@opra/common 0.10.2 → 0.12.0

package/{cjs/http/enums/http-status.enum.js → esm/http/enums/http-status-codes.enum.js}

@@ -1,131 +1,128 @@
-"use strict";
 // noinspection JSUnusedGlobalSymbols
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpStatus = void 0;
 /**
  * https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#successful_responses
  */
-var HttpStatus;
-(function (HttpStatus) {
+export var HttpStatusCodes;
+(function (HttpStatusCodes) {
     /* *** Information responses *** */
     /**
      * This interim response indicates that the client should continue the request or
      * ignore the response if the request is already finished.
      */
-    HttpStatus[HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    HttpStatusCodes[HttpStatusCodes["CONTINUE"] = 100] = "CONTINUE";
     /**
      * This code is sent in response to an Upgrade request header from the client and
      * indicates the protocol the server is switching to.
      */
-    HttpStatus[HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HttpStatusCodes[HttpStatusCodes["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
     /**
      * This code indicates that the server has received and is processing the request, but no response is available yet.
      */
-    HttpStatus[HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    HttpStatusCodes[HttpStatusCodes["PROCESSING"] = 102] = "PROCESSING";
     /**
      * This status code is primarily intended to be used with the Link header, letting the user agent
      * start preloading resources while the server prepares a response.
      */
-    HttpStatus[HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    HttpStatusCodes[HttpStatusCodes["EARLYHINTS"] = 103] = "EARLYHINTS";
     /* *** Successful responses *** */
     /**
      * The request succeeded.
      */
-    HttpStatus[HttpStatus["OK"] = 200] = "OK";
+    HttpStatusCodes[HttpStatusCodes["OK"] = 200] = "OK";
     /**
      * The request succeeded, and a new resource was created as a result.
      * This is typically the response sent after POST requests, or some PUT requests.
      */
-    HttpStatus[HttpStatus["CREATED"] = 201] = "CREATED";
+    HttpStatusCodes[HttpStatusCodes["CREATED"] = 201] = "CREATED";
     /**
      * The request has been received but not yet acted upon. It is noncommittal,
      * since there is no way in HTTP to later send an asynchronous response indicating
      * the outcome of the request. It is intended for cases where another process or
      * server handles the request, or for batch processing.
      */
-    HttpStatus[HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HttpStatusCodes[HttpStatusCodes["ACCEPTED"] = 202] = "ACCEPTED";
     /**
      * This response code means the returned metadata is not exactly the same as is available from
      * the origin server, but is collected from a local or a third-party copy. This is mostly used
      * for mirrors or backups of another resource. Except for that specific case, the 200 OK
      * response is preferred to this status.
      */
-    HttpStatus[HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    HttpStatusCodes[HttpStatusCodes["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
     /**
      * There is no content to send for this request, but the headers may be useful.
      * The user agent may update its cached headers for this resource with the new ones.
      */
-    HttpStatus[HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["NO_CONTENT"] = 204] = "NO_CONTENT";
     /**
      * Tells the user agent to reset the document which sent this request.
      */
-    HttpStatus[HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["RESET_CONTENT"] = 205] = "RESET_CONTENT";
     /**
      * This response code is used when the Range header is sent from the client to request only part of a resource.
      */
-    HttpStatus[HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HttpStatusCodes[HttpStatusCodes["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
     /* *** Redirection messages *** */
     /**
      * The request has more than one possible response. The user agent or user should choose one of them.
      * (There is no standardized way of choosing one of the responses, but HTML links to the possibilities
      * are recommended so the user can pick.)
      */
-    HttpStatus[HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    HttpStatusCodes[HttpStatusCodes["AMBIGUOUS"] = 300] = "AMBIGUOUS";
     /**
      * The URL of the requested resource has been changed permanently. The new URL is given in the response.
      */
-    HttpStatus[HttpStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HttpStatusCodes[HttpStatusCodes["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
     /**
      * This response code means that the URI of requested resource has been changed temporarily.
      * Further changes in the URI might be made in the future. Therefore, this same URI should
      * be used by the client in future requests.
      */
-    HttpStatus[HttpStatus["FOUND"] = 302] = "FOUND";
+    HttpStatusCodes[HttpStatusCodes["FOUND"] = 302] = "FOUND";
     /**
      * This is used for caching purposes. It tells the client that the response has not been modified,
      * so the client can continue to use the same cached version of the response.
      */
-    HttpStatus[HttpStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HttpStatusCodes[HttpStatusCodes["SEE_OTHER"] = 303] = "SEE_OTHER";
     /**
      *
      */
-    HttpStatus[HttpStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HttpStatusCodes[HttpStatusCodes["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
     /**
      * The server sends this response to direct the client to get the requested resource at another
      * URI with same method that was used in the prior request. This has the same semantics as
      * the 302 Found HTTP response code, with the exception that the user agent must not change
      * the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.
      */
-    HttpStatus[HttpStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HttpStatusCodes[HttpStatusCodes["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
     /**
      * This means that the resource is now permanently located at another URI, specified by the Location:
      * HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code,
      * with the exception that the user agent must not change the HTTP method used: if a POST was used
      * in the first request, a POST must be used in the second request.
      */
-    HttpStatus[HttpStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HttpStatusCodes[HttpStatusCodes["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
     /* *** Client error responses *** */
     /**
      * The server cannot or will not process the request due to something that is perceived to be a client error
      * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
      */
-    HttpStatus[HttpStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HttpStatusCodes[HttpStatusCodes["BAD_REQUEST"] = 400] = "BAD_REQUEST";
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated".
      * That is, the client must authenticate itself to get the requested response.
      */
-    HttpStatus[HttpStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HttpStatusCodes[HttpStatusCodes["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
     /**
      * This response code is reserved for future use. The initial aim for creating this code was using
      * it for digital payment systems, however this status code is used very rarely and no standard convention exists.
      */
-    HttpStatus[HttpStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
     /**
      * The client does not have access rights to the content; that is, it is unauthorized,
      * so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
      * the client's identity is known to the server.
      */
-    HttpStatus[HttpStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HttpStatusCodes[HttpStatusCodes["FORBIDDEN"] = 403] = "FORBIDDEN";
     /**
      * The server can not find the requested resource. In the browser, this means the URL is not recognized.
      * In an API, this can also mean that the endpoint is valid but the resource itself does not exist.
@@ -133,21 +130,21 @@ var HttpStatus;
      * from an unauthorized client. This response code is probably the most well known due to its
      * frequent occurrence on the web.
      */
-    HttpStatus[HttpStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HttpStatusCodes[HttpStatusCodes["NOT_FOUND"] = 404] = "NOT_FOUND";
     /**
      * The request method is known by the server but is not supported by the target resource.
      * For example, an API may not allow calling DELETE to remove a resource.
      */
-    HttpStatus[HttpStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HttpStatusCodes[HttpStatusCodes["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
     /**
      * This response is sent when the web server, after performing server-driven content negotiation,
      * doesn't find any content that conforms to the criteria given by the user agent.
      */
-    HttpStatus[HttpStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HttpStatusCodes[HttpStatusCodes["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
     /**
      * This is similar to 401 Unauthorized but authentication is needed to be done by a proxy.
      */
-    HttpStatus[HttpStatus["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
     /**
      * This response is sent on an idle connection by some servers, even without any previous request by the client.
      * It means that the server would like to shut down this unused connection.
@@ -155,107 +152,107 @@ var HttpStatus;
      * like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing.
      * Also note that some servers merely shut down the connection without sending this message.
      */
-    HttpStatus[HttpStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HttpStatusCodes[HttpStatusCodes["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
-    HttpStatus[HttpStatus["CONFLICT"] = 409] = "CONFLICT";
+    HttpStatusCodes[HttpStatusCodes["CONFLICT"] = 409] = "CONFLICT";
     /**
      * This response is sent when the requested content has been permanently deleted from server,
      * with no forwarding address. Clients are expected to remove their caches and links to the resource.
      * The HTTP specification intends this status code to be used for "limited-time, promotional services".
      * APIs should not feel compelled to indicate resources that have been deleted with this status code.
      */
-    HttpStatus[HttpStatus["GONE"] = 410] = "GONE";
+    HttpStatusCodes[HttpStatusCodes["GONE"] = 410] = "GONE";
     /**
      * Server rejected the request because the Content-Length header field is not defined and the server requires it.
      */
-    HttpStatus[HttpStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
     /**
      * The client has indicated preconditions in its headers which the server does not meet.
      */
-    HttpStatus[HttpStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HttpStatusCodes[HttpStatusCodes["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
     /**
      * Request entity is larger than limits defined by server. The server might close the connection or
      * return an Retry-After header field.
      */
-    HttpStatus[HttpStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HttpStatusCodes[HttpStatusCodes["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
     /**
      * The URI requested by the client is longer than the server is willing to interpret.
      */
-    HttpStatus[HttpStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HttpStatusCodes[HttpStatusCodes["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
     /**
      * The media format of the requested data is not supported by the server, so the server is rejecting the request.
      */
-    HttpStatus[HttpStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HttpStatusCodes[HttpStatusCodes["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
     /**
      * The range specified by the Range header field in the request cannot be fulfilled.
      * It's possible that the range is outside the size of the target URI's data.
      */
-    HttpStatus[HttpStatus["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    HttpStatusCodes[HttpStatusCodes["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
     /**
      * This response code means the expectation indicated by the Expect request header field cannot be met by the server.
      */
-    HttpStatus[HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HttpStatusCodes[HttpStatusCodes["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
     /**
      * The server refuses the attempt to brew coffee with a teapot.
      */
-    HttpStatus[HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    HttpStatusCodes[HttpStatusCodes["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
     /**
      * The request was directed at a server that is not able to produce a response.
      * This can be sent by a server that is not configured to produce responses for
      * the combination of scheme and authority that are included in the request URI.
      */
-    HttpStatus[HttpStatus["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+    HttpStatusCodes[HttpStatusCodes["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
     /**
      * The request was well-formed but was unable to be followed due to semantic errors.
      */
-    HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HttpStatusCodes[HttpStatusCodes["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
     /**
      * The resource that is being accessed is locked.
      */
-    HttpStatus[HttpStatus["LOCKED"] = 423] = "LOCKED";
+    HttpStatusCodes[HttpStatusCodes["LOCKED"] = 423] = "LOCKED";
     /**
      * The request failed due to failure of a previous request.
      */
-    HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HttpStatusCodes[HttpStatusCodes["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
     /**
      * Indicates that the server is unwilling to risk processing a request that might be replayed.
      */
-    HttpStatus[HttpStatus["TOO_EARLY"] = 425] = "TOO_EARLY";
+    HttpStatusCodes[HttpStatusCodes["TOO_EARLY"] = 425] = "TOO_EARLY";
     /**
      * The server refuses to perform the request using the current protocol but might be willing
      * to do so after the client upgrades to a different protocol. The server sends an Upgrade
      * header in a 426 response to indicate the required protocol(s).
      */
-    HttpStatus[HttpStatus["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
     /**
      * The origin server requires the request to be conditional. This response is intended to prevent
      * the 'lost update' problem, where a client GETs a resource's state, modifies it and PUTs
      * it back to the server, when meanwhile a third party has modified the state on the server,
      * leading to a conflict.
      */
-    HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    HttpStatusCodes[HttpStatusCodes["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting").
      */
-    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HttpStatusCodes[HttpStatusCodes["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
     /* *** Server error responses *** */
     /**
      * The server has encountered a situation it does not know how to handle.
      */
-    HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HttpStatusCodes[HttpStatusCodes["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
     /**
      * The request method is not supported by the server and cannot be handled.
      * The only methods that servers are required to support (and therefore that must not return this code)
      * are GET and HEAD.
      */
-    HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HttpStatusCodes[HttpStatusCodes["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
     /**
      * This error response means that the server, while working as a gateway to get
      * a response needed to handle the request, got an invalid response.
      */
-    HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HttpStatusCodes[HttpStatusCodes["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
     /**
      * The server is not ready to handle the request. Common causes are a server that is down for maintenance
      * or that is overloaded. Note that together with this response, a user-friendly page explaining
@@ -265,36 +262,36 @@ var HttpStatus;
      * headers that are sent along with this response, as these temporary condition responses
      * should usually not be cached.
      */
-    HttpStatus[HttpStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HttpStatusCodes[HttpStatusCodes["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
     /**
      * This error response is given when the server is acting as a gateway and cannot get a response in time.
      */
-    HttpStatus[HttpStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HttpStatusCodes[HttpStatusCodes["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
     /**
      * The HTTP version used in the request is not supported by the server.
      */
-    HttpStatus[HttpStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+    HttpStatusCodes[HttpStatusCodes["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
     /**
      * The server has an internal configuration error: the chosen variant resource is configured
      * to engage in transparent content negotiation itself, and is therefore not a proper end
      * point in the negotiation process.
      */
-    HttpStatus[HttpStatus["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+    HttpStatusCodes[HttpStatusCodes["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
     /**
      * The method could not be performed on the resource because the server is unable to store
      * the representation needed to successfully complete the request.
      */
-    HttpStatus[HttpStatus["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+    HttpStatusCodes[HttpStatusCodes["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
     /**
      * The server detected an infinite loop while processing the request.
      */
-    HttpStatus[HttpStatus["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+    HttpStatusCodes[HttpStatusCodes["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
     /**
      * Further extensions to the request are required for the server to fulfill it.
      */
-    HttpStatus[HttpStatus["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+    HttpStatusCodes[HttpStatusCodes["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
     /**
      * Indicates that the client needs to authenticate to gain network access.
      */
-    HttpStatus[HttpStatus["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
-})(HttpStatus = exports.HttpStatus || (exports.HttpStatus = {}));
+    HttpStatusCodes[HttpStatusCodes["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+})(HttpStatusCodes || (HttpStatusCodes = {}));

package/esm/http/http-headers.d.ts

@@ -0,0 +1,70 @@
+import { ResponsiveMap } from '../helpers/responsive-map.js';
+declare const nodeInspectCustom: unique symbol;
+declare const kEntries: unique symbol;
+declare const kSize: unique symbol;
+declare const kOptions: unique symbol;
+type HeaderValueType = string | number | boolean;
+export type HttpHeadersInit = string | Headers | HttpHeaders | Map<string, any> | Record<string, string | string[]>;
+export interface HttpHeadersOptions {
+    onChange?: () => void;
+}
+export declare class HttpHeaders {
+    protected static kEntries: symbol;
+    protected static kSize: symbol;
+    protected static kOptions: symbol;
+    protected [kEntries]: ResponsiveMap<string, string[]>;
+    protected [kSize]: number;
+    protected [kOptions]: HttpHeadersOptions;
+    constructor(init?: HttpHeadersInit, options?: HttpHeadersOptions);
+    get size(): number;
+    /**
+     * Appends a new value to the existing set of values for a header
+     * and returns this instance
+     */
+    append(name: string, value: HeaderValueType | HeaderValueType[]): this;
+    /**
+     * Appends multiple values to the existing set of values for a header
+     * and returns this instance
+     */
+    appendAll(headers: HttpHeadersInit): this;
+    changed(): void;
+    clear(): void;
+    /**
+     * Deletes values for a given header
+     */
+    delete(name: string, value?: HeaderValueType | HeaderValueType[]): this;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries(): IterableIterator<[string, string]>;
+    forEach(callbackFn: (value: string, key: string, parent: HttpHeaders) => void, thisArg?: any): void;
+    /**
+     * Retrieves value of a given header at given index
+     */
+    get(name: string, index?: number): string | null;
+    /**
+     * Retrieves an array of values for a given header.
+     */
+    getAll(name: string): string[] | null;
+    /**
+     * Retrieves the names of the headers.
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Checks for existence of a given header.
+     */
+    has(name: string): boolean;
+    /**
+     * Sets or modifies a value for a given header.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name: string, value: HeaderValueType | HeaderValueType[]): this;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    protected _append(name: string, value: HeaderValueType | HeaderValueType[]): void;
+    protected _delete(name: string, value?: HeaderValueType | HeaderValueType[]): boolean;
+    protected _set(name: string, value: string | string[]): void;
+    [nodeInspectCustom](): ResponsiveMap<string, string[]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    get [Symbol.toStringTag](): string;
+}
+export {};

package/esm/http/http-headers.js

@@ -0,0 +1,209 @@
+var _a, _b;
+import { ResponsiveMap } from '../helpers/responsive-map.js';
+import { HttpHeaderCodes } from './enums/http-headers-codes.enum.js';
+const knownKeys = Object.keys(HttpHeaderCodes);
+const knownKeysLower = knownKeys.map(x => x.toLowerCase());
+const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+const kEntries = Symbol('kEntries');
+const kSize = Symbol('kSize');
+const kOptions = Symbol('kOptions');
+export class HttpHeaders {
+    constructor(init, options) {
+        this[_a] = new ResponsiveMap();
+        this[_b] = 0;
+        this[kOptions] = { ...options, onChange: undefined };
+        if (init)
+            this.appendAll(init);
+        this[kOptions].onChange = options?.onChange;
+    }
+    get size() {
+        return this[kSize];
+    }
+    /**
+     * Appends a new value to the existing set of values for a header
+     * and returns this instance
+     */
+    append(name, value) {
+        this._append(name, value);
+        this.changed();
+        return this;
+    }
+    /**
+     * Appends multiple values to the existing set of values for a header
+     * and returns this instance
+     */
+    appendAll(headers) {
+        if (typeof headers === 'string') {
+            headers.split('\n').forEach(line => {
+                const index = line.indexOf(':');
+                if (index > 0) {
+                    const name = line.slice(0, index);
+                    const value = line.slice(index + 1).trim();
+                    this._append(name, value);
+                }
+            });
+        }
+        else if (headers.forEach && typeof headers.forEach === 'function')
+            headers.forEach((value, name) => this._append(name, value));
+        else
+            Object.keys(headers).forEach(name => this._append(name, headers[name]));
+        this.changed();
+        return this;
+    }
+    changed() {
+        if (this[kOptions].onChange)
+            this[kOptions].onChange();
+    }
+    clear() {
+        if (this[kEntries].size) {
+            this[kEntries].clear();
+            this[kSize] = 0;
+            this.changed();
+        }
+    }
+    /**
+     * Deletes values for a given header
+     */
+    delete(name, value) {
+        if (this._delete(name, value))
+            this.changed();
+        return this;
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries() {
+        const iter = this[kEntries].entries();
+        let i = 0;
+        let key;
+        let values;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                if (values) {
+                    if (i >= values.length) {
+                        values = undefined;
+                        i = 0;
+                    }
+                }
+                if (!values) {
+                    const n = iter.next();
+                    if (n.done)
+                        return { done: true, value: undefined };
+                    key = n.value[0];
+                    values = n.value[1];
+                }
+                return {
+                    done: false,
+                    value: [key, values[i++]]
+                };
+            }
+        };
+    }
+    forEach(callbackFn, thisArg) {
+        const iterator = this.entries();
+        let entry = iterator.next();
+        while (!entry.done) {
+            callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
+            entry = iterator.next();
+        }
+    }
+    /**
+     * Retrieves value of a given header at given index
+     */
+    get(name, index = 0) {
+        const values = this[kEntries].get(name.toLowerCase());
+        return values && values.length > index ? values[index] : null;
+    }
+    /**
+     * Retrieves an array of values for a given header.
+     */
+    getAll(name) {
+        const entry = this[kEntries].get(name);
+        return entry ? entry.slice(0) : null;
+    }
+    /**
+     * Retrieves the names of the headers.
+     */
+    keys() {
+        return this[kEntries].keys();
+    }
+    /**
+     * Checks for existence of a given header.
+     */
+    has(name) {
+        return this[kEntries].has(name);
+    }
+    /**
+     * Sets or modifies a value for a given header.
+     * If the header already exists, its value is replaced with the given value
+     */
+    set(name, value) {
+        this._set(name, String(value));
+        this.changed();
+        return this;
+    }
+    sort(compareFn) {
+        this[kEntries].sort(compareFn);
+        this.changed();
+        return this;
+    }
+    _append(name, value) {
+        const i = knownKeysLower.indexOf(name);
+        const normalizedName = knownKeys[i] || name;
+        let values = this[kEntries].get(normalizedName);
+        if (!values) {
+            values = [];
+            this[kEntries].set(normalizedName, values);
+        }
+        const oldSize = values.length;
+        if (Array.isArray(value))
+            values.push(...value.map(x => String(x)));
+        else
+            values.push(String(value));
+        this[kSize] = -oldSize + values.length;
+    }
+    _delete(name, value) {
+        const oldValues = this[kEntries].get(name);
+        if (!oldValues)
+            return false;
+        const oldSize = this[kSize];
+        if (value) {
+            const valueToDelete = Array.isArray(value) ? value.map(x => String(x)) : [String(value)];
+            const newValues = oldValues.filter(x => !valueToDelete.includes(x));
+            this[kEntries].set(name, newValues);
+            this[kSize] += -oldValues.length + newValues.length;
+        }
+        else {
+            this[kEntries].delete(name);
+            this[kSize] -= oldValues.length;
+        }
+        return oldSize !== this[kSize];
+    }
+    _set(name, value) {
+        if (value == null) {
+            this._delete(name);
+            return;
+        }
+        const oldValues = this[kEntries].get(name);
+        const i = knownKeysLower.indexOf(name);
+        const normalizedName = knownKeys[i] || name;
+        const newValues = Array.isArray(value) ? value : [value];
+        this[kEntries].set(normalizedName, newValues);
+        this[kSize] += -(oldValues?.length || 0) + newValues.length;
+    }
+    [(_a = kEntries, _b = kSize, nodeInspectCustom)]() {
+        return this[kEntries];
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get [Symbol.toStringTag]() {
+        return 'HttpHeaders';
+    }
+}
+HttpHeaders.kEntries = kEntries;
+HttpHeaders.kSize = kSize;
+HttpHeaders.kOptions = kOptions;

package/esm/http/http-param-codec.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class HttpParamCodec {
+    abstract decode(value: string): any;
+    abstract encode(value: any): string;
+}

package/esm/http/http-param-codec.js

@@ -0,0 +1,2 @@
+export class HttpParamCodec {
+}