ACIL FM

Nama	Ukuran	Aksi
Exception	-	Open
AppendStream.php	5.81 MB	View DL Edit
BufferStream.php	3.14 MB	View DL Edit
CachingStream.php	4.49 MB	View DL Edit
DroppingStream.php	1.17 MB	View DL Edit
FnStream.php	4.21 MB	View DL Edit
Header.php	3.85 MB	View DL Edit
HttpFactory.php	3 MB	View DL Edit
InflateStream.php	1.38 MB	View DL Edit
LazyOpenStream.php	1.06 MB	View DL Edit
LimitStream.php	4.2 MB	View DL Edit
Message.php	8.14 MB	View DL Edit
MessageTrait.php	7.56 MB	View DL Edit
MimeType.php	53.75 MB	View DL Edit
MultipartStream.php	5.06 MB	View DL Edit
NoSeekStream.php	524 B	View DL Edit
PumpStream.php	4.49 MB	View DL Edit
Query.php	3.95 MB	View DL Edit
Request.php	3.82 MB	View DL Edit
Response.php	4.79 MB	View DL Edit
Rfc7230.php	661 B	View DL Edit
ServerRequest.php	9.33 MB	View DL Edit
Stream.php	7.21 MB	View DL Edit
StreamDecoratorTrait.php	3.24 MB	View DL Edit
StreamWrapper.php	4.53 MB	View DL Edit
UploadedFile.php	4.75 MB	View DL Edit
Uri.php	21.44 MB	View DL Edit
UriComparator.php	1.12 MB	View DL Edit
UriNormalizer.php	8.26 MB	View DL Edit
UriResolver.php	8.38 MB	View DL Edit
Utils.php	15.57 MB	View DL Edit

Edit file: /home/mhhtmff/app/NH-HR-test-old/vendor/guzzlehttp/psr7/src/Message.php

<?php

declare(strict_types=1);

namespace GuzzleHttp\Psr7;

use Psr\Http\Message\MessageInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

final class Message
{
    /**
     * Returns the string representation of an HTTP message.
     *
     * @param MessageInterface $message Message to convert to a string.
     */
    public static function toString(MessageInterface $message): string
    {
        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) {
            if (is_string($name) && strtolower($name) === 'set-cookie') {
                foreach ($values as $value) {
                    $msg .= "\r\n{$name}: ".$value;
                }
            } else {
                $msg .= "\r\n{$name}: ".implode(', ', $values);
            }
        }

return "{$msg}\r\n\r\n".$message->getBody();
    }

/**
     * Get a short summary of the message body.
     *
     * Will return `null` if the response is not printable.
     *
     * @param MessageInterface $message    The message to get the body summary
     * @param int              $truncateAt The maximum allowed size of the summary
     */
    public static function bodySummary(MessageInterface $message, int $truncateAt = 120): ?string
    {
        $body = $message->getBody();

if (!$body->isSeekable() || !$body->isReadable()) {
            return null;
        }

$size = $body->getSize();

if ($size === 0) {
            return null;
        }

$body->rewind();
        $summary = $body->read($truncateAt);
        $body->rewind();

if ($size > $truncateAt) {
            $summary .= ' (truncated...)';
        }

// Matches any printable character, including unicode characters:
        // letters, marks, numbers, punctuation, spacing, and separators.
        if (preg_match('/[^\pL\pM\pN\pP\pS\pZ\n\r\t]/u', $summary) !== 0) {
            return null;
        }

return $summary;
    }

/**
     * 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
     */
    public static function rewindBody(MessageInterface $message): void
    {
        $body = $message->getBody();

if ($body->tell()) {
            $body->rewind();
        }
    }

/**
     * 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.
     */
    public static function parseMessage(string $message): array
    {
        if (!$message) {
            throw new \InvalidArgumentException('Invalid message');
        }

$message = ltrim($message, "\r\n");

$messageParts = preg_split("/\r?\n\r?\n/", $message, 2);

if ($messageParts === false || count($messageParts) !== 2) {
            throw new \InvalidArgumentException('Invalid message: Missing header delimiter');
        }

[$rawHeaders, $body] = $messageParts;
        $rawHeaders .= "\r\n"; // Put back the delimiter we split previously
        $headerParts = preg_split("/\r?\n/", $rawHeaders, 2);

if ($headerParts === false || count($headerParts) !== 2) {
            throw new \InvalidArgumentException('Invalid message: Missing status line');
        }

[$startLine, $rawHeaders] = $headerParts;

if (preg_match("/(?:^HTTP\/|^[A-Z]+ \S+ HTTP\/)(\d+(?:\.\d+)?)/i", $startLine, $matches) && $matches[1] === '1.0') {
            // Header folding is deprecated for HTTP/1.1, but allowed in HTTP/1.0
            $rawHeaders = preg_replace(Rfc7230::HEADER_FOLD_REGEX, ' ', $rawHeaders);
        }

/** @var array[] $headerLines */
        $count = preg_match_all(Rfc7230::HEADER_REGEX, $rawHeaders, $headerLines, PREG_SET_ORDER);

// If these aren't the same, then one line didn't match and there's an invalid header.
        if ($count !== substr_count($rawHeaders, "\n")) {
            // Folding is deprecated, see https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4
            if (preg_match(Rfc7230::HEADER_FOLD_REGEX, $rawHeaders)) {
                throw new \InvalidArgumentException('Invalid header syntax: Obsolete line folding');
            }

throw new \InvalidArgumentException('Invalid header syntax');
        }

$headers = [];

foreach ($headerLines as $headerLine) {
            $headers[$headerLine[1]][] = $headerLine[2];
        }

return [
            'start-line' => $startLine,
            'headers' => $headers,
            'body' => $body,
        ];
    }

/**
     * 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).
     */
    public static function parseRequestUri(string $path, array $headers): string
    {
        $hostKey = array_filter(array_keys($headers), function ($k) {
            // Numeric array keys are converted to int by PHP.
            $k = (string) $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, '/');
    }

/**
     * Parses a request message string into a request object.
     *
     * @param string $message Request message string.
     */
    public static function parseRequest(string $message): RequestInterface
    {
        $data = self::parseMessage($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] === '/' ? self::parseRequestUri($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.
     */
    public static function parseResponse(string $message): ResponseInterface
    {
        $data = self::parseMessage($message);
        // According to https://datatracker.ietf.org/doc/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: '.$data['start-line']);
        }
        $parts = explode(' ', $data['start-line'], 3);

return new Response(
            (int) $parts[1],
            $data['headers'],
            $data['body'],
            explode('/', $parts[0])[1],
            $parts[2] ?? null
        );
    }
}

Batal