File indexing completed on 2024-12-29 05:27:23

 <?php
 namespace GuzzleHttp\Psr7;
 
 use Psr\Http\Message\MessageInterface;
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamInterface;
 use Psr\Http\Message\UriInterface;
 
 /**
  * Returns the string representation of an HTTP message.
  *
  * @param MessageInterface $message Message to convert to a string.
  *
  * @return string
  */
 function str(MessageInterface $message)
 {
     if ($message instanceof RequestInterface) {
         $msg = trim($message->getMethod() . ' '
                 . $message->getRequestTarget())
             . ' HTTP/' . $message->getProtocolVersion();
         if (!$message->hasHeader('host')) {
             $msg .= "\r\nHost: " . $message->getUri()->getHost();
         }
     } elseif ($message instanceof ResponseInterface) {
         $msg = 'HTTP/' . $message->getProtocolVersion() . ' '
             . $message->getStatusCode() . ' '
             . $message->getReasonPhrase();
     } else {
         throw new \InvalidArgumentException('Unknown message type');
     }
 
     foreach ($message->getHeaders() as $name => $values) {
         $msg .= "\r\n{$name}: " . implode(', ', $values);
     }
 
     return "{$msg}\r\n\r\n" . $message->getBody();
 }
 
 /**
  * Returns a UriInterface for the given value.
  *
  * This function accepts a string or {@see Psr\Http\Message\UriInterface} and
  * returns a UriInterface for the given value. If the value is already a
  * `UriInterface`, it is returned as-is.
  *
  * @param string|UriInterface $uri
  *
  * @return UriInterface
  * @throws \InvalidArgumentException
  */
 function uri_for($uri)
 {
     if ($uri instanceof UriInterface) {
         return $uri;
     } elseif (is_string($uri)) {
         return new Uri($uri);
     }
 
     throw new \InvalidArgumentException('URI must be a string or UriInterface');
 }
 
 /**
  * Create a new stream based on the input type.
  *
  * Options is an associative array that can contain the following keys:
  * - metadata: Array of custom metadata.
  * - size: Size of the stream.
  *
  * @param resource|string|null|int|float|bool|StreamInterface|callable $resource Entity body data
  * @param array                                                        $options  Additional options
  *
  * @return Stream
  * @throws \InvalidArgumentException if the $resource arg is not valid.
  */
 function stream_for($resource = '', array $options = [])
 {
     if (is_scalar($resource)) {
         $stream = fopen('php://temp', 'r+');
         if ($resource !== '') {
             fwrite($stream, $resource);
             fseek($stream, 0);
         }
         return new Stream($stream, $options);
     }
 
     switch (gettype($resource)) {
         case 'resource':
             return new Stream($resource, $options);
         case 'object':
             if ($resource instanceof StreamInterface) {
                 return $resource;
             } elseif ($resource instanceof \Iterator) {
                 return new PumpStream(function () use ($resource) {
                     if (!$resource->valid()) {
                         return false;
                     }
                     $result = $resource->current();
                     $resource->next();
                     return $result;
                 }, $options);
             } elseif (method_exists($resource, '__toString')) {
                 return stream_for((string) $resource, $options);
             }
             break;
         case 'NULL':
             return new Stream(fopen('php://temp', 'r+'), $options);
     }
 
     if (is_callable($resource)) {
         return new PumpStream($resource, $options);
     }
 
     throw new \InvalidArgumentException('Invalid resource type: ' . gettype($resource));
 }
 
 /**
  * Parse an array of header values containing ";" separated data into an
  * array of associative arrays representing the header key value pair
  * data of the header. When a parameter does not contain a value, but just
  * contains a key, this function will inject a key with a '' string value.
  *
  * @param string|array $header Header to parse into components.
  *
  * @return array Returns the parsed header values.
  */
 function parse_header($header)
 {
     static $trimmed = "\"'  \n\t\r";
     $params = $matches = [];
 
     foreach (normalize_header($header) as $val) {
         $part = [];
         foreach (preg_split('/;(?=([^"]*"[^"]*")*[^"]*$)/', $val) as $kvp) {
             if (preg_match_all('/<[^>]+>|[^=]+/', $kvp, $matches)) {
                 $m = $matches[0];
                 if (isset($m[1])) {
                     $part[trim($m[0], $trimmed)] = trim($m[1], $trimmed);
                 } else {
                     $part[] = trim($m[0], $trimmed);
                 }
             }
         }
         if ($part) {
             $params[] = $part;
         }
     }
 
     return $params;
 }
 
 /**
  * Converts an array of header values that may contain comma separated
  * headers into an array of headers with no comma separated values.
  *
  * @param string|array $header Header to normalize.
  *
  * @return array Returns the normalized header field values.
  */
 function normalize_header($header)
 {
     if (!is_array($header)) {
         return array_map('trim', explode(',', $header));
     }
 
     $result = [];
     foreach ($header as $value) {
         foreach ((array) $value as $v) {
             if (strpos($v, ',') === false) {
                 $result[] = $v;
                 continue;
             }
             foreach (preg_split('/,(?=([^"]*"[^"]*")*[^"]*$)/', $v) as $vv) {
                 $result[] = trim($vv);
             }
         }
     }
 
     return $result;
 }
 
 /**
  * Clone and modify a request with the given changes.
  *
  * The changes can be one of:
  * - method: (string) Changes the HTTP method.
  * - set_headers: (array) Sets the given headers.
  * - remove_headers: (array) Remove the given headers.
  * - body: (mixed) Sets the given body.
  * - uri: (UriInterface) Set the URI.
  * - query: (string) Set the query string value of the URI.
  * - version: (string) Set the protocol version.
  *
  * @param RequestInterface $request Request to clone and modify.
  * @param array            $changes Changes to apply.
  *
  * @return RequestInterface
  */
 function modify_request(RequestInterface $request, array $changes)
 {
     if (!$changes) {
         return $request;
     }
 
     $headers = $request->getHeaders();
 
     if (!isset($changes['uri'])) {
         $uri = $request->getUri();
     } else {
         // Remove the host header if one is on the URI
         if ($host = $changes['uri']->getHost()) {
             $changes['set_headers']['Host'] = $host;
 
             if ($port = $changes['uri']->getPort()) {
                 $standardPorts = ['http' => 80, 'https' => 443];
                 $scheme = $changes['uri']->getScheme();
                 if (isset($standardPorts[$scheme]) && $port != $standardPorts[$scheme]) {
                     $changes['set_headers']['Host'] .= ':'.$port;
                 }
             }
         }
         $uri = $changes['uri'];
     }
 
     if (!empty($changes['remove_headers'])) {
         $headers = _caseless_remove($changes['remove_headers'], $headers);
     }
 
     if (!empty($changes['set_headers'])) {
         $headers = _caseless_remove(array_keys($changes['set_headers']), $headers);
         $headers = $changes['set_headers'] + $headers;
     }
 
     if (isset($changes['query'])) {
         $uri = $uri->withQuery($changes['query']);
     }
 
     if ($request instanceof ServerRequestInterface) {
         return new ServerRequest(
             isset($changes['method']) ? $changes['method'] : $request->getMethod(),
             $uri,
             $headers,
             isset($changes['body']) ? $changes['body'] : $request->getBody(),
             isset($changes['version'])
                 ? $changes['version']
                 : $request->getProtocolVersion(),
             $request->getServerParams()
         );
     }
 
     return new Request(
         isset($changes['method']) ? $changes['method'] : $request->getMethod(),
         $uri,
         $headers,
         isset($changes['body']) ? $changes['body'] : $request->getBody(),
         isset($changes['version'])
             ? $changes['version']
             : $request->getProtocolVersion()
     );
 }
 
 /**
  * Attempts to rewind a message body and throws an exception on failure.
  *
  * The body of the message will only be rewound if a call to `tell()` returns a
  * value other than `0`.
  *
  * @param MessageInterface $message Message to rewind
  *
  * @throws \RuntimeException
  */
 function rewind_body(MessageInterface $message)
 {
     $body = $message->getBody();
 
     if ($body->tell()) {
         $body->rewind();
     }
 }
 
 /**
  * Safely opens a PHP stream resource using a filename.
  *
  * When fopen fails, PHP normally raises a warning. This function adds an
  * error handler that checks for errors and throws an exception instead.
  *
  * @param string $filename File to open
  * @param string $mode     Mode used to open the file
  *
  * @return resource
  * @throws \RuntimeException if the file cannot be opened
  */
 function try_fopen($filename, $mode)
 {
     $ex = null;
     set_error_handler(function () use ($filename, $mode, &$ex) {
         $ex = new \RuntimeException(sprintf(
             'Unable to open %s using mode %s: %s',
             $filename,
             $mode,
             func_get_args()[1]
         ));
     });
 
     $handle = fopen($filename, $mode);
     restore_error_handler();
 
     if ($ex) {
         /** @var $ex \RuntimeException */
         throw $ex;
     }
 
     return $handle;
 }
 
 /**
  * Copy the contents of a stream into a string until the given number of
  * bytes have been read.
  *
  * @param StreamInterface $stream Stream to read
  * @param int             $maxLen Maximum number of bytes to read. Pass -1
  *                                to read the entire stream.
  * @return string
  * @throws \RuntimeException on error.
  */
 function copy_to_string(StreamInterface $stream, $maxLen = -1)
 {
     $buffer = '';
 
     if ($maxLen === -1) {
         while (!$stream->eof()) {
             $buf = $stream->read(1048576);
             // Using a loose equality here to match on '' and false.
             if ($buf == null) {
                 break;
             }
             $buffer .= $buf;
         }
         return $buffer;
     }
 
     $len = 0;
     while (!$stream->eof() && $len < $maxLen) {
         $buf = $stream->read($maxLen - $len);
         // Using a loose equality here to match on '' and false.
         if ($buf == null) {
             break;
         }
         $buffer .= $buf;
         $len = strlen($buffer);
     }
 
     return $buffer;
 }
 
 /**
  * Copy the contents of a stream into another stream until the given number
  * of bytes have been read.
  *
  * @param StreamInterface $source Stream to read from
  * @param StreamInterface $dest   Stream to write to
  * @param int             $maxLen Maximum number of bytes to read. Pass -1
  *                                to read the entire stream.
  *
  * @throws \RuntimeException on error.
  */
 function copy_to_stream(
     StreamInterface $source,
     StreamInterface $dest,
     $maxLen = -1
 ) {
     $bufferSize = 8192;
 
     if ($maxLen === -1) {
         while (!$source->eof()) {
             if (!$dest->write($source->read($bufferSize))) {
                 break;
             }
         }
     } else {
         $remaining = $maxLen;
         while ($remaining > 0 && !$source->eof()) {
             $buf = $source->read(min($bufferSize, $remaining));
             $len = strlen($buf);
             if (!$len) {
                 break;
             }
             $remaining -= $len;
             $dest->write($buf);
         }
     }
 }
 
 /**
  * Calculate a hash of a Stream
  *
  * @param StreamInterface $stream    Stream to calculate the hash for
  * @param string          $algo      Hash algorithm (e.g. md5, crc32, etc)
  * @param bool            $rawOutput Whether or not to use raw output
  *
  * @return string Returns the hash of the stream
  * @throws \RuntimeException on error.
  */
 function hash(
     StreamInterface $stream,
     $algo,
     $rawOutput = false
 ) {
     $pos = $stream->tell();
 
     if ($pos > 0) {
         $stream->rewind();
     }
 
     $ctx = hash_init($algo);
     while (!$stream->eof()) {
         hash_update($ctx, $stream->read(1048576));
     }
 
     $out = hash_final($ctx, (bool) $rawOutput);
     $stream->seek($pos);
 
     return $out;
 }
 
 /**
  * Read a line from the stream up to the maximum allowed buffer length
  *
  * @param StreamInterface $stream    Stream to read from
  * @param int             $maxLength Maximum buffer length
  *
  * @return string|bool
  */
 function readline(StreamInterface $stream, $maxLength = null)
 {
     $buffer = '';
     $size = 0;
 
     while (!$stream->eof()) {
         // Using a loose equality here to match on '' and false.
         if (null == ($byte = $stream->read(1))) {
             return $buffer;
         }
         $buffer .= $byte;
         // Break when a new line is found or the max length - 1 is reached
         if ($byte === "\n" || ++$size === $maxLength - 1) {
             break;
         }
     }
 
     return $buffer;
 }
 
 /**
  * Parses a request message string into a request object.
  *
  * @param string $message Request message string.
  *
  * @return Request
  */
 function parse_request($message)
 {
     $data = _parse_message($message);
     $matches = [];
     if (!preg_match('/^[\S]+\s+([a-zA-Z]+:\/\/|\/).*/', $data['start-line'], $matches)) {
         throw new \InvalidArgumentException('Invalid request string');
     }
     $parts = explode(' ', $data['start-line'], 3);
     $version = isset($parts[2]) ? explode('/', $parts[2])[1] : '1.1';
 
     $request = new Request(
         $parts[0],
         $matches[1] === '/' ? _parse_request_uri($parts[1], $data['headers']) : $parts[1],
         $data['headers'],
         $data['body'],
         $version
     );
 
     return $matches[1] === '/' ? $request : $request->withRequestTarget($parts[1]);
 }
 
 /**
  * Parses a response message string into a response object.
  *
  * @param string $message Response message string.
  *
  * @return Response
  */
 function parse_response($message)
 {
     $data = _parse_message($message);
     // According to https://tools.ietf.org/html/rfc7230#section-3.1.2 the space
     // between status-code and reason-phrase is required. But browsers accept
     // responses without space and reason as well.
     if (!preg_match('/^HTTP\/.* [0-9]{3}( .*|$)/', $data['start-line'])) {
         throw new \InvalidArgumentException('Invalid response string');
     }
     $parts = explode(' ', $data['start-line'], 3);
 
     return new Response(
         $parts[1],
         $data['headers'],
         $data['body'],
         explode('/', $parts[0])[1],
         isset($parts[2]) ? $parts[2] : null
     );
 }
 
 /**
  * Parse a query string into an associative array.
  *
  * If multiple values are found for the same key, the value of that key
  * value pair will become an array. This function does not parse nested
  * PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will
  * be parsed into ['foo[a]' => '1', 'foo[b]' => '2']).
  *
  * @param string      $str         Query string to parse
  * @param bool|string $urlEncoding How the query string is encoded
  *
  * @return array
  */
 function parse_query($str, $urlEncoding = true)
 {
     $result = [];
 
     if ($str === '') {
         return $result;
     }
 
     if ($urlEncoding === true) {
         $decoder = function ($value) {
             return rawurldecode(str_replace('+', ' ', $value));
         };
     } elseif ($urlEncoding == PHP_QUERY_RFC3986) {
         $decoder = 'rawurldecode';
     } elseif ($urlEncoding == PHP_QUERY_RFC1738) {
         $decoder = 'urldecode';
     } else {
         $decoder = function ($str) { return $str; };
     }
 
     foreach (explode('&', $str) as $kvp) {
         $parts = explode('=', $kvp, 2);
         $key = $decoder($parts[0]);
         $value = isset($parts[1]) ? $decoder($parts[1]) : null;
         if (!isset($result[$key])) {
             $result[$key] = $value;
         } else {
             if (!is_array($result[$key])) {
                 $result[$key] = [$result[$key]];
             }
             $result[$key][] = $value;
         }
     }
 
     return $result;
 }
 
 /**
  * Build a query string from an array of key value pairs.
  *
  * This function can use the return value of parse_query() to build a query
  * string. This function does not modify the provided keys when an array is
  * encountered (like http_build_query would).
  *
  * @param array     $params   Query string parameters.
  * @param int|false $encoding Set to false to not encode, PHP_QUERY_RFC3986
  *                            to encode using RFC3986, or PHP_QUERY_RFC1738
  *                            to encode using RFC1738.
  * @return string
  */
 function build_query(array $params, $encoding = PHP_QUERY_RFC3986)
 {
     if (!$params) {
         return '';
     }
 
     if ($encoding === false) {
         $encoder = function ($str) { return $str; };
     } elseif ($encoding === PHP_QUERY_RFC3986) {
         $encoder = 'rawurlencode';
     } elseif ($encoding === PHP_QUERY_RFC1738) {
         $encoder = 'urlencode';
     } else {
         throw new \InvalidArgumentException('Invalid type');
     }
 
     $qs = '';
     foreach ($params as $k => $v) {
         $k = $encoder($k);
         if (!is_array($v)) {
             $qs .= $k;
             if ($v !== null) {
                 $qs .= '=' . $encoder($v);
             }
             $qs .= '&';
         } else {
             foreach ($v as $vv) {
                 $qs .= $k;
                 if ($vv !== null) {
                     $qs .= '=' . $encoder($vv);
                 }
                 $qs .= '&';
             }
         }
     }
 
     return $qs ? (string) substr($qs, 0, -1) : '';
 }
 
 /**
  * Determines the mimetype of a file by looking at its extension.
  *
  * @param $filename
  *
  * @return null|string
  */
 function mimetype_from_filename($filename)
 {
     return mimetype_from_extension(pathinfo($filename, PATHINFO_EXTENSION));
 }
 
 /**
  * Maps a file extensions to a mimetype.
  *
  * @param $extension string The file extension.
  *
  * @return string|null
  * @link http://svn.apache.org/repos/asf/httpd/httpd/branches/1.3.x/conf/mime.types
  */
 function mimetype_from_extension($extension)
 {
     static $mimetypes = [
         '7z' => 'application/x-7z-compressed',
         'aac' => 'audio/x-aac',
         'ai' => 'application/postscript',
         'aif' => 'audio/x-aiff',
         'asc' => 'text/plain',
         'asf' => 'video/x-ms-asf',
         'atom' => 'application/atom+xml',
         'avi' => 'video/x-msvideo',
         'bmp' => 'image/bmp',
         'bz2' => 'application/x-bzip2',
         'cer' => 'application/pkix-cert',
         'crl' => 'application/pkix-crl',
         'crt' => 'application/x-x509-ca-cert',
         'css' => 'text/css',
         'csv' => 'text/csv',
         'cu' => 'application/cu-seeme',
         'deb' => 'application/x-debian-package',
         'doc' => 'application/msword',
         'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
         'dvi' => 'application/x-dvi',
         'eot' => 'application/vnd.ms-fontobject',
         'eps' => 'application/postscript',
         'epub' => 'application/epub+zip',
         'etx' => 'text/x-setext',
         'flac' => 'audio/flac',
         'flv' => 'video/x-flv',
         'gif' => 'image/gif',
         'gz' => 'application/gzip',
         'htm' => 'text/html',
         'html' => 'text/html',
         'ico' => 'image/x-icon',
         'ics' => 'text/calendar',
         'ini' => 'text/plain',
         'iso' => 'application/x-iso9660-image',
         'jar' => 'application/java-archive',
         'jpe' => 'image/jpeg',
         'jpeg' => 'image/jpeg',
         'jpg' => 'image/jpeg',
         'js' => 'text/javascript',
         'json' => 'application/json',
         'latex' => 'application/x-latex',
         'log' => 'text/plain',
         'm4a' => 'audio/mp4',
         'm4v' => 'video/mp4',
         'mid' => 'audio/midi',
         'midi' => 'audio/midi',
         'mov' => 'video/quicktime',
         'mp3' => 'audio/mpeg',
         'mp4' => 'video/mp4',
         'mp4a' => 'audio/mp4',
         'mp4v' => 'video/mp4',
         'mpe' => 'video/mpeg',
         'mpeg' => 'video/mpeg',
         'mpg' => 'video/mpeg',
         'mpg4' => 'video/mp4',
         'oga' => 'audio/ogg',
         'ogg' => 'audio/ogg',
         'ogv' => 'video/ogg',
         'ogx' => 'application/ogg',
         'pbm' => 'image/x-portable-bitmap',
         'pdf' => 'application/pdf',
         'pgm' => 'image/x-portable-graymap',
         'png' => 'image/png',
         'pnm' => 'image/x-portable-anymap',
         'ppm' => 'image/x-portable-pixmap',
         'ppt' => 'application/vnd.ms-powerpoint',
         'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
         'ps' => 'application/postscript',
         'qt' => 'video/quicktime',
         'rar' => 'application/x-rar-compressed',
         'ras' => 'image/x-cmu-raster',
         'rss' => 'application/rss+xml',
         'rtf' => 'application/rtf',
         'sgm' => 'text/sgml',
         'sgml' => 'text/sgml',
         'svg' => 'image/svg+xml',
         'swf' => 'application/x-shockwave-flash',
         'tar' => 'application/x-tar',
         'tif' => 'image/tiff',
         'tiff' => 'image/tiff',
         'torrent' => 'application/x-bittorrent',
         'ttf' => 'application/x-font-ttf',
         'txt' => 'text/plain',
         'wav' => 'audio/x-wav',
         'webm' => 'video/webm',
         'wma' => 'audio/x-ms-wma',
         'wmv' => 'video/x-ms-wmv',
         'woff' => 'application/x-font-woff',
         'wsdl' => 'application/wsdl+xml',
         'xbm' => 'image/x-xbitmap',
         'xls' => 'application/vnd.ms-excel',
         'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
         'xml' => 'application/xml',
         'xpm' => 'image/x-xpixmap',
         'xwd' => 'image/x-xwindowdump',
         'yaml' => 'text/yaml',
         'yml' => 'text/yaml',
         'zip' => 'application/zip',
     ];
 
     $extension = strtolower($extension);
 
     return isset($mimetypes[$extension])
         ? $mimetypes[$extension]
         : null;
 }
 
 /**
  * Parses an HTTP message into an associative array.
  *
  * The array contains the "start-line" key containing the start line of
  * the message, "headers" key containing an associative array of header
  * array values, and a "body" key containing the body of the message.
  *
  * @param string $message HTTP request or response to parse.
  *
  * @return array
  * @internal
  */
 function _parse_message($message)
 {
     if (!$message) {
         throw new \InvalidArgumentException('Invalid message');
     }
 
     // Iterate over each line in the message, accounting for line endings
     $lines = preg_split('/(\\r?\\n)/', $message, -1, PREG_SPLIT_DELIM_CAPTURE);
     $result = ['start-line' => array_shift($lines), 'headers' => [], 'body' => ''];
     array_shift($lines);
 
     for ($i = 0, $totalLines = count($lines); $i < $totalLines; $i += 2) {
         $line = $lines[$i];
         // If two line breaks were encountered, then this is the end of body
         if (empty($line)) {
             if ($i < $totalLines - 1) {
                 $result['body'] = implode('', array_slice($lines, $i + 2));
             }
             break;
         }
         if (strpos($line, ':')) {
             $parts = explode(':', $line, 2);
             $key = trim($parts[0]);
             $value = isset($parts[1]) ? trim($parts[1]) : '';
             $result['headers'][$key][] = $value;
         }
     }
 
     return $result;
 }
 
 /**
  * Constructs a URI for an HTTP request message.
  *
  * @param string $path    Path from the start-line
  * @param array  $headers Array of headers (each value an array).
  *
  * @return string
  * @internal
  */
 function _parse_request_uri($path, array $headers)
 {
     $hostKey = array_filter(array_keys($headers), function ($k) {
         return strtolower($k) === 'host';
     });
 
     // If no host is found, then a full URI cannot be constructed.
     if (!$hostKey) {
         return $path;
     }
 
     $host = $headers[reset($hostKey)][0];
     $scheme = substr($host, -4) === ':443' ? 'https' : 'http';
 
     return $scheme . '://' . $host . '/' . ltrim($path, '/');
 }
 
 /** @internal */
 function _caseless_remove($keys, array $data)
 {
     $result = [];
 
     foreach ($keys as &$key) {
         $key = strtolower($key);
     }
 
     foreach ($data as $k => $v) {
         if (!in_array(strtolower($k), $keys)) {
             $result[$k] = $v;
         }
     }
 
     return $result;
 }