webhoster 0.3.3 → 0.3.5

package/types/helpers/HttpListener.d.ts

@@ -0,0 +1,84 @@
+export const SERVER_ALREADY_CREATED: "SERVER_ALREADY_CREATED";
+export default class HttpListener {
+    /** @return {HttpListener} */
+    static get defaultInstance(): HttpListener;
+    /** @param {HttpListenerOptions} options */
+    constructor(options?: HttpListenerOptions);
+    /** @param {HttpListenerOptions} options */
+    configure(options?: HttpListenerOptions): void;
+    httpHandler: HttpHandler;
+    insecurePort: number;
+    insecureHost: string;
+    securePort: number;
+    secureHost: string;
+    useHttp: boolean;
+    useHttps: boolean;
+    useHttp2: boolean;
+    tlsOptions: import("tls").TlsOptions;
+    /**
+     * @param {import('node:http').ServerOptions} [options]
+     * @return {import('node:http').Server}
+     */
+    createHttpServer(options?: import("node:http").ServerOptions): import("node:http").Server;
+    httpServer: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    /**
+     * @param {import('node:https').ServerOptions} [options]
+     * @return {import('node:https').Server}
+     */
+    createHttpsServer(options?: import("node:https").ServerOptions): import("node:https").Server;
+    httpsServer: import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    /**
+     * @param {import('node:http2').ServerOptions} [options]
+     * @return {import('node:http2').Http2SecureServer}
+     */
+    createHttp2Server(options?: import("node:http2").ServerOptions): import("node:http2").Http2SecureServer;
+    http2Server: import("http2").Http2SecureServer<typeof import("http").IncomingMessage, typeof import("http").ServerResponse, typeof import("http2").Http2ServerRequest, typeof import("http2").Http2ServerResponse>;
+    /** @return {Promise<import('node:http').Server>} */
+    startHttpServer(): Promise<import("node:http").Server>;
+    /** @return {Promise<import('node:https').Server>} */
+    startHttpsServer(): Promise<import("node:https").Server>;
+    /** @return {Promise<import('node:http2').Http2SecureServer>} */
+    startHttp2Server(): Promise<import("node:http2").Http2SecureServer>;
+    /** @return {Promise<void>} */
+    stopHttpServer(): Promise<void>;
+    /** @return {Promise<void>} */
+    stopHttpsServer(): Promise<void>;
+    /** @return {Promise<void>} */
+    stopHttp2Server(): Promise<void>;
+    /**
+     * @return {Promise<[
+     *  import('node:http').Server,
+     *  import('node:https').Server,
+     *  import('node:http2').Http2SecureServer
+     * ]>
+     * }
+     */
+    startAll(): Promise<[import("node:http").Server, import("node:https").Server, import("node:http2").Http2SecureServer]>;
+    /**
+     * @return {Promise<void>}
+     */
+    stopAll(): Promise<void>;
+    #private;
+}
+export type TlsOptions = import("tls").TlsOptions;
+export type Http2Session = import("http2").Http2Session;
+export type Http2Stream = import("http2").Http2Stream;
+export type HttpListenerOptions = {
+    httpHandler?: HttpHandler;
+    insecurePort?: number;
+    /**
+     * blank defaults to '::' or '0.0.0.0'
+     */
+    insecureHost?: string;
+    securePort?: number;
+    /**
+     * blank defaults to '::' or '0.0.0.0'
+     */
+    secureHost?: string;
+    useHttp?: boolean;
+    useHttps?: boolean;
+    useHttp2?: boolean;
+    tlsOptions?: TlsOptions;
+};
+import HttpHandler from '../lib/HttpHandler.js';
+//# sourceMappingURL=HttpListener.d.ts.map

package/types/helpers/HttpListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpListener.d.ts","sourceRoot":"","sources":["../../helpers/HttpListener.js"],"names":[],"mappings":"AAOA,qCAAsC,wBAAwB,CAAC;AAsB/D;IACE,6BAA6B;IAC7B,8BADa,YAAY,CAMxB;IAsCD,2CAA2C;IAC3C,sBADY,mBAAmB,EAG9B;IAED,2CAA2C;IAC3C,oBADY,mBAAmB,QAW9B;IATC,yBAAqE;IACrE,qBAAgD;IAChD,qBAAwC;IACxC,mBAA4C;IAC5C,mBAAoC;IACpC,iBAAwC;IACxC,kBAAyC;IACzC,kBAA0C;IAC1C,qCAA0C;IAG5C;;;OAGG;IACH,2BAHW,OAAO,WAAW,EAAE,aAAa,GAChC,OAAO,WAAW,EAAE,MAAM,CASrC;IALG,+GAA2C;IAO/C;;;OAGG;IACH,4BAHW,OAAO,YAAY,EAAE,aAAa,GACjC,OAAO,YAAY,EAAE,MAAM,CAYtC;IARG,iHAGE;IAON;;;OAGG;IACH,4BAHW,OAAO,YAAY,EAAE,aAAa,GACjC,OAAO,YAAY,EAAE,iBAAiB,CAajD;IATG,mNAIE;IAON,oDAAoD;IACpD,mBADa,OAAO,CAAC,OAAO,WAAW,EAAE,MAAM,CAAC,CA8C/C;IAED,qDAAqD;IACrD,oBADa,OAAO,CAAC,OAAO,YAAY,EAAE,MAAM,CAAC,CA8ChD;IAED,gEAAgE;IAChE,oBADa,OAAO,CAAC,OAAO,YAAY,EAAE,iBAAiB,CAAC,CA0I3D;IAED,8BAA8B;IAC9B,kBADa,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED,8BAA8B;IAC9B,mBADa,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED,8BAA8B;IAC9B,mBADa,OAAO,CAAC,IAAI,CAAC,CAmCzB;IAED;;;;;;;OAOG;IACH,YAPY,OAAO,CAAC,CACnB,OAAU,WAAW,EAAE,MAAM,EAC7B,OAAU,YAAY,EAAE,MAAM,EAC9B,OAAU,YAAY,EAAE,iBAAiB,CACtC,CAAC,CASJ;IAED;;OAEG;IACH,WAFY,OAAO,CAAC,IAAI,CAAC,CAQxB;;CACF;yBAhea,OAAO,KAAK,EAAE,UAAU;2BACxB,OAAO,OAAO,EAAE,YAAY;0BAC5B,OAAO,OAAO,EAAE,WAAW;;kBAI/B,WAAW;mBACX,MAAM;;;;mBACN,MAAM;iBACN,MAAM;;;;iBACN,MAAM;cACN,OAAO;eACP,OAAO;eACP,OAAO;iBACP,UAAU;;wBAlBI,uBAAuB"}

package/types/helpers/RequestHeaders.d.ts

@@ -0,0 +1,25 @@
+export default class RequestHeaders extends HeadersHandler {
+    /**
+     * @param {HttpRequest} request
+     * @return {{get:(name:string)=>string,all:(name:string)=>string[]}}
+     */
+    static cookies(request: HttpRequest): {
+        get: (name: string) => string;
+        all: (name: string) => string[];
+    };
+    /** @param {HttpRequest} request */
+    constructor(request: HttpRequest);
+    /** @return {{get:(name:string)=>string,all:(name:string)=>string[]}} */
+    get cookies(): {
+        get: (name: string) => string;
+        all: (name: string) => string[];
+    };
+    /** @return {Object<string,string[]>} */
+    get cookieEntries(): {
+        [x: string]: string[];
+    };
+    #private;
+}
+export type HttpRequest = import("../lib/HttpRequest.js").default;
+import HeadersHandler from './HeadersParser.js';
+//# sourceMappingURL=RequestHeaders.d.ts.map

package/types/helpers/RequestHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestHeaders.d.ts","sourceRoot":"","sources":["../../helpers/RequestHeaders.js"],"names":[],"mappings":"AAgCA;IASE;;;OAGG;IACH,wBAHW,WAAW,GACV;QAAC,GAAG,EAAC,CAAC,IAAI,EAAC,MAAM,KAAG,MAAM,CAAC;QAAA,GAAG,EAAC,CAAC,IAAI,EAAC,MAAM,KAAG,MAAM,EAAE,CAAA;KAAC,CAKlE;IAfD,mCAAmC;IACnC,qBADY,WAAW,EAMtB;IAcD,wEAAwE;IACxE,eADa;QAAC,GAAG,EAAC,CAAC,IAAI,EAAC,MAAM,KAAG,MAAM,CAAC;QAAA,GAAG,EAAC,CAAC,IAAI,EAAC,MAAM,KAAG,MAAM,EAAE,CAAA;KAAC,CAYnE;IAED,wCAAwC;IACxC;;MAqFC;;CACF;0BAxJa,OAAO,uBAAuB,EAAE,OAAO;2BAF1B,oBAAoB"}

package/types/helpers/RequestReader.d.ts

@@ -0,0 +1,52 @@
+export default class RequestReader {
+    /**
+     * @param {HttpRequest} request
+     * @param {RequestReaderOptions} [options]
+     */
+    constructor(request: HttpRequest, options?: RequestReaderOptions);
+    request: import("../lib/HttpRequest.js").default;
+    /** @return {Promise<Buffer>} */
+    readBuffer(): Promise<Buffer>;
+    /** @return {Promise<string>} */
+    readString(): Promise<string>;
+    /** @return {Promise<Object<string,any>>} */
+    readJSON(): Promise<{
+        [x: string]: any;
+    }>;
+    /**
+     * The application/x-www-form-urlencoded format is in many ways an aberrant monstrosity,
+     * the result of many years of implementation accidents and compromises leading to a set of
+     * requirements necessary for interoperability, but in no way representing good design practices.
+     * In particular, readers are cautioned to pay close attention to the twisted details
+     * involving repeated (and in some cases nested) conversions between character encodings and byte sequences.
+     * Unfortunately the format is in widespread use due to the prevalence of HTML forms. [HTML]
+     * @return {Promise<[string, string][]>}
+     */
+    readUrlEncoded(): Promise<[string, string][]>;
+    /** @return {Promise<Map<string,string>>} */
+    readUrlEncodedAsMap(): Promise<Map<string, string>>;
+    /** @return {Promise<Object<string,string>>} */
+    readUrlEncodedAsObject(): Promise<{
+        [x: string]: string;
+    }>;
+    /**
+     * Returns `readJSON()`, `readUrlEncodedAsObject`, or `Promise<null>` based on Content-Type
+     * @return {Promise<Object<string, any>|null>}
+     */
+    readObject(): Promise<{
+        [x: string]: any;
+    } | null>;
+    /**
+     * Returns `readJSON()`, `readUrlEncoded`, `readBuffer()`, or `readString()` based on Content-Type
+     * @return {Promise<Object<string,any>|string|Buffer>}
+     */
+    read(): Promise<{
+        [x: string]: any;
+    } | string | Buffer>;
+    #private;
+}
+export type HttpRequest = import("../data/custom-types.js").HttpRequest;
+export type RequestReaderOptions = {
+    cache?: boolean;
+};
+//# sourceMappingURL=RequestReader.d.ts.map

package/types/helpers/RequestReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestReader.d.ts","sourceRoot":"","sources":["../../helpers/RequestReader.js"],"names":[],"mappings":"AAgBA;IAIE;;;OAGG;IACH,qBAHW,WAAW,YACX,oBAAoB,EAc9B;IADC,iDAAsB;IAGxB,gCAAgC;IAChC,cADa,OAAO,CAAC,MAAM,CAAC,CA0C3B;IAED,gCAAgC;IAChC,cADa,OAAO,CAAC,MAAM,CAAC,CAQ3B;IAED,4CAA4C;IAC5C,YADa,OAAO,CAAC;YAAO,MAAM,GAAC,GAAG;KAAC,CAAC,CAGvC;IAED;;;;;;;;OAQG;IACH,kBAFY,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAuDtC;IAED,4CAA4C;IAC5C,uBADa,OAAO,CAAC,GAAG,CAAC,MAAM,EAAC,MAAM,CAAC,CAAC,CAGvC;IAED,+CAA+C;IAC/C,0BADa,OAAO,CAAC;YAAO,MAAM,GAAC,MAAM;KAAC,CAAC,CAG1C;IAED;;;OAGG;IACH,cAFY,OAAO,CAAC;YAAO,MAAM,GAAE,GAAG;KAAC,GAAC,IAAI,CAAC,CAa5C;IAED;;;OAGG;IACH,QAFY,OAAO,CAAC;YAAO,MAAM,GAAC,GAAG;KAAC,GAAC,MAAM,GAAC,MAAM,CAAC,CAmBpD;;CACF;0BAlNa,OAAO,yBAAyB,EAAE,WAAW;;YAQjD,OAAO"}

package/types/helpers/ResponseHeaders.d.ts

@@ -0,0 +1,126 @@
+export default class ResponseHeaders extends HeadersHandler {
+    /** @param {HttpResponse} response */
+    static cookies(response: HttpResponse): {
+        /**
+         * @param {string|CookieDetails|CookieObject} nameOrDetails
+         * @return {boolean}
+         */
+        has(nameOrDetails: string | CookieDetails | CookieObject): boolean;
+        /**
+         * @param {string|CookieDetails} partial
+         * @return {CookieObject}
+         */
+        get(partial: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} [partial]
+         * @return {CookieObject[]}
+         */
+        getAll(partial?: string | CookieDetails): CookieObject[];
+        /**
+         * @param {CookieDetails} details
+         * @return {CookieObject}
+         */
+        find(details: CookieDetails): CookieObject;
+        /**
+         * @param {CookieDetails} [details]
+         * @return {CookieObject[]}
+         */
+        findAll(details?: CookieDetails): CookieObject[];
+        /**
+         * @param {string|CookieDetails} cookie
+         * @return {CookieObject}
+         */
+        set(cookie: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} partial
+         * @return {number} count
+         */
+        remove(partial: string | CookieDetails): number;
+        /**
+         * @param {string|CookieDetails} partial name or details
+         * @return {CookieObject}
+         */
+        expire(partial: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} [partial]
+         * @return {CookieObject[]}
+         */
+        expireAll(partial?: string | CookieDetails): CookieObject[];
+    };
+    /** @param {HttpResponse} response */
+    constructor(response: HttpResponse);
+    /** @param {string} contentType */
+    set contentType(contentType: string);
+    get contentType(): string;
+    /** @param {string} mediaType */
+    set mediaType(mediaType: string);
+    get mediaType(): string;
+    /** @param {string} charset */
+    set charset(charset: string);
+    get charset(): string;
+    /** @param {BufferEncoding} bufferEncoding */
+    set charsetAsBufferEncoding(bufferEncoding: BufferEncoding);
+    /** @return {BufferEncoding} */
+    get charsetAsBufferEncoding(): BufferEncoding;
+    /** @param {string} boundary */
+    set boundary(boundary: string);
+    get boundary(): string;
+    /** @param {number} value */
+    set contentLength(value: number);
+    get contentLength(): number;
+    get cookies(): {
+        /**
+         * @param {string|CookieDetails|CookieObject} nameOrDetails
+         * @return {boolean}
+         */
+        has(nameOrDetails: string | CookieDetails | CookieObject): boolean;
+        /**
+         * @param {string|CookieDetails} partial
+         * @return {CookieObject}
+         */
+        get(partial: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} [partial]
+         * @return {CookieObject[]}
+         */
+        getAll(partial?: string | CookieDetails): CookieObject[];
+        /**
+         * @param {CookieDetails} details
+         * @return {CookieObject}
+         */
+        find(details: CookieDetails): CookieObject;
+        /**
+         * @param {CookieDetails} [details]
+         * @return {CookieObject[]}
+         */
+        findAll(details?: CookieDetails): CookieObject[];
+        /**
+         * @param {string|CookieDetails} cookie
+         * @return {CookieObject}
+         */
+        set(cookie: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} partial
+         * @return {number} count
+         */
+        remove(partial: string | CookieDetails): number;
+        /**
+         * @param {string|CookieDetails} partial name or details
+         * @return {CookieObject}
+         */
+        expire(partial: string | CookieDetails): CookieObject;
+        /**
+         * @param {string|CookieDetails} [partial]
+         * @return {CookieObject[]}
+         */
+        expireAll(partial?: string | CookieDetails): CookieObject[];
+    };
+    /** @return {Array<CookieObject>} */
+    get cookieEntries(): Array<CookieObject>;
+    #private;
+}
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type CookieDetails = import("../data/custom-types.js").CookieDetails;
+import HeadersHandler from './HeadersParser.js';
+import CookieObject from '../data/CookieObject.js';
+//# sourceMappingURL=ResponseHeaders.d.ts.map

package/types/helpers/ResponseHeaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResponseHeaders.d.ts","sourceRoot":"","sources":["../../helpers/ResponseHeaders.js"],"names":[],"mappings":"AAuBA;IASE,qCAAqC;IACrC,yBADY,YAAY;QAsIpB;;;WAGG;2BAFQ,MAAM,GAAC,aAAa,GAAC,YAAY,GAChC,OAAO;QAKnB;;;WAGG;qBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAKxB;;;WAGG;yBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY,EAAE;QAW1B;;;WAGG;sBAFQ,aAAa,GACZ,YAAY;QAKxB;;;WAGG;0BAFQ,aAAa,GACZ,YAAY,EAAE;QAmB1B;;;WAGG;oBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAmBxB;;;WAGG;wBAFQ,MAAM,GAAC,aAAa,GACnB,MAAM;QAUlB;;;WAGG;wBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAcxB;;;WAGG;4BAFQ,MAAM,GAAC,aAAa,GACnB,YAAY,EAAE;MA5O7B;IAZD,qCAAqC;IACrC,sBADY,YAAY,EAMvB;IA4BD,kCAAkC;IAClC,6BADY,MAAM,EAGjB;IAPD,mBAIY,MAAM,CAFjB;IAWD,gCAAgC;IAChC,yBADY,MAAM,EAQjB;IAZD,iBAIY,MAAM,CAFjB;IAgBD,8BAA8B;IAC9B,qBADY,MAAM,EAQjB;IAZD,eAIY,MAAM,CAFjB;IAoCD,6CAA6C;IAC7C,4CADY,cAAc,EAsBzB;IA9CD,+BAA+B;IAC/B,+BADa,cAAc,CAsB1B;IA8BD,+BAA+B;IAC/B,uBADY,MAAM,EAQjB;IAZD,gBAIY,MAAM,CAFjB;IAgBD,4BAA4B;IAC5B,yBADY,MAAM,EAGjB;IAPD,qBAIY,MAAM,CAFjB;IAOD;QAII;;;WAGG;2BAFQ,MAAM,GAAC,aAAa,GAAC,YAAY,GAChC,OAAO;QAKnB;;;WAGG;qBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAKxB;;;WAGG;yBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY,EAAE;QAW1B;;;WAGG;sBAFQ,aAAa,GACZ,YAAY;QAKxB;;;WAGG;0BAFQ,aAAa,GACZ,YAAY,EAAE;QAmB1B;;;WAGG;oBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAmBxB;;;WAGG;wBAFQ,MAAM,GAAC,aAAa,GACnB,MAAM;QAUlB;;;WAGG;wBAFQ,MAAM,GAAC,aAAa,GACnB,YAAY;QAcxB;;;WAGG;4BAFQ,MAAM,GAAC,aAAa,GACnB,YAAY,EAAE;MAY7B;IAED,oCAAoC;IACpC,qBADa,KAAK,CAAC,YAAY,CAAC,CAoD/B;;CACF;2BA/Ua,OAAO,wBAAwB,EAAE,OAAO;4BACxC,OAAO,yBAAyB,EAAE,aAAa;2BAHlC,oBAAoB;yBAFtB,yBAAyB"}

package/types/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export { default as HttpListener } from "./HttpListener.js";
+export { default as HeadersParser } from "./HeadersParser.js";
+export { default as RequestHeaders } from "./RequestHeaders.js";
+export { default as RequestReader } from "./RequestReader.js";
+export { default as ResponseHeaders } from "./ResponseHeaders.js";
+//# sourceMappingURL=index.d.ts.map

package/types/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../helpers/index.js"],"names":[],"mappings":""}

package/types/lib/HttpHandler.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @typedef {Object} HttpHandlerOptions
+ * @prop {Middleware[]} [middleware]
+ * @prop {MiddlewareErrorHandler[]} [errorHandlers]
+ */
+export default class HttpHandler {
+    /** @type {true} */
+    static CONTINUE: true;
+    /** @type {false} */
+    static BREAK: false;
+    /** @type {0} */
+    static END: 0;
+    /** @return {HttpHandler} */
+    static get defaultInstance(): HttpHandler;
+    /**
+     * @param {any} result
+     * @return {?MiddlewareFlowInstruction}
+     */
+    static ParseResultSync(result: any): MiddlewareFlowInstruction | null;
+    /**
+     * @param {string} scheme
+     * @param {string} authority
+     * @param {string} path
+     */
+    static parseURL(scheme: string, authority: string, path: string): {
+        href: string;
+        origin: string;
+        protocol: string;
+        username: string;
+        password: string;
+        host: string;
+        hostname: string;
+        port: string;
+        pathname: string;
+        search: string;
+        hash: string;
+        query: string;
+        fragment: string;
+        url: string;
+    };
+    /** @param {HttpHandlerOptions} options */
+    constructor(options?: HttpHandlerOptions);
+    middleware: import("../data/middleware.js").Middleware[];
+    errorHandlers: import("../data/custom-types.js").MiddlewareErrorHandler[];
+    /**
+     * @param {HttpTransaction} transaction
+     * @return {Promise<HttpTransaction>}
+     */
+    handleTransaction(transaction: HttpTransaction): Promise<HttpTransaction>;
+    /**
+     * @param {import('http').IncomingMessage} incomingMessage
+     * @param {import('http').ServerResponse} serverResponse
+     * @return {Promise<HttpTransaction>}
+     */
+    handleHttp1Request(incomingMessage: import("http").IncomingMessage, serverResponse: import("http").ServerResponse): Promise<HttpTransaction>;
+    /**
+     * @param {import('http2').ServerHttp2Stream} stream
+     * @param {import('http2').IncomingHttpHeaders} headers
+     * @param {Partial<import('./HttpTransaction.js').HttpTransactionOptions<unknown>>} [transactionOptions]
+     * @return {Promise<HttpTransaction>}
+     */
+    handleHttp2Stream(stream: import("http2").ServerHttp2Stream, headers: import("http2").IncomingHttpHeaders, transactionOptions?: Partial<import("./HttpTransaction.js").HttpTransactionOptions<unknown>>): Promise<HttpTransaction>;
+    /**
+     * @param {HttpTransaction} transaction
+     * @param {Middleware} middleware
+     * @return {Promise<MiddlewareFlowInstruction>}
+     */
+    processMiddleware(transaction: HttpTransaction, middleware: Middleware): Promise<MiddlewareFlowInstruction>;
+}
+export type Middleware = import("../data/custom-types.js").Middleware;
+export type MiddlewareErrorHandler = import("../data/custom-types.js").MiddlewareErrorHandler;
+export type MiddlewareFlowInstruction = import("../data/custom-types.js").MiddlewareFlowInstruction;
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type HttpHandlerOptions = {
+    middleware?: Middleware[];
+    errorHandlers?: MiddlewareErrorHandler[];
+};
+import HttpTransaction from './HttpTransaction.js';
+//# sourceMappingURL=HttpHandler.d.ts.map

package/types/lib/HttpHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpHandler.d.ts","sourceRoot":"","sources":["../../lib/HttpHandler.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH;IACE,mBAAmB;IACnB,iBADW,IAAI,CACQ;IAEvB,oBAAoB;IACpB,cADW,KAAK,CACK;IAErB,gBAAgB;IAChB,YADW,CAAC,CACG;IAEf,4BAA4B;IAC5B,8BADa,WAAW,CAMvB;IAED;;;OAGG;IACH,+BAHW,GAAG,GACD,yBAAyB,OAAA,CAkBrC;IAED;;;;OAIG;IACH,wBAJW,MAAM,aACN,MAAM,QACN,MAAM;;;;;;;;;;;;;;;MA6DhB;IAED,0CAA0C;IAC1C,sBADY,kBAAkB,EAO7B;IALC,yDAA0C;IAC1C,0EAAgD;IA2IlD;;;OAGG;IACH,+BAHW,eAAe,GACd,OAAO,CAAC,eAAe,CAAC,CAwBnC;IAED;;;;OAIG;IACH,oCAJW,OAAO,MAAM,EAAE,eAAe,kBAC9B,OAAO,MAAM,EAAE,cAAc,GAC5B,OAAO,CAAC,eAAe,CAAC,CAyFnC;IAED;;;;;OAKG;IACH,0BALW,OAAO,OAAO,EAAE,iBAAiB,WACjC,OAAO,OAAO,EAAE,mBAAmB,uBACnC,OAAO,CAAC,OAAO,sBAAsB,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC,GACtE,OAAO,CAAC,eAAe,CAAC,CAiKnC;IApaD;;;;OAIG;IACH,+BAJW,eAAe,cACf,UAAU,GACT,OAAO,CAAC,yBAAyB,CAAC,CAgI7C;CAkSF;yBAriBa,OAAO,yBAAyB,EAAE,UAAU;qCAC5C,OAAO,yBAAyB,EAAE,sBAAsB;wCACxD,OAAO,yBAAyB,EAAE,yBAAyB;4BAC3D,OAAO,yBAAyB,EAAE,aAAa;;iBAOnD,UAAU,EAAE;oBACZ,sBAAsB,EAAE;;4BAbN,sBAAsB"}

package/types/lib/HttpRequest.d.ts

@@ -0,0 +1,175 @@
+/**
+ * @typedef HttpRequestOptions
+ * @prop {IncomingHttpHeaders} [headers]
+ * @prop {RequestMethod} method
+ * @prop {Readable} stream
+ * @prop {string} href URL.href
+ * @prop {URL['origin']} origin URL.origin
+ * @prop {URL['protocol']} protocol URL.protocol
+ * @prop {URL['username']} username URL.username
+ * @prop {URL['password']} password URL.password
+ * @prop {URL['host']} host URL.host
+ * @prop {URL['hostname']} hostname URL.hostname
+ * @prop {URL['port']} port URL.port
+ * @prop {URL['pathname']} pathname URL.pathname
+ * @prop {URL['search']} search URL.search
+ * @prop {URL['hash']} hash URL.hash
+ * @prop {string} scheme
+ * @prop {string} authority
+ * @prop {string} path unparsed path
+ * @prop {string} url unparsed url
+ * @prop {string} query
+ * @prop {string} fragment
+ */
+/**
+ * @implements {URL}
+ */
+export default class HttpRequest implements URL {
+    /** @param {HttpRequestOptions} options */
+    constructor(options: HttpRequestOptions);
+    /** @type {number} Minimum initial buffer size when working with chunks. Default 64KB */
+    MIN_INITIAL_BUFFER_SIZE: number;
+    /** @type {number} Maximium initial buffer size when working with chunks. Default 4MB */
+    MAX_INITIAL_BUFFER_SIZE: number;
+    /** @type {number} Absolute maximum buffer size to be allocated per request. Default 64MB */
+    MAX_BUFFER_SIZE: number;
+    /** @type {ContentReaderRegistration[]} */
+    contentReaders: ContentReaderRegistration[];
+    /** @type {IncomingHttpHeaders} */
+    headers: IncomingHttpHeaders;
+    method: import("../data/custom-types.js").RequestMethod;
+    stream: Readable;
+    href: string;
+    origin: string;
+    protocol: string;
+    username: string;
+    password: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+    url: string;
+    /**
+     * @param {import('stream').Duplex} downstream
+     * @param {Object} [options]
+     * @param {boolean} [options.forwardErrors=true] Forward errors back toward source
+     * @param {boolean} [options.autoPipe=true]
+     * @param {boolean} [options.autoDestroy=true] Ignored if auto-piping
+     * @param {boolean} [options.autoPause=false]
+     * @return {Readable} previous tailend stream
+     */
+    addDownstream(downstream: import("stream").Duplex, options?: {
+        forwardErrors?: boolean;
+        autoPipe?: boolean;
+        autoDestroy?: boolean;
+        autoPause?: boolean;
+    }): Readable;
+    get bodyUsed(): boolean;
+    /**
+     * @throws {Error<'NOT_SUPPORTED'>}
+     * @return {?ReadableStream}
+     */
+    get readable(): ReadableStream | null;
+    read(): Promise<any>;
+    /**
+     * @throws {Error<'MAX_BUFFER_SIZE_REACHED'>}
+     * @return {Promise<Buffer>}
+     */
+    buffer(): Promise<Buffer>;
+    /**
+     * @return {Promise<ArrayBufferLike>}
+     */
+    arrayBuffer(): Promise<ArrayBufferLike>;
+    blob(): Promise<Blob | import("buffer").Blob>;
+    text(): Promise<string>;
+    /** @return {Promise<any>} */
+    json(): Promise<any>;
+    get mediaType(): import("../data/custom-types.js").MediaType;
+    /** @return {null|undefined|string} */
+    get charset(): null | undefined | string;
+    get bufferEncoding(): BufferEncoding;
+    formData(): Promise<void>;
+    get searchParams(): URLSearchParams;
+    toJSON(): string;
+    toString(): string;
+    get body(): ReadableStream<any>;
+    #private;
+}
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type IncomingHttpHeaders = import("http").IncomingHttpHeaders;
+export type MediaType = import("../data/custom-types.js").MediaType;
+export type ContentReaderRegistration = Partial<MediaType> & {
+    parse: (this: HttpRequest) => any | PromiseLike<any>;
+    test?: (this: HttpRequest, mediaType: MediaType) => boolean;
+};
+export type HttpRequestOptions = {
+    headers?: IncomingHttpHeaders;
+    method: RequestMethod;
+    stream: Readable;
+    /**
+     * URL.href
+     */
+    href: string;
+    /**
+     * URL.origin
+     */
+    origin: URL["origin"];
+    /**
+     * URL.protocol
+     */
+    protocol: URL["protocol"];
+    /**
+     * URL.username
+     */
+    username: URL["username"];
+    /**
+     * URL.password
+     */
+    password: URL["password"];
+    /**
+     * URL.host
+     */
+    host: URL["host"];
+    /**
+     * URL.hostname
+     */
+    hostname: URL["hostname"];
+    /**
+     * URL.port
+     */
+    port: URL["port"];
+    /**
+     * URL.pathname
+     */
+    pathname: URL["pathname"];
+    /**
+     * URL.search
+     */
+    search: URL["search"];
+    /**
+     * URL.hash
+     */
+    hash: URL["hash"];
+    scheme: string;
+    authority: string;
+    /**
+     * unparsed path
+     */
+    path: string;
+    /**
+     * unparsed url
+     */
+    url: string;
+    query: string;
+    fragment: string;
+};
+import { Readable } from 'node:stream';
+import { URLSearchParams } from 'node:url';
+//# sourceMappingURL=HttpRequest.d.ts.map

package/types/lib/HttpRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpRequest.d.ts","sourceRoot":"","sources":["../../lib/HttpRequest.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;GAEG;AACH,4CAFgB,GAAG;IA8BjB,0CAA0C;IAC1C,qBADY,kBAAkB,EAyB7B;IAzCD,wFAAwF;IACxF,yBADW,MAAM,CACmB;IAEpC,wFAAwF;IACxF,yBADW,MAAM,CACyB;IAE1C,4FAA4F;IAC5F,iBADW,MAAM,CACkB;IAEnC,0CAA0C;IAC1C,gBADW,yBAAyB,EAAE,CAKpC;IAIA,kCAAkC;IAClC,SADW,mBAAmB,CACM;IACpC,wDAA4B;IAC5B,iBAA4B;IAE5B,aAAwB;IACxB,eAA4B;IAC5B,iBAAgC;IAChC,iBAAgC;IAChC,iBAAgC;IAChC,aAAwB;IACxB,iBAAgC;IAChC,aAAwB;IACxB,iBAAgC;IAChC,eAA4B;IAC5B,aAAwB;IAExB,eAA4B;IAC5B,kBAAkC;IAClC,aAAwB;IACxB,cAA0B;IAC1B,iBAAgC;IAChC,YAAsB;IAGxB;;;;;;;;OAQG;IACH,0BARW,OAAO,QAAQ,EAAE,MAAM,YAE/B;QAA0B,aAAa,GAA/B,OAAO;QACW,QAAQ,GAA1B,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,SAAS,GAA3B,OAAO;KACf,GAAS,QAAQ,CAwBnB;IAED,wBAAyC;IAEzC;;;OAGG;IACH,gBAFa,cAAc,OAAA,CAiB1B;IAED,qBA+BC;IAED;;;OAGG;IACH,UAFY,OAAO,CAAC,MAAM,CAAC,CAqC1B;IAED;;OAEG;IACH,eAFY,OAAO,CAAC,eAAe,CAAC,CAYnC;IAED,8CA2CC;IAED,wBAsBC;IAED,6BAA6B;IAC7B,QADa,OAAO,CAAC,GAAG,CAAC,CAQxB;IAED,6DAwCC;IAED,sCAAsC;IACtC,eADa,IAAI,GAAC,SAAS,GAAC,MAAM,CAGjC;IAED,qCAqBC;IAGD,0BAEC;IAED,oCAGC;IAED,iBAEC;IAED,mBAEC;IAED,gCAEC;;CACF;4BA3Za,OAAO,yBAAyB,EAAE,aAAa;kCAC/C,OAAO,MAAM,EAAE,mBAAmB;wBAClC,OAAO,yBAAyB,EAAE,SAAS;wCAE3C,OAAO,CAAC,SAAS,CAAC,GAAG;IAAC,KAAK,EAAC,CAAC,IAAI,EAAC,WAAW,KAAG,GAAG,GAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAAC,IAAI,CAAC,EAAC,CAAC,IAAI,EAAC,WAAW,EAAE,SAAS,EAAE,SAAS,KAAG,OAAO,CAAA;CAAC;;cAYlI,mBAAmB;YACnB,aAAa;YACb,QAAQ;;;;UACR,MAAM;;;;YACN,GAAG,CAAC,QAAQ,CAAC;;;;cACb,GAAG,CAAC,UAAU,CAAC;;;;cACf,GAAG,CAAC,UAAU,CAAC;;;;cACf,GAAG,CAAC,UAAU,CAAC;;;;UACf,GAAG,CAAC,MAAM,CAAC;;;;cACX,GAAG,CAAC,UAAU,CAAC;;;;UACf,GAAG,CAAC,MAAM,CAAC;;;;cACX,GAAG,CAAC,UAAU,CAAC;;;;YACf,GAAG,CAAC,QAAQ,CAAC;;;;UACb,GAAG,CAAC,MAAM,CAAC;YACX,MAAM;eACN,MAAM;;;;UACN,MAAM;;;;SACN,MAAM;WACN,MAAM;cACN,MAAM;;yBAtCS,aAAa;gCACN,UAAU"}