webhoster 0.3.4 → 0.3.5

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentLengthMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentLengthMiddleware.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH;IACE,wDAAwD;IACxD,sBADY,8BAA8B,EAKzC;IAHC,oBAA2C;IAC3C,wBAAqD;;IAIvD;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CAwDf;;CA+BF;2BAjHa,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;;;;;;kBAMvD,MAAM;;;;qBAIN,OAAO"}

package/types/middleware/HashMiddleware.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @typedef {Object} HashMiddlewareOptions
+ * @prop {'md5'|'sha1'|'sha256'|'sha512'} [algorithm=DEFAULT_ALGORITHM]
+ * @prop {BinaryToTextEncoding} [digest=DEFAULT_DIGEST]
+ */
+export default class HashMiddleware {
+    /** @param {HashMiddlewareOptions} options */
+    constructor(options?: HashMiddlewareOptions);
+    algorithm: "sha1" | "md5" | "sha256" | "sha512";
+    digest: import("crypto").BinaryToTextEncoding;
+    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 BinaryToTextEncoding = import("node:crypto").BinaryToTextEncoding;
+export type HttpRequest = import("../lib/HttpRequest.js").default;
+export type HttpResponse = import("../lib/HttpResponse.js").default;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type HashMiddlewareOptions = {
+    algorithm?: "md5" | "sha1" | "sha256" | "sha512";
+    digest?: BinaryToTextEncoding;
+};
+//# sourceMappingURL=HashMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HashMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/HashMiddleware.js"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH;IACE,6CAA6C;IAC7C,sBADY,qBAAqB,EAKhC;IAHC,gDAAuD;IACvD,8CAA8C;;IAIhD;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CAiDf;;CA8BF;mCAzGa,OAAO,aAAa,EAAE,oBAAoB;0BAC1C,OAAO,uBAAuB,EAAE,OAAO;2BACvC,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;gBAQvD,KAAK,GAAC,MAAM,GAAC,QAAQ,GAAC,QAAQ;aAC9B,oBAAoB"}

package/types/middleware/HeadMethodMiddleware.d.ts

@@ -0,0 +1,12 @@
+export default class HeadMethodMiddleware {
+    /** @type {ConstructorParameters<typeof Transform>[0]} */
+    static DEFAULT_TRANSFORM_OPTIONS: ConstructorParameters<typeof Transform>[0];
+    static FinalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    static Execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    execute: any;
+}
+export type HttpTransaction = import("../data/custom-types.js").HttpTransaction;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+import { Transform } from 'node:stream';
+//# sourceMappingURL=HeadMethodMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HeadMethodMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/HeadMethodMiddleware.js"],"names":[],"mappings":"AAMA;IAKE,yDAAyD;IACzD,kCADW,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAInD;;;IAPA,aAAsD;CAuBzD;8BA/Ba,OAAO,yBAAyB,EAAE,eAAe;iCACjD,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;0BAEvC,aAAa"}

package/types/middleware/MethodMiddleware.d.ts

@@ -0,0 +1,40 @@
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
+/** @typedef {RegExp|RequestMethod} MethodEntry */
+/**
+ * @typedef {Object} MethodMiddlewareOptions
+ * @prop {MethodEntry|MethodEntry[]} method
+ */
+export default class MethodMiddleware {
+    /** @type {Map<MethodEntry, MethodMiddleware>} */
+    static cache: Map<MethodEntry, MethodMiddleware>;
+    /**
+     * @param {RequestMethod} method
+     * @param {RegExp | string} input
+     * @return {boolean}
+     */
+    static test(method: RequestMethod, input: RegExp | string): boolean;
+    static CONNECT(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static DELETE(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static HEADORGET(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static GET(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static OPTIONS(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static HEAD(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static PATCH(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static POST(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static PUT(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    static TRACE(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    /** @param {MethodMiddlewareOptions|MethodEntry|MethodEntry[]} options */
+    constructor(options: MethodMiddlewareOptions | MethodEntry | MethodEntry[]);
+    method: MethodEntry[];
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpTransaction = import("../data/custom-types.js").HttpTransaction;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type RequestMethod = import("../data/custom-types.js").RequestMethod;
+export type MethodEntry = RegExp | RequestMethod;
+export type MethodMiddlewareOptions = {
+    method: MethodEntry | MethodEntry[];
+};
+//# sourceMappingURL=MethodMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/MethodMiddleware.js"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,yFAAyF;AACzF,+EAA+E;AAE/E,kDAAkD;AAElD;;;GAGG;AAEH;IAYE,iDAAiD;IACjD,cADW,GAAG,CAAC,WAAW,EAAE,gBAAgB,CAAC,CACpB;IAEzB;;;;OAIG;IACH,oBAJW,aAAa,SACb,MAAM,GAAG,MAAM,GACd,OAAO,CAOlB;;;;;;;;;;;IAxBD,yEAAyE;IACzE,qBADY,uBAAuB,GAAC,WAAW,GAAC,WAAW,EAAE,EAS5D;IANG,sBAAqB;;CA8D1B;8BA7Ea,OAAO,yBAAyB,EAAE,eAAe;iCACjD,OAAO,yBAAyB,EAAE,kBAAkB;4BACpD,OAAO,yBAAyB,EAAE,aAAa;0BAE/C,MAAM,GAAC,aAAa;;YAIxB,WAAW,GAAC,WAAW,EAAE"}

package/types/middleware/PathMiddleware.d.ts

@@ -0,0 +1,81 @@
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @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 {RegExp|string} PathEntry */
+/**
+ * @typedef {Object} PathHistoryEntry hello?
+ * @prop {string} base
+ * @prop {number[]} treeIndex
+ */
+/**
+ * @typedef {Object} PathState
+ * @prop {PathHistoryEntry[]} history
+ * @prop {string} currentPath
+ */
+/**
+ * @typedef {Object} PathMiddlewareOptions
+ * @prop {PathEntry|PathEntry[]} [path]
+ * @prop {boolean} [absolute=false]
+ * Path is not relative to previous PathMiddleware. Defaults to `false`.
+ * @prop {boolean} [subPath=false]
+ * Path values are subpaths. Default to `false`;
+ */
+export default class PathMiddleware {
+    /**
+     * @param {PathEntry|PathEntry[]} entry
+     */
+    static SUBPATH(entry: PathEntry | PathEntry[]): PathMiddleware;
+    /**
+     * @param {string} path
+     * @param {RegExp | string} input
+     * @return {?string}
+     */
+    static test(path: string, input: RegExp | string): string | null;
+    /**
+     * @param {HttpTransaction} transaction
+     * @param {string} base new base subpath
+     * @param {string} currentPath
+     * @return {void}
+     */
+    static WritePathState(transaction: HttpTransaction, base: string, currentPath: string): void;
+    /**
+     * @param {HttpTransaction} transaction
+     * @return {string} joined base path
+     */
+    static ReadPathState(transaction: HttpTransaction): string;
+    /** @param {PathMiddlewareOptions|PathEntry|PathEntry[]} options */
+    constructor(options: PathMiddlewareOptions | PathEntry | PathEntry[]);
+    path: PathEntry[];
+    absolute: boolean;
+    subPath: boolean;
+    execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type HttpTransaction = import("../data/custom-types.js").HttpTransaction;
+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 PathEntry = RegExp | string;
+/**
+ * hello?
+ */
+export type PathHistoryEntry = {
+    base: string;
+    treeIndex: number[];
+};
+export type PathState = {
+    history: PathHistoryEntry[];
+    currentPath: string;
+};
+export type PathMiddlewareOptions = {
+    path?: PathEntry | PathEntry[];
+    /**
+     * Path is not relative to previous PathMiddleware. Defaults to `false`.
+     */
+    absolute?: boolean;
+    /**
+     * Path values are subpaths. Default to `false`;
+     */
+    subPath?: boolean;
+};
+//# sourceMappingURL=PathMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PathMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/PathMiddleware.js"],"names":[],"mappings":"AAEA,mFAAmF;AACnF,2EAA2E;AAC3E,yFAAyF;AACzF,+EAA+E;AAE/E,yCAAyC;AAEzC;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;GAOG;AAEH;IACE;;OAEG;IACH,sBAFW,SAAS,GAAC,SAAS,EAAE,kBAQ/B;IAED;;;;OAIG;IACH,kBAJW,MAAM,SACN,MAAM,GAAG,MAAM,GACb,MAAM,OAAA,CAYlB;IAED;;;;;OAKG;IACH,mCALW,eAAe,QACf,MAAM,eACN,MAAM,GACL,IAAI,CAWf;IAED;;;OAGG;IACH,kCAHW,eAAe,GACd,MAAM,CA4BjB;IAED,mEAAmE;IACnE,qBADY,qBAAqB,GAAC,SAAS,GAAC,SAAS,EAAE,EAetD;IAZG,kBAAmB;IACnB,kBAAqB;IACrB,iBAAoB;;CA4BzB;8BA3Ia,OAAO,yBAAyB,EAAE,eAAe;0BACjD,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;4BACpD,OAAO,yBAAyB,EAAE,aAAa;wBAE/C,MAAM,GAAC,MAAM;;;;;UAIjB,MAAM;eACN,MAAM,EAAE;;;aAKR,gBAAgB,EAAE;iBAClB,MAAM;;;WAKN,SAAS,GAAC,SAAS,EAAE;;;;eACrB,OAAO;;;;cAEP,OAAO"}

package/types/middleware/ReadFormData.d.ts

@@ -0,0 +1,7 @@
+export default class ReadFormData {
+    static Execute(transaction: import("../lib/HttpTransaction.js").default<any>): import("../data/custom-types.js").MiddlewareFunctionResult;
+    execute: any;
+}
+export type HttpRequest = import("../lib/HttpRequest.js").default;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+//# sourceMappingURL=ReadFormData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReadFormData.d.ts","sourceRoot":"","sources":["../../middleware/ReadFormData.js"],"names":[],"mappings":"AAwFA;;IAEI,aAA8C;CAQjD;0BAlGa,OAAO,uBAAuB,EAAE,OAAO;iCACvC,OAAO,yBAAyB,EAAE,kBAAkB"}

package/types/middleware/SendJsonMiddleware.d.ts

@@ -0,0 +1,51 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareResponseFunction} MiddlewareResponseFunction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
+/**
+ * @typedef {Object} SendJsonMiddlewareOptions
+ * @prop {string} [defaultCharset='utf-8']
+ * @prop {boolean} [setCharset=true]
+ * Automatically applies charset in `Content-Type`
+ * @prop {boolean} [setMediaType=true]
+ * Automatically applies `application/json` mediatype in `Content-Type`
+ */
+export default class SendJsonMiddleware {
+    /** @type {SendJsonMiddleware} */
+    static "__#5@#defaultInstance": SendJsonMiddleware;
+    /**
+     * @param {string} charset
+     * @return {BufferEncoding}
+     */
+    static charsetAsBufferEncoding(charset: string): BufferEncoding;
+    static Execute(transaction: {
+        response: import("../lib/HttpResponse.js").default;
+    }): import("../data/custom-types.js").MiddlewareFunctionResult;
+    /** @param {SendJsonMiddlewareOptions} [options] */
+    constructor(options?: SendJsonMiddlewareOptions);
+    options: {
+        defaultCharset: string;
+        setCharset: boolean;
+        setMediaType: boolean;
+    };
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | boolean>;
+    execute(transaction: {
+        response: import("../lib/HttpResponse.js").default;
+    }): import("../data/custom-types.js").MiddlewareFunctionResult;
+}
+export type IMiddleware = import("../data/custom-types.js").IMiddleware;
+export type MiddlewareResponseFunction = import("../data/custom-types.js").MiddlewareResponseFunction;
+export type MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type SendJsonMiddlewareOptions = {
+    defaultCharset?: string;
+    /**
+     * Automatically applies charset in `Content-Type`
+     */
+    setCharset?: boolean;
+    /**
+     * Automatically applies `application/json` mediatype in `Content-Type`
+     */
+    setMediaType?: boolean;
+};
+//# sourceMappingURL=SendJsonMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SendJsonMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/SendJsonMiddleware.js"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,yGAAyG;AACzG,yFAAyF;AACzF,uFAAuF;AAEvF;;;;;;;GAOG;AAIH;IACE,iCAAiC;IACjC,gCADW,kBAAkB,CACL;IAExB;;;OAGG;IACH,wCAHW,MAAM,GACL,cAAc,CAsBzB;;;;IAcD,mDAAmD;IACnD,sBADY,yBAAyB,EASpC;IAPC;;;;MAIC;;;;;CAkEJ;0BAlIa,OAAO,yBAAyB,EAAE,WAAW;yCAC7C,OAAO,yBAAyB,EAAE,0BAA0B;iCAC5D,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;qBAIvD,MAAM;;;;iBACN,OAAO;;;;mBAEP,OAAO"}

package/types/middleware/SendStringMiddleware.d.ts

@@ -0,0 +1,35 @@
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
+/**
+ * @typedef {Object} SendStringMiddlewareOptions
+ * @prop {string} [defaultCharset='utf-8']
+ * @prop {boolean} [setCharset=true]
+ * Automatically applies charset in `Content-Type`
+ */
+export default class SendStringMiddleware {
+    /**
+     * @param {string} charset
+     * @return {BufferEncoding}
+     */
+    static charsetAsBufferEncoding(charset: string): BufferEncoding;
+    /** @param {SendStringMiddlewareOptions} [options] */
+    constructor(options?: SendStringMiddlewareOptions);
+    options: {
+        defaultCharset: string;
+        setCharset: boolean;
+    };
+    finalizeResponse(response: import("../data/custom-types.js").HttpResponse): void | null | boolean | Promise<void | null | 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 ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type SendStringMiddlewareOptions = {
+    defaultCharset?: string;
+    /**
+     * Automatically applies charset in `Content-Type`
+     */
+    setCharset?: boolean;
+};
+//# sourceMappingURL=SendStringMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SendStringMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/SendStringMiddleware.js"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,yFAAyF;AACzF,uFAAuF;AAEvF;;;;;GAKG;AAEH;IAWE;;;OAGG;IACH,wCAHW,MAAM,GACL,cAAc,CAsBzB;IAlCD,qDAAqD;IACrD,sBADY,2BAA2B,EAQtC;IANC;;;MAGC;;;CAqEJ;0BAtFa,OAAO,yBAAyB,EAAE,WAAW;iCAC7C,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;;qBAIvD,MAAM;;;;iBACN,OAAO"}

package/types/templates/starter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {Object} options
+ * @param {string} [options.host='0.0.0.0']
+ * @param {number} [options.port=8080]
+ * @param {import('../data/custom-types.js').Middleware[]} [options.middleware]
+ * @param {import('../data/custom-types.js').MiddlewareErrorHandler[]} [options.errorHandlers]
+ * @return {Promise<import('../helpers/HttpListener.js').default>}
+ */
+export function start(options: {
+    host?: string;
+    port?: number;
+    middleware?: import("../data/custom-types.js").Middleware[];
+    errorHandlers?: import("../data/custom-types.js").MiddlewareErrorHandler[];
+}): Promise<import("../helpers/HttpListener.js").default>;
+//# sourceMappingURL=starter.d.ts.map

package/types/templates/starter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter.d.ts","sourceRoot":"","sources":["../../templates/starter.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,+BANG;IAAyB,IAAI,GAArB,MAAM;IACW,IAAI,GAArB,MAAM;IACmD,UAAU,GAAnE,OAAO,yBAAyB,EAAE,UAAU,EAAE;IACuB,aAAa,GAAlF,OAAO,yBAAyB,EAAE,sBAAsB,EAAE;CAClE,GAAS,OAAO,CAAC,OAAO,4BAA4B,EAAE,OAAO,CAAC,CAqChE"}

package/types/utils/AsyncObject.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @template {any} T
+ * @class AsyncObject<T>
+ */
+export default class AsyncObject<T extends unknown> {
+    /** @param {T} [value] */
+    constructor(value?: T);
+    value: T;
+    ready: boolean;
+    busy: boolean;
+    /** @type {{resolve:function(T):void, reject:function(Error?):void}[]} */
+    pendingPromises: {
+        resolve: (arg0: T) => void;
+        reject: (arg0: Error | null) => void;
+    }[];
+    hasValue(): boolean;
+    isBusy(): boolean;
+    /** @return {Promise<T>} */
+    get(): Promise<T>;
+    /**
+     * @param {T} [value]
+     * @return {T}
+     */
+    set(value?: T): T;
+    /**
+     * @param {Error} [error] Error passed to pending promises
+     * @return {void}
+     */
+    reset(error?: Error): void;
+    /**
+     * Clear value and mark busy
+     * @return {void}
+     */
+    prepare(): void;
+    /** @return {void} */
+    setBusy(): void;
+}
+//# sourceMappingURL=AsyncObject.d.ts.map

package/types/utils/AsyncObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncObject.d.ts","sourceRoot":"","sources":["../../utils/AsyncObject.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,iCAHmB,CAAC;IAIlB,yBAAyB;IACzB,oBADY,CAAC,EAOZ;IALC,SAAkB;IAClB,eAAkB;IAClB,cAAiB;IACjB,yEAAyE;IACzE,iBADW;QAAC,OAAO,EAAC,CAAS,IAAC,EAAD,CAAC,KAAE,IAAI,CAAC;QAAC,MAAM,EAAC,CAAS,IAAM,EAAN,KAAK,OAAC,KAAE,IAAI,CAAA;KAAC,EAAE,CAC5C;IAG3B,oBAEC;IAED,kBAEC;IAED,2BAA2B;IAC3B,OADa,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;OAGG;IACH,YAHW,CAAC,GACA,CAAC,CAUZ;IAED;;;OAGG;IACH,cAHW,KAAK,GACJ,IAAI,CASf;IAED;;;OAGG;IACH,WAFY,IAAI,CAMf;IAED,qBAAqB;IACrB,WADa,IAAI,CAGhB;CACF"}

package/types/utils/CaseInsensitiveObject.d.ts

@@ -0,0 +1,9 @@
+declare class CaseInsensitiveObject {
+    /** @param {Object} [object] */
+    constructor(object?: Object);
+}
+declare namespace CaseInsensitiveObject {
+    let defaultProxyHandler: ProxyHandler<Object>;
+}
+export default CaseInsensitiveObject;
+//# sourceMappingURL=CaseInsensitiveObject.d.ts.map

package/types/utils/CaseInsensitiveObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaseInsensitiveObject.d.ts","sourceRoot":"","sources":["../../utils/CaseInsensitiveObject.js"],"names":[],"mappings":"AAAA;IACE,+BAA+B;IAC/B,qBADY,MAAM,EAajB;CACF;;6BAEU,YAAY,CAAC,MAAM,CAAC"}

package/types/utils/function.d.ts

@@ -0,0 +1,2 @@
+export function noop(): void;
+//# sourceMappingURL=function.d.ts.map

package/types/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../utils/function.js"],"names":[],"mappings":"AAAO,6BAAqB"}

package/types/utils/headers.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {?string} contentType
+ * @return {import('../data/custom-types.js').MediaType}
+ */
+export function parseContentType(contentType: string | null): import("../data/custom-types.js").MediaType;
+//# sourceMappingURL=headers.d.ts.map

package/types/utils/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../utils/headers.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,8CAHY,MAAM,OAAA,GACN,OAAO,yBAAyB,EAAE,SAAS,CAsCtD"}

package/types/utils/qualityValues.d.ts

@@ -0,0 +1,12 @@
+/** @typedef {{q:number?} & {[key:string]:string}} ParsedQualityValues */
+/**
+ * @param {string} input
+ * @return {Map<string, ParsedQualityValues>}
+ */
+export function parseQualityValues(input: string): Map<string, ParsedQualityValues>;
+export type ParsedQualityValues = {
+    q: number | null;
+} & {
+    [key: string]: string;
+};
+//# sourceMappingURL=qualityValues.d.ts.map

package/types/utils/qualityValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualityValues.d.ts","sourceRoot":"","sources":["../../utils/qualityValues.js"],"names":[],"mappings":"AAAA,yEAAyE;AAEzE;;;GAGG;AACH,0CAHW,MAAM,GACL,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CA2B3C;kCA/Ba;IAAC,CAAC,EAAC,MAAM,OAAC,CAAA;CAAC,GAAG;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,MAAM,CAAA;CAAC"}

package/types/utils/stream.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {import('node:stream').Writable|import('node:http').ServerResponse} writableLike
+ * @return {boolean}
+ */
+export function isWritable(writableLike: import("node:stream").Writable | import("node:http").ServerResponse): boolean;
+//# sourceMappingURL=stream.d.ts.map

package/types/utils/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../utils/stream.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,yCAHW,OAAO,aAAa,EAAE,QAAQ,GAAC,OAAO,WAAW,EAAE,cAAc,GAChE,OAAO,CAIlB"}

package/.eslintrc.json

@@ -1,96 +0,0 @@
-{
-  "env": {
-    "es2021": true
-  },
-  "extends": [
-    "airbnb-base",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:jsdoc/recommended-typescript-flavor-error",
-    "plugin:n/recommended",
-    "plugin:unicorn/recommended",
-    "plugin:import/recommended"
-  ],
-  "overrides": [
-    {
-      "files": [
-        "*.cjs"
-      ],
-      "rules": {
-        "@typescript-eslint/no-var-requires": 0,
-        "import/no-nodejs-modules": 0
-      }
-    }
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaFeatures": {
-      "impliedStrict": true
-    },
-    "ecmaVersion": 2019,
-    "project": "./jsconfig.json",
-    "sourceType": "module"
-  },
-  "plugins": [
-    "@typescript-eslint",
-    "canonical",
-    "jsdoc",
-    "n",
-    "unicorn",
-    "import"
-  ],
-  "root": true,
-  "rules": {
-    "import/extensions": [
-      "error",
-      "always",
-      {
-        "js": "always",
-        "mjs": "never"
-      }
-    ],
-    "import/no-extraneous-dependencies": "off",
-    "import/prefer-default-export": "off",
-    "jsdoc/no-defaults": "off",
-    "jsdoc/require-param-description": "off",
-    "jsdoc/require-property-description": "off",
-    "jsdoc/require-returns": "off",
-    "jsdoc/require-returns-description": "off",
-    "no-continue": "off",
-    "no-restricted-syntax": "off",
-    "no-return-await": "off",
-    "unicorn/explicit-length-check": "off",
-    "unicorn/filename-case": "off",
-    "unicorn/no-null": "off",
-    "unicorn/no-useless-switch-case": "off",
-    "unicorn/no-useless-undefined": "off",
-    "unicorn/prefer-ternary": [
-      "error",
-      "only-single-line"
-    ],
-    "unicorn/prevent-abbreviations": [
-      "error",
-      {
-        "checkFilenames": false
-      }
-    ],
-    "unicorn/switch-case-braces": "off",
-    "unicorn/text-encoding-identifier-case": "off"
-  },
-  "settings": {
-    "jsdoc": {
-      "preferredTypes": {
-        "array": "Array",
-        "object": "Object",
-        "object.": "Object<>",
-        "object<>": "Object<>",
-        "symbol": "Symbol"
-      },
-      "tagNamePreference": {
-        "augment": "extends",
-        "constant": "const",
-        "property": "prop",
-        "returns": "return"
-      }
-    }
-  }
-}

package/.github/FUNDING.yml

@@ -1,4 +0,0 @@
-# These are supported funding model platforms
-
-github: [clshortfuse]
-custom: ["https://www.paypal.me/clshortfuse"]

package/.github/copilot-instructions.md

@@ -1,100 +0,0 @@
-<!-- Auto-generated: guidance for AI coding assistants working on this repo -->
-# Copilot / AI assistant instructions for webhoster
-
-This file gives focused, actionable guidance to quickly become productive in this repository.
-
-Overview
-- **Purpose**: `webhoster` is a stream-first, middleware-driven HTTP/HTTP2 framework for Node.js. Core classes live in `lib/` (notably `lib/HttpHandler.js`, `lib/HttpRequest.js`, `lib/HttpResponse.js`). Middleware implementations live in `middleware/` and are composed into the `HttpHandler` middleware tree.
-- **Module type**: The project is ESM (`"type": "module"` in `package.json`) and targets Node >v16.13.
-
-Key patterns and conventions
-- **Middleware tree**: Middleware can be a function, a filter, an Iterable (e.g. `Set`), or a `Map`. Branching is represented by nested arrays/iterables. See examples in `README.md` and `middleware/` files.
-- **Return values**: Middleware return values drive control flow. Use the `HttpHandler` constants or their aliases:
-  - `HttpHandler.CONTINUE` (or `true`, `undefined`, `null`) — continue the branch
-  - `HttpHandler.BREAK` (or `false`) — break this branch, move to next
-  - `HttpHandler.END` (or `0`) — terminate the middleware tree
-  - `number` — treated as an HTTP status code and ends
-- **I/O model**: Requests expose `.read()`, `.stream`, and `.body` helpers. Responses expose `.stream`, `.end()`, `.send()`, `.pipeFrom()` and may call `.pushPath()` for HTTP/2 pushes. See `lib/HttpRequest.js` and `lib/HttpResponse.js`.
-- **Locals**: Per-request state belongs on `request.locals` (or `locals`) and is passed through middleware.
-
-Developer workflows
-- **Run tests**: `npm test` (uses `c8` + `ava` for coverage). Unit tests live under `test/` (pattern: `test/**/*.js`, excluding `test/fixtures/**`).
-- **Run full/test-all scripts**: `npm run testall` (async) or `npm run testallsync` (sync). These call the scripts in `scripts/`.
-- **Debug tests**: `npm run debug-test` which runs `ava --serial`.
-- **Coverage**: Coverage created by `c8`; `posttestall`/`posttestallsync` call `c8 report`.
-
-Code style & types
-- Project uses `eslint` (Airbnb base + plugins) in devDependencies — follow existing style. There are TypeScript type hints (`types/typings.d.ts`) but the codebase is JavaScript ESM.
-
-Where to change behavior
-- Add or alter middleware in `middleware/`. Prefer small, single-responsibility modules: decoding, encoding, header transforms, routing filters (see `PathMiddleware.js`, `MethodMiddleware.js`).
-- Core runtime behavior is in `lib/HttpHandler.js`. Changes here affect branching, error handling, and how middleware results are interpreted.
-
-Testing & examples
-- Example middleware composition is in `README.md` and `test/index.js` — use those as canonical examples when adding new middleware or behavior.
-- Write tests under `test/` and avoid touching `test/fixtures/` unless updating fixture data. Use `ava` and follow existing test styles.
-\
-Example: minimal middleware
-
-```js
-// middleware/ExampleMiddleware.js
-export default class ExampleMiddleware {
-  execute(transaction) {
-    transaction.locals = transaction.locals || {};
-    transaction.locals.example = (transaction.locals.example || 0) + 1;
-    return true; // continue processing
-  }
-}
-```
-
-Test example (AVA):
-
-```js
-import test from 'ava';
-import ExampleMiddleware from '../middleware/ExampleMiddleware.js';
-
-test('ExampleMiddleware increments locals', (t) => {
-  const m = new ExampleMiddleware();
-  const transaction = { locals: {}, state: { treeIndex: [] }, request: {}, response: {} };
-  m.execute(transaction);
-  t.is(transaction.locals.example, 1);
-});
-```
-
-I added `middleware/ExampleMiddleware.js` and `test/example-middleware.js` to the repo as a runnable template. Run `npm test` to verify the example.
-
-Integration points & runtime
-- Typical integration: a server registers handlers:
-  - `http1Server.addListener('request', HttpHandler.defaultInstance.handleHttp1Request)`
-  - `http2Server.addListener('stream', HttpHandler.defaultInstance.handleHttp2Stream)`
-- Middleware may push HTTP/2 resources using `response.pushPath()` — guard with `if (response.canPushPath)`.
-
-Practical tips for PRs and edits
-- Keep changes small and focused. Prefer adding middleware modules over modifying `HttpHandler` unless implementing a framework-level feature.
-- Preserve ESM syntax and `export`/`import` styles. Respect the project's `node` engine minimum.
-- Add or update `test/*.js` for any behavioral change; run `npm test` locally to confirm.
-
-Files to inspect when in doubt
-- `lib/HttpHandler.js`, `lib/HttpRequest.js`, `lib/HttpResponse.js`
-- `middleware/*` for existing middleware primitives
-- `test/index.js` and `test/**` for test patterns and usage examples
-- `scripts/test-all.sh` and `scripts/test-all-sync.sh` for CI/test orchestration
-
-CI / Workflows
-- `/.github/workflows/test-matrix.yml`: the recommended workflow. Runs `npm ci` + `npm run test` across a Node matrix (`16.13`, `16`, `18`, `20`, `22`) using `actions/setup-node`. Prefer editing this file when you want to change supported Node versions or add reporting steps (Codecov/Upload). Each matrix job uses the display name `Test on Node <version>`.
-- `/.github/workflows/test-with-nvm.yml`: optional workflow that installs `nvm` on the runner and executes `scripts/test-all.sh` to mirror local developer behavior. Keep this for parity/debugging only; the matrix job is preferred for CI.
-
-README badges
-- `README.md` contains per-node badges that point to the `test-matrix.yml` workflow and the job names. If you rename the workflow or change the job display name, update the badges in `README.md` accordingly. Badges point to the `master` branch by default.
-
-Local & debugging notes
-- Run tests locally (fast):
-  - `npm ci`
-  - `npm test` (runs `c8 ava`)
-- Run the full multi-version script locally (requires `nvm`):
-  - `chmod +x scripts/test-all.sh`
-  - `./scripts/test-all.sh`
-- The `scripts/test-all.sh` script runs `nvm install`/`nvm use` for multiple Node versions and then executes `npx c8 --clean false -r none ava` for each version in parallel. A recent fix corrected a typo so the Node 22 step now correctly runs `nvm use 22`.
-
-If you need more
-- If anything here is unclear or you'd like more examples (specific middleware templates, test scaffolds, or a debugging recipe), ask and I'll add them.