webhoster 0.3.4 → 0.3.6

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/custom-types.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,2DAA0C;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"}

package/types/lib/HttpResponse.d.ts

@@ -0,0 +1,117 @@
+/** @typedef {import('http').OutgoingHttpHeaders} OutgoingHttpHeaders */
+/** @typedef {import('stream').Stream} Stream */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
+/** @typedef {import('./HttpRequest.js').default} HttpRequest */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
+/**
+ * @typedef {Object} HttpResponseOptions
+ * @prop {HttpRequest} [request]
+ * @prop {OutgoingHttpHeaders} [headers]
+ * @prop {function():boolean} [onHeadersSent]
+ * @prop {(flush:boolean, end:boolean) => any} [onSendHeaders]
+ * @prop {number} [status]
+ * @prop {Writable} stream
+ * @prop {Stream[]} [pipes]
+ * @prop {ResponseFinalizer[]} [finalizers] inline middleware for message body
+ * @prop {any} [body]
+ */
+export default class HttpResponse {
+    /** @param {HttpResponseOptions} options */
+    constructor(options: HttpResponseOptions);
+    request: import("./HttpRequest.js").default;
+    /** @type {OutgoingHttpHeaders} */
+    headers: OutgoingHttpHeaders;
+    isStreaming: boolean;
+    stream: import("stream").Writable;
+    pipes: import("stream").Stream[];
+    /** @type {ResponseFinalizer[]} */
+    finalizers: ResponseFinalizer[];
+    status: number;
+    /** @type {any} */
+    body: any;
+    set statusCode(number: number);
+    get statusCode(): number;
+    /**
+     * A boolean indicating whether the response was successful (status in the range 200–299) or not.
+     * @return {boolean}
+     */
+    get ok(): boolean;
+    get headersSent(): boolean;
+    /**
+     * @param {boolean} [flush] Flush headers
+     * @param {boolean} [end] End stream
+     * @return {void}
+     */
+    sendHeaders(flush?: boolean, end?: boolean): void;
+    /**
+     * @param {number} [status]
+     * @return {Promise<0>} HttpHandler.END
+     */
+    sendStatusOnly(status?: number): Promise<0>;
+    /**
+     * Send message body to response stream without finalizers
+     * @param {any} [body]
+     * @return {Promise<0>}
+     */
+    sendRaw(body?: any): Promise<0>;
+    /** @return {boolean} */
+    hasPipeline(): boolean;
+    /**
+     * @param {import('stream').Transform} stream
+     * @return {this}
+     */
+    addUpstream(stream: import("stream").Transform): this;
+    /**
+     * @param {(err: NodeJS.ErrnoException | null) => void} [callback] pipeline completion
+     * @return {Writable}
+     */
+    getPipeline(callback?: (err: NodeJS.ErrnoException | null) => void): Writable;
+    /**
+     * Asynchronously sends message body
+     * Returns on completions
+     * @throws {Error}
+     * @param {any} [body]
+     * @return {Promise<0>} HttpHandler.END
+     */
+    send(body?: any): Promise<0>;
+    wasEndCalled(): boolean;
+    /**
+     * Synchronously ends stream with message body. Ignores errors
+     * @param {any} [body]
+     * @return {0} HttpHandler.END
+     */
+    end(body?: any): 0;
+    /**
+     * @param {number} status
+     * @return {this}
+     */
+    code(status: number): this;
+    /**
+     * @param {number} status
+     * @throws {Error<ERR_HEADER_SENT>}
+     * @return {this}
+     */
+    setStatus(status: number): this;
+    #private;
+}
+export type Writable = import("stream").Writable;
+export type OutgoingHttpHeaders = import("http").OutgoingHttpHeaders;
+export type Stream = import("stream").Stream;
+export type Middleware = import("../data/custom-types.js").Middleware;
+export type HttpRequest = import("./HttpRequest.js").default;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type HttpResponseOptions = {
+    request?: HttpRequest;
+    headers?: OutgoingHttpHeaders;
+    onHeadersSent?: () => boolean;
+    onSendHeaders?: (flush: boolean, end: boolean) => any;
+    status?: number;
+    stream: Writable;
+    pipes?: Stream[];
+    /**
+     * inline middleware for message body
+     */
+    finalizers?: ResponseFinalizer[];
+    body?: any;
+};
+//# sourceMappingURL=HttpResponse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HttpResponse.d.ts","sourceRoot":"","sources":["../../lib/HttpResponse.js"],"names":[],"mappings":"AAWA,wEAAwE;AACxE,gDAAgD;AAChD,yEAAyE;AACzE,gEAAgE;AAChE,uFAAuF;AAEvF;;;;;;;;;;;GAWG;AAEH;IAmBE,2CAA2C;IAC3C,qBADY,mBAAmB,EAe9B;IAbC,4CAA8B;IAC9B,kCAAkC;IAClC,SADW,mBAAmB,CACM;IACpC,qBAAwB;IACxB,kCAA4B;IAC5B,iCAAgC;IAChC,kCAAkC;IAClC,YADW,iBAAiB,EAAE,CACY;IAC1C,eAA4B;IAC5B,kBAAkB;IAClB,MADW,GAAG,CACU;IAS1B,+BAEC;IAND,yBAEC;IAMD;;;OAGG;IACH,UAFY,OAAO,CAIlB;IAED,2BAIC;IAED;;;;OAIG;IACH,oBAJW,OAAO,QACP,OAAO,GACN,IAAI,CAWf;IAED;;;OAGG;IACH,wBAHW,MAAM,GACL,OAAO,CAAC,CAAC,CAAC,CAUrB;IAED;;;;OAIG;IACH,eAHW,GAAG,GACF,OAAO,CAAC,CAAC,CAAC,CASrB;IAED,wBAAwB;IACxB,eADa,OAAO,CAGnB;IAED;;;OAGG;IACH,oBAHW,OAAO,QAAQ,EAAE,SAAS,GACzB,IAAI,CAKf;IAED;;;OAGG;IACH,uBAHW,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,KAAK,IAAI,GAC1C,QAAQ,CAmDnB;IAED;;;;;;OAMG;IACH,YAHW,GAAG,GACF,OAAO,CAAC,CAAC,CAAC,CA6CrB;IAED,wBAEC;IAED;;;;OAIG;IACH,WAHW,GAAG,GACF,CAAC,CAmGZ;IAID;;;OAGG;IACH,aAHW,MAAM,GACL,IAAI,CAKf;IAED;;;;OAIG;IACH,kBAJW,MAAM,GAEL,IAAI,CAMf;;CACF;uBAzXa,OAAO,QAAQ,EAAE,QAAQ;kCAMzB,OAAO,MAAM,EAAE,mBAAmB;qBAClC,OAAO,QAAQ,EAAE,MAAM;yBACvB,OAAO,yBAAyB,EAAE,UAAU;0BAC5C,OAAO,kBAAkB,EAAE,OAAO;gCAClC,OAAO,yBAAyB,EAAE,iBAAiB;;cAIvD,WAAW;cACX,mBAAmB;oBACnB,MAAW,OAAO;oBAClB,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,EAAC,OAAO,KAAK,GAAG;aACnC,MAAM;YACN,QAAQ;YACR,MAAM,EAAE;;;;iBACR,iBAAiB,EAAE;WACnB,GAAG"}

package/types/lib/HttpTransaction.d.ts

@@ -0,0 +1,114 @@
+/** @typedef {import('./HttpRequest.js').default} HttpRequest */
+/** @typedef {import('./HttpResponse.js').default} HttpResponse */
+/** @typedef {import('stream').Stream} Stream */
+/** @typedef {import('../data/custom-types.js').MediaType} MediaType */
+/** @typedef {import('../data/custom-types.js').Middleware} Middleware */
+/** @typedef {import('stream').Writable} Writable */
+/** @typedef {Partial<MediaType> & {parse:(this:HttpRequest)=>any|PromiseLike<any>, test?:(this:HttpRequest, mediaType: MediaType)=>boolean}} ContentReaderRegistration */
+/**
+ * @typedef {Object} PathHistoryEntry
+ * @prop {string} base
+ * @prop {number[]} treeIndex
+ */
+/**
+ * @typedef {Object} PathState
+ * @prop {PathHistoryEntry[]} history
+ * @prop {string} currentPath
+ */
+/**
+ * @typedef {Object} HttpTransactionState
+ * @prop {number[]} treeIndex Middleware level
+ * @prop {PathState} path
+ */
+/**
+ * @template {Object<string,any>} T
+ * @typedef HttpTransactionOptions
+ * @prop {string} httpVersion
+ * @prop {HttpRequest} [request]
+ * @prop {HttpResponse} [response]
+ * @prop {import('net').Socket|import('tls').TLSSocket} socket
+ * @prop {boolean} [canPing]
+ * @prop {(function():Promise<any>)|(function():any)} [onPing]
+ * @prop {boolean|function():boolean} [canPushPath]
+ * @prop {(path:string) => Promise<any>} [onPushPath]
+ * @prop {function():boolean} [onHeadersSent]
+ * @prop {(flush:boolean, end:boolean) => boolean} [onSendHeaders]
+ * @prop {T} [locals]
+ * @prop {HttpTransactionState} [state]
+ * @prop {Error} [error]
+ */
+/**
+ * @template {Object<string,any>} [T=any]
+ */
+export default class HttpTransaction<T extends {
+    [x: string]: any;
+} = any> {
+    /** @param {HttpTransactionOptions<T>} options */
+    constructor(options: HttpTransactionOptions<T>);
+    request: import("./HttpRequest.js").default;
+    response: import("./HttpResponse.js").default;
+    /** @type {T} */
+    locals: T;
+    state: HttpTransactionState;
+    socket: import("net").Socket | import("tls").TLSSocket;
+    httpVersion: string;
+    error: Error;
+    setErrorHandlerState(): void;
+    isErrorHandlerState(): boolean;
+    get canPing(): boolean;
+    /**
+     * @return {Promise<any>}
+     */
+    ping(): Promise<any>;
+    get pushedPaths(): string[];
+    get canPushPath(): boolean;
+    /**
+     * @param {string} [path]
+     * @return {Promise<any>}
+     */
+    pushPath(path?: string): Promise<any>;
+    #private;
+}
+export type HttpRequest = import("./HttpRequest.js").default;
+export type HttpResponse = import("./HttpResponse.js").default;
+export type Stream = import("stream").Stream;
+export type MediaType = import("../data/custom-types.js").MediaType;
+export type Middleware = import("../data/custom-types.js").Middleware;
+export type Writable = import("stream").Writable;
+export type ContentReaderRegistration = Partial<MediaType> & {
+    parse: (this: HttpRequest) => any | PromiseLike<any>;
+    test?: (this: HttpRequest, mediaType: MediaType) => boolean;
+};
+export type PathHistoryEntry = {
+    base: string;
+    treeIndex: number[];
+};
+export type PathState = {
+    history: PathHistoryEntry[];
+    currentPath: string;
+};
+export type HttpTransactionState = {
+    /**
+     * Middleware level
+     */
+    treeIndex: number[];
+    path: PathState;
+};
+export type HttpTransactionOptions<T extends {
+    [x: string]: any;
+}> = {
+    httpVersion: string;
+    request?: HttpRequest;
+    response?: HttpResponse;
+    socket: import("net").Socket | import("tls").TLSSocket;
+    canPing?: boolean;
+    onPing?: (() => Promise<any>) | (() => any);
+    canPushPath?: boolean | (() => boolean);
+    onPushPath?: (path: string) => Promise<any>;
+    onHeadersSent?: () => boolean;
+    onSendHeaders?: (flush: boolean, end: boolean) => boolean;
+    locals?: T;
+    state?: HttpTransactionState;
+    error?: Error;
+};
+//# sourceMappingURL=HttpTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HttpTransaction.d.ts","sourceRoot":"","sources":["../../lib/HttpTransaction.js"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,kEAAkE;AAClE,gDAAgD;AAEhD,uEAAuE;AACvE,yEAAyE;AACzE,oDAAoD;AAEpD,0KAA0K;AAE1K;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;GAEG;AACH,qCAFmC,CAAC,SAAvB;QAAQ,MAAM,GAAC,GAAG;CAAE;IAoB/B,iDAAiD;IACjD,qBADY,sBAAsB,CAAC,CAAC,CAAC,EAsBpC;IApBC,4CAA8B;IAC9B,8CAAgC;IAEhC,gBAAgB;IAChB,QADW,CAAC,CACyC;IACrD,4BAGC;IAED,uDAA4B;IAC5B,oBAAsC;IAQtC,aAA0B;IAG5B,6BAEC;IAED,+BAEC;IAED,uBAIC;IAED;;OAEG;IACH,QAFY,OAAO,CAAC,GAAG,CAAC,CAUvB;IAED,4BAEC;IAED,2BAIC;IAED;;;OAGG;IACH,gBAHW,MAAM,GACL,OAAO,CAAC,GAAG,CAAC,CAcvB;;CACF;0BAjJa,OAAO,kBAAkB,EAAE,OAAO;2BAClC,OAAO,mBAAmB,EAAE,OAAO;qBACnC,OAAO,QAAQ,EAAE,MAAM;wBAEvB,OAAO,yBAAyB,EAAE,SAAS;yBAC3C,OAAO,yBAAyB,EAAE,UAAU;uBAC5C,OAAO,QAAQ,EAAE,QAAQ;wCAEzB,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;;UAIlI,MAAM;eACN,MAAM,EAAE;;;aAKR,gBAAgB,EAAE;iBAClB,MAAM;;;;;;eAKN,MAAM,EAAE;UACR,SAAS;;mCAIe,CAAC,SAAtB;QAAQ,MAAM,GAAC,GAAG;CAAE;iBAEvB,MAAM;cACN,WAAW;eACX,YAAY;YACZ,OAAO,KAAK,EAAE,MAAM,GAAC,OAAO,KAAK,EAAE,SAAS;cAC5C,OAAO;aACP,CAAC,MAAW,OAAO,CAAC,GAAG,CAAC,CAAC,GAAC,CAAC,MAAW,GAAG,CAAC;kBAC1C,OAAO,IAAC,MAAW,OAAO,CAAA;iBAC1B,CAAC,IAAI,EAAC,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;oBAC7B,MAAW,OAAO;oBAClB,CAAC,KAAK,EAAC,OAAO,EAAE,GAAG,EAAC,OAAO,KAAK,OAAO;aACvC,CAAC;YACD,oBAAoB;YACpB,KAAK"}

package/types/middleware/AutoHeadersMiddleware.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @typedef {Object} AutoHeadersMiddlewareOptions
+ * @prop {boolean} [setStatus=true]
+ * Automatically set `200` or `204` status if not set
+ */
+export default class AutoHeadersMiddleware {
+    /** @param {AutoHeadersMiddlewareOptions} options */
+    constructor(options?: AutoHeadersMiddlewareOptions);
+    setStatus: boolean;
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    /**
+     * @param {HttpResponse} response
+     * @return {void}
+     */
+    addTransformStream(response: HttpResponse): void;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type AutoHeadersMiddlewareOptions = {
+    /**
+     * Automatically set `200` or `204` status if not set
+     */
+    setStatus?: boolean;
+};
+//# sourceMappingURL=AutoHeadersMiddleware.d.ts.map

package/types/middleware/AutoHeadersMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutoHeadersMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/AutoHeadersMiddleware.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;IACE,oDAAoD;IACpD,sBADY,4BAA4B,EAIvC;IAFC,mBAA4C;;IAI9C;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CA+Bf;;CAoBF;2BAxEa,OAAO,wBAAwB,EAAE,OAAO;gCACxC,OAAO,yBAAyB,EAAE,iBAAiB;iCACnD,OAAO,yBAAyB,EAAE,kBAAkB;;;;;gBAMxD,OAAO"}

package/types/middleware/CORSMiddleware.d.ts

@@ -0,0 +1,65 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
+/**
+ * @typedef CORSMiddlewareOptions
+ * @prop {(string|RegExp)[]} [allowOrigin]
+ * Indicates whether the response can be shared, via returning the literal
+ * value of the `Origin` request header (which can be `null`) or `*` in a response.
+ * @prop {boolean} [allowCredentials]
+ * Indicates whether the response can be shared when request’s credentials mode is "include".
+ * @prop {RequestMethod[]} [allowMethods]
+ * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
+ * @prop {string[]} [allowHeaders]
+ * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
+ * @prop {number} [maxAge=5]
+ * Indicates the number of seconds (5 by default) the information provided by the
+ * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
+ * @prop {string[]} [exposeHeaders]
+ * Indicates which headers can be exposed as part of the response by listing their names.
+ */
+export default class CORSMiddleware {
+    static OK_BUFFER: Buffer<ArrayBuffer>;
+    static ACCESS_CONTROL_ALLOW_HEADERS_ALL: string;
+    /** @param {CORSMiddlewareOptions} [options] */
+    constructor(options?: CORSMiddlewareOptions);
+    allowOrigin: (string | RegExp)[];
+    allowCredentials: boolean;
+    allowMethods: import("../data/custom-types.js").RequestMethod[];
+    allowHeaders: string[];
+    maxAge: number;
+    exposeHeaders: string[];
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IMiddleware = import("../data/custom-types.js").IMiddleware;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type CORSMiddlewareOptions = {
+    /**
+     * Indicates whether the response can be shared, via returning the literal
+     * value of the `Origin` request header (which can be `null`) or `*` in a response.
+     */
+    allowOrigin?: (string | RegExp)[];
+    /**
+     * Indicates whether the response can be shared when request’s credentials mode is "include".
+     */
+    allowCredentials?: boolean;
+    /**
+     * Indicates which methods are supported by the response’s URL for the purposes of the CORS protocol.
+     */
+    allowMethods?: RequestMethod[];
+    /**
+     * Indicates which headers are supported by the response’s URL for the purposes of the CORS protocol.
+     */
+    allowHeaders?: string[];
+    /**
+     * Indicates the number of seconds (5 by default) the information provided by the
+     * `Access-Control-Allow-Methods` and `Access-Control-Allow-Headers` headers can be cached.
+     */
+    maxAge?: number;
+    /**
+     * Indicates which headers can be exposed as part of the response by listing their names.
+     */
+    exposeHeaders?: string[];
+};
+//# sourceMappingURL=CORSMiddleware.d.ts.map

package/types/middleware/CORSMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CORSMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/CORSMiddleware.js"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,yFAAyF;AACzF,+EAA+E;AAE/E;;;;;;;;;;;;;;;;GAgBG;AAEH;IAWE,sCAA8C;IAE9C,gDAEY;IAdZ,+CAA+C;IAC/C,sBADY,qBAAqB,EAQhC;IANC,iCAAsC;IACtC,0BAAyD;IACzD,gEAAwC;IACxC,uBAAwC;IACxC,eAAiC;IACjC,wBAA0C;;CAkE7C;0BAhGa,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;4BACpD,OAAO,yBAAyB,EAAE,aAAa;;;;;;kBAInD,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE;;;;uBAGjB,OAAO;;;;mBAEP,aAAa,EAAE;;;;mBAEf,MAAM,EAAE;;;;;aAER,MAAM;;;;oBAGN,MAAM,EAAE"}

package/types/middleware/CaseInsensitiveHeadersMiddleware.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/**
+ * @typedef {Object} CaseInsensitiveHeadersMiddlewareOptions
+ * @prop {boolean} [request=false] Mutate request headers to be case-insensitive
+ * @prop {boolean} [response=false] Mutate response headers to be case-insensistive
+ */
+export default class CaseInsensitiveHeadersMiddleware {
+    /** @param {CaseInsensitiveHeadersMiddlewareOptions} options */
+    constructor(options: CaseInsensitiveHeadersMiddlewareOptions);
+    request: boolean;
+    response: boolean;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IMiddleware = import("../data/custom-types.js").IMiddleware;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type CaseInsensitiveHeadersMiddlewareOptions = {
+    /**
+     * Mutate request headers to be case-insensitive
+     */
+    request?: boolean;
+    /**
+     * Mutate response headers to be case-insensistive
+     */
+    response?: boolean;
+};
+//# sourceMappingURL=CaseInsensitiveHeadersMiddleware.d.ts.map

package/types/middleware/CaseInsensitiveHeadersMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseInsensitiveHeadersMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/CaseInsensitiveHeadersMiddleware.js"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,yFAAyF;AAEzF;;;;GAIG;AAEH;IACE,+DAA+D;IAC/D,qBADY,uCAAuC,EAIlD;IAFC,iBAAuC;IACvC,kBAAyC;;CAc5C;0BA3Ba,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;;;;;cAIxD,OAAO;;;;eACP,OAAO"}

package/types/middleware/ContentDecoderMiddleware.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Implements `Accept-Encoding`
+ * https://tools.ietf.org/html/rfc7231#section-5.3.4
+ */
+export default class ContentDecoderMiddleware {
+    /** @param {ContentDecoderMiddlewareOptions} [options] */
+    constructor(options?: ContentDecoderMiddlewareOptions);
+    chunkSize: number;
+    respondNotAcceptable: boolean;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ContentDecoderMiddlewareOptions = {
+    chunkSize?: number;
+    respondNotAcceptable?: boolean;
+};
+//# sourceMappingURL=ContentDecoderMiddleware.d.ts.map

package/types/middleware/ContentDecoderMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentDecoderMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentDecoderMiddleware.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE,yDAAyD;IACzD,sBADY,+BAA+B,EAI1C;IAFC,kBAAkC;IAClC,8BAAiE;;CAoHpE;iCAtIa,OAAO,yBAAyB,EAAE,kBAAkB;;gBAIxD,MAAM;2BACN,OAAO"}