webhoster 0.3.4 → 0.3.6

package/types/middleware/ContentEncoderMiddleware.d.ts

@@ -0,0 +1,48 @@
+export default class ContentEncoderMiddleware {
+    static BrotliCompressAsync: typeof brotliCompress.__promisify__;
+    static GzipAsync: typeof gzip.__promisify__;
+    static DeflateAsync: typeof deflate.__promisify__;
+    /**
+     * @param {IncomingHttpHeaders} headers
+     * @throws {NotAcceptableException} Error with `NOT_ACCEPTIBLE` message
+     * @return {COMPATIBLE_ENCODING}
+     */
+    static chooseEncoding(headers: IncomingHttpHeaders): COMPATIBLE_ENCODING;
+    /** @param {ContentEncoderMiddlewareOptions} [options] */
+    constructor(options?: ContentEncoderMiddlewareOptions);
+    chunkSize: number;
+    respondNotAcceptable: boolean;
+    preferredEncoding: "deflate" | "gzip" | "br" | "identity";
+    minimumSize: number;
+    asyncThreshold: number;
+    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 IncomingHttpHeaders = import("http").IncomingHttpHeaders;
+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 COMPATIBLE_ENCODING = "br" | "gzip" | "deflate" | "identity" | "*";
+export type ContentEncoderMiddlewareOptions = {
+    chunkSize?: number;
+    respondNotAcceptable?: boolean;
+    /**
+     * Minimum content size before using any compression
+     */
+    preferredEncoding?: "br" | "gzip" | "deflate" | "identity";
+    /**
+     * Minimum content size before using async compression
+     */
+    minimumSize?: number;
+    asyncThreshold?: number;
+};
+import { brotliCompress } from 'node:zlib';
+import { gzip } from 'node:zlib';
+import { deflate } from 'node:zlib';
+//# sourceMappingURL=ContentEncoderMiddleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentEncoderMiddleware.d.ts","sourceRoot":"","sources":["../../middleware/ContentEncoderMiddleware.js"],"names":[],"mappings":"AAwCA;IACE,gEAAuD;IAEvD,4CAAmC;IAEnC,kDAAyC;IAEzC;;;;OAIG;IACH,+BAJW,mBAAmB,GAElB,mBAAmB,CA8C9B;IAED,yDAAyD;IACzD,sBADY,+BAA+B,EAQ1C;IANC,kBAAkC;IAClC,8BAAiE;IACjE,0DAAgE;IAChE,oBAA8D;IAC9D,uBAAuE;;IAIzE;;;OAGG;IACH,6BAHW,YAAY,GACX,IAAI,CA4Ef;;CAwGF;kCApRa,OAAO,MAAM,EAAE,mBAAmB;0BAClC,OAAO,uBAAuB,EAAE,OAAO;2BACvC,OAAO,wBAAwB,EAAE,OAAO;iCACxC,OAAO,yBAAyB,EAAE,kBAAkB;gCACpD,OAAO,yBAAyB,EAAE,iBAAiB;kCAEnD,IAAI,GAAC,MAAM,GAAC,SAAS,GAAC,UAAU,GAAC,GAAG;;gBAQxC,MAAM;2BACN,OAAO;;;;wBACP,IAAI,GAAC,MAAM,GAAC,SAAS,GAAC,UAAU;;;;kBAEhC,MAAM;qBAEN,MAAM;;+BA1BT,WAAW;qBAAX,WAAW;wBAAX,WAAW"}

package/types/middleware/ContentLengthMiddleware.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @typedef {Object} ContentLengthMiddlewareOptions
+ * @prop {number} [delayCycles=2]
+ * Delays writing to stream by setTimeout cycles when piping.
+ * If `.end()` is called on the same event loop as write, then the
+ * content length can be still calculated despite receiving data in chunks.
+ * @prop {boolean} [overrideHeader=false]
+ * Always replace `Content-Length` header
+ */
+export default class ContentLengthMiddleware {
+    /** @param {ContentLengthMiddlewareOptions} [options] */
+    constructor(options?: ContentLengthMiddlewareOptions);
+    delayCycles: number;
+    overrideHeader: 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 MiddlewareFunction = import("../data/custom-types.js").MiddlewareFunction;
+export type ResponseFinalizer = import("../data/custom-types.js").ResponseFinalizer;
+export type ContentLengthMiddlewareOptions = {
+    /**
+     * Delays writing to stream by setTimeout cycles when piping.
+     * If `.end()` is called on the same event loop as write, then the
+     * content length can be still calculated despite receiving data in chunks.
+     */
+    delayCycles?: number;
+    /**
+     * Always replace `Content-Length` header
+     */
+    overrideHeader?: boolean;
+};
+//# sourceMappingURL=ContentLengthMiddleware.d.ts.map

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"]