@versori/run 0.0.1-alpha.1 → 0.0.1-alpha.3

package/esm/deps/jsr.io/@oak/commons/1.0.0/form_data.js

@@ -0,0 +1,285 @@
+// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _MultipartStream_instances, _MultipartStream_buffer, _MultipartStream_boundaryFinal, _MultipartStream_boundaryPart, _MultipartStream_current, _MultipartStream_finalized, _MultipartStream_pos, _MultipartStream_readLine, _MultipartStream_readHeaders, _MultipartStream_readParts, _MultipartStream_readToBoundary, _MultipartStream_transform, _MultipartStream_truncate;
+/**
+ * The ability to parse a request body into {@linkcode FormData} when not
+ * supported natively by the runtime.
+ *
+ * @example
+ *
+ * ```ts
+ * import { parse } from "jsr:@oak/commons/form_data";
+ *
+ * const body = new Blob([someFormData]).stream();
+ * const contentType = "multipart/form-data; boundary=SOME_BOUNDARY";
+ *
+ * const formData = await parse(contentType, body);
+ * ```
+ *
+ * @module
+ */
+import { concat } from "../../../@std/bytes/1.0.5/concat.js";
+import { timingSafeEqual } from "../../../@std/crypto/1.0.4/timing_safe_equal.js";
+import { toParamRegExp, unquote } from "./header_utils.js";
+import { createHttpError } from "./http_errors.js";
+import { getFilename } from "./content_disposition.js";
+import { Status } from "./status.js";
+const BOUNDARY_PARAM_RE = toParamRegExp("boundary", "i");
+const NAME_PARAM_RE = toParamRegExp("name", "i");
+const LF = 0x0a;
+const CR = 0x0d;
+const COLON = 0x3a;
+const HTAB = 0x09;
+const SPACE = 0x20;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function indexOfCRLF(u8) {
+    let start = 0;
+    while (true) {
+        const idx = u8.indexOf(CR, start);
+        if (idx < 0) {
+            return idx;
+        }
+        if (u8.at(idx + 1) === LF) {
+            return idx + 1;
+        }
+        start = idx + 1;
+    }
+}
+/** Returns `u8` with leading white space removed. */
+function skipLWSPChar(u8) {
+    const result = new Uint8Array(u8.length);
+    let j = 0;
+    for (let i = 0; i < u8.length; i++) {
+        if (u8[i] === SPACE || u8[i] === HTAB)
+            continue;
+        result[j++] = u8[i];
+    }
+    return result.slice(0, j);
+}
+function stripEol(value) {
+    if (value[value.byteLength - 1] == LF) {
+        let drop = 1;
+        if (value.byteLength > 1 && value[value.byteLength - 2] === CR) {
+            drop = 2;
+        }
+        return value.subarray(0, value.byteLength - drop);
+    }
+    return value;
+}
+function isEqual(a, b) {
+    return timingSafeEqual(skipLWSPChar(a), b);
+}
+class MultipartStream extends TransformStream {
+    constructor(contentType) {
+        const matches = contentType.match(BOUNDARY_PARAM_RE);
+        if (!matches) {
+            throw createHttpError(Status.BadRequest, `Content type "${contentType}" does not contain a valid boundary.`);
+        }
+        super({
+            transform: (chunk, controller) => {
+                __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_transform).call(this, chunk, controller);
+            },
+            flush: (controller) => {
+                if (!__classPrivateFieldGet(this, _MultipartStream_finalized, "f")) {
+                    controller.error(createHttpError(Status.BadRequest, `Body terminated without being finalized.`));
+                }
+            },
+        });
+        _MultipartStream_instances.add(this);
+        _MultipartStream_buffer.set(this, new Uint8Array(0));
+        _MultipartStream_boundaryFinal.set(this, void 0);
+        _MultipartStream_boundaryPart.set(this, void 0);
+        _MultipartStream_current.set(this, void 0);
+        _MultipartStream_finalized.set(this, false);
+        _MultipartStream_pos.set(this, 0);
+        let [, boundary] = matches;
+        boundary = unquote(boundary);
+        __classPrivateFieldSet(this, _MultipartStream_boundaryPart, encoder.encode(`--${boundary}`), "f");
+        __classPrivateFieldSet(this, _MultipartStream_boundaryFinal, encoder.encode(`--${boundary}--`), "f");
+    }
+}
+_MultipartStream_buffer = new WeakMap(), _MultipartStream_boundaryFinal = new WeakMap(), _MultipartStream_boundaryPart = new WeakMap(), _MultipartStream_current = new WeakMap(), _MultipartStream_finalized = new WeakMap(), _MultipartStream_pos = new WeakMap(), _MultipartStream_instances = new WeakSet(), _MultipartStream_readLine = function _MultipartStream_readLine(strip = true) {
+    let slice = null;
+    const i = indexOfCRLF(__classPrivateFieldGet(this, _MultipartStream_buffer, "f").subarray(__classPrivateFieldGet(this, _MultipartStream_pos, "f")));
+    if (i >= 0) {
+        slice = __classPrivateFieldGet(this, _MultipartStream_buffer, "f").subarray(__classPrivateFieldGet(this, _MultipartStream_pos, "f"), __classPrivateFieldGet(this, _MultipartStream_pos, "f") + i + 1);
+        __classPrivateFieldSet(this, _MultipartStream_pos, __classPrivateFieldGet(this, _MultipartStream_pos, "f") + (i + 1), "f");
+        if (slice.byteLength && strip) {
+            return stripEol(slice);
+        }
+        return slice;
+    }
+    return null;
+}, _MultipartStream_readHeaders = function _MultipartStream_readHeaders() {
+    const currentPos = __classPrivateFieldGet(this, _MultipartStream_pos, "f");
+    const headers = new Headers();
+    let line = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readLine).call(this);
+    while (line) {
+        let i = line.indexOf(COLON);
+        if (i < 0) {
+            return headers;
+        }
+        const key = decoder.decode(line.subarray(0, i)).trim();
+        i++;
+        while (i < line.byteLength && (line[i] === SPACE || line[i] === HTAB)) {
+            i++;
+        }
+        const value = decoder.decode(line.subarray(i)).trim();
+        headers.set(key, encodeURIComponent(value));
+        line = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readLine).call(this);
+    }
+    // if we have a partial part that breaks across chunks, we won't have the
+    // right read position and so need to reset the pos and return a `null`.
+    __classPrivateFieldSet(this, _MultipartStream_pos, currentPos, "f");
+    return null;
+}, _MultipartStream_readParts = function* _MultipartStream_readParts() {
+    while (true) {
+        const headers = __classPrivateFieldGet(this, _MultipartStream_current, "f")?.headers ?? __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readHeaders).call(this);
+        if (!headers) {
+            break;
+        }
+        const contentDisposition = decodeURIComponent(headers.get("content-disposition") ?? "");
+        if (!contentDisposition) {
+            throw createHttpError(Status.BadRequest, 'Form data part missing "content-disposition" header.');
+        }
+        if (!contentDisposition.match(/^form-data;/i)) {
+            throw createHttpError(Status.BadRequest, `Invalid "content-disposition" header: "${contentDisposition}"`);
+        }
+        const matches = NAME_PARAM_RE.exec(contentDisposition);
+        if (!matches) {
+            throw createHttpError(Status.BadRequest, "Unable to determine name of form body part.");
+        }
+        __classPrivateFieldSet(this, _MultipartStream_current, { headers }, "f");
+        let [, key] = matches;
+        key = unquote(key);
+        const rawContentType = headers.get("content-type");
+        if (rawContentType) {
+            const contentType = decodeURIComponent(rawContentType);
+            const fileName = getFilename(contentDisposition);
+            const arrays = [];
+            const pos = __classPrivateFieldGet(this, _MultipartStream_pos, "f");
+            while (true) {
+                const line = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readLine).call(this, false);
+                if (!line) {
+                    // abnormal termination of part, therefore we will reset pos and
+                    // return
+                    __classPrivateFieldSet(this, _MultipartStream_pos, pos, "f");
+                    return null;
+                }
+                const stripped = stripEol(line);
+                if (isEqual(stripped, __classPrivateFieldGet(this, _MultipartStream_boundaryPart, "f")) ||
+                    isEqual(stripped, __classPrivateFieldGet(this, _MultipartStream_boundaryFinal, "f"))) {
+                    __classPrivateFieldSet(this, _MultipartStream_current, {}, "f");
+                    arrays[arrays.length - 1] = stripEol(arrays[arrays.length - 1]);
+                    yield [key, new Blob(arrays, { type: contentType }), fileName];
+                    __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_truncate).call(this);
+                    if (isEqual(stripped, __classPrivateFieldGet(this, _MultipartStream_boundaryFinal, "f"))) {
+                        __classPrivateFieldSet(this, _MultipartStream_finalized, true, "f");
+                        return null;
+                    }
+                    break;
+                }
+                arrays.push(line);
+            }
+        }
+        else {
+            const lines = [];
+            const pos = __classPrivateFieldGet(this, _MultipartStream_pos, "f");
+            while (true) {
+                const line = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readLine).call(this);
+                if (!line) {
+                    __classPrivateFieldSet(this, _MultipartStream_pos, pos, "f");
+                    return null;
+                }
+                if (isEqual(line, __classPrivateFieldGet(this, _MultipartStream_boundaryPart, "f")) ||
+                    isEqual(line, __classPrivateFieldGet(this, _MultipartStream_boundaryFinal, "f"))) {
+                    __classPrivateFieldSet(this, _MultipartStream_current, {}, "f");
+                    yield [key, lines.join("\n"), undefined];
+                    __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_truncate).call(this);
+                    if (isEqual(line, __classPrivateFieldGet(this, _MultipartStream_boundaryFinal, "f"))) {
+                        __classPrivateFieldSet(this, _MultipartStream_finalized, true, "f");
+                        return null;
+                    }
+                    break;
+                }
+                lines.push(decoder.decode(line));
+            }
+        }
+    }
+    return null;
+}, _MultipartStream_readToBoundary = function _MultipartStream_readToBoundary() {
+    let line;
+    while ((line = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readLine).call(this))) {
+        if (isEqual(line, __classPrivateFieldGet(this, _MultipartStream_boundaryPart, "f"))) {
+            return "part";
+        }
+        if (isEqual(line, __classPrivateFieldGet(this, _MultipartStream_boundaryFinal, "f"))) {
+            return "final";
+        }
+    }
+    return null;
+}, _MultipartStream_transform = function _MultipartStream_transform(chunk, controller) {
+    __classPrivateFieldSet(this, _MultipartStream_buffer, concat([__classPrivateFieldGet(this, _MultipartStream_buffer, "f"), chunk]), "f");
+    if (!__classPrivateFieldGet(this, _MultipartStream_current, "f")) {
+        const boundary = __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readToBoundary).call(this);
+        if (!boundary) {
+            return;
+        }
+        if (boundary === "final") {
+            __classPrivateFieldSet(this, _MultipartStream_finalized, true, "f");
+            controller.terminate();
+            return;
+        }
+    }
+    try {
+        for (const part of __classPrivateFieldGet(this, _MultipartStream_instances, "m", _MultipartStream_readParts).call(this)) {
+            if (!part) {
+                break;
+            }
+            controller.enqueue(part);
+        }
+        if (__classPrivateFieldGet(this, _MultipartStream_finalized, "f")) {
+            controller.terminate();
+        }
+    }
+    catch (err) {
+        controller.error(err);
+    }
+}, _MultipartStream_truncate = function _MultipartStream_truncate() {
+    __classPrivateFieldSet(this, _MultipartStream_buffer, __classPrivateFieldGet(this, _MultipartStream_buffer, "f").slice(__classPrivateFieldGet(this, _MultipartStream_pos, "f")), "f");
+    __classPrivateFieldSet(this, _MultipartStream_pos, 0, "f");
+};
+/**
+ * Take a content type and the body of a request and parse it as
+ * {@linkcode FormData}.
+ *
+ * This is used can be used in run-times where there isn't native support for
+ * this feature.
+ */
+export async function parse(contentType, body) {
+    const formData = new FormData();
+    if (body) {
+        const stream = body
+            .pipeThrough(new MultipartStream(contentType));
+        for await (const [key, value, fileName] of stream) {
+            if (fileName) {
+                formData.append(key, value, fileName);
+            }
+            else {
+                formData.append(key, value);
+            }
+        }
+    }
+    return formData;
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/forwarded.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Adapted directly from forwarded-parse at https://github.com/lpinca/forwarded-parse
+ * which is licensed as follows:
+ *
+ * Copyright(c) 2015 Luigi Pinca
+ * Copyright(c) 2023 the oak authors
+ * MIT Licensed
+ */
+/**
+ * Parse the `Forwarded` header field value into an array of objects. If the
+ * value is not parsable, `undefined` is returned.
+ *
+ * @param value The header field value.
+ */
+export declare function parse(value: string): Record<string, string>[] | undefined;
+//# sourceMappingURL=forwarded.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/forwarded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwarded.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/forwarded.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA+EH;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,SAAS,CA4HzE"}

package/esm/deps/jsr.io/@oak/commons/1.0.0/forwarded.js

@@ -0,0 +1,208 @@
+/*!
+ * Adapted directly from forwarded-parse at https://github.com/lpinca/forwarded-parse
+ * which is licensed as follows:
+ *
+ * Copyright(c) 2015 Luigi Pinca
+ * Copyright(c) 2023 the oak authors
+ * MIT Licensed
+ */
+/**
+ * Provides utilities for parsing and validating the `Forwarded` header.
+ *
+ * @module
+ */
+import { assert } from "../../../@std/assert/1.0.11/assert.js";
+/**
+ * Unescape a string.
+ *
+ * @param str The string to unescape.
+ * @returns A new unescaped string.
+ */
+function decode(value) {
+    return value.replace(/\\(.)/g, "$1");
+}
+/**
+ * Check if a character is a delimiter as defined in section 3.2.6 of RFC 7230.
+ *
+ * @param code The code of the character to check.
+ * @returns `true` if the character is a delimiter, else `false`.
+ */
+function isDelimiter(code) {
+    return code === 0x22 || // '"'
+        code === 0x28 || // '('
+        code === 0x29 || // ')'
+        code === 0x2C || // ','
+        code === 0x2F || // '/'
+        code >= 0x3A && code <= 0x40 || // ':', ';', '<', '=', '>', '?' '@'
+        code >= 0x5B && code <= 0x5D || // '[', '\', ']'
+        code === 0x7B || // '{'
+        code === 0x7D; // '}'
+}
+/**
+ * Check if a character is an extended ASCII character.
+ *
+ * @param code The code of the character to check.
+ * @returns `true` if `code` is in the %x80-FF range, else `false`.
+ */
+function isExtended(code) {
+    return code >= 0x80 && code <= 0xFF;
+}
+/**
+ * Check if a character is a printable ASCII character.
+ *
+ * @param code The code of the character to check.
+ * @returns `true` if `code` is in the %x20-7E range, else `false`.
+ */
+function isPrint(code) {
+    return code >= 0x20 && code <= 0x7E;
+}
+/**
+ * Check if a character is allowed in a token as defined in section 3.2.6
+ * of RFC 7230.
+ *
+ * @param code The code of the character to check.
+ * @returns `true` if the character is allowed, else `false`.
+ */
+function isTokenChar(code) {
+    return code === 0x21 || // '!'
+        code >= 0x23 && code <= 0x27 || // '#', '$', '%', '&', '''
+        code === 0x2A || // '*'
+        code === 0x2B || // '+'
+        code === 0x2D || // '-'
+        code === 0x2E || // '.'
+        code >= 0x30 && code <= 0x39 || // 0-9
+        code >= 0x41 && code <= 0x5A || // A-Z
+        code >= 0x5E && code <= 0x7A || // '^', '_', '`', a-z
+        code === 0x7C || // '|'
+        code === 0x7E; // '~'
+}
+/**
+ * Parse the `Forwarded` header field value into an array of objects. If the
+ * value is not parsable, `undefined` is returned.
+ *
+ * @param value The header field value.
+ */
+export function parse(value) {
+    let parameter;
+    let start = -1;
+    let end = -1;
+    let isEscaping = false;
+    let inQuotes = false;
+    let mustUnescape = false;
+    let code;
+    let forwarded = {};
+    const output = [];
+    let i;
+    for (i = 0; i < value.length; i++) {
+        code = value.charCodeAt(i);
+        if (parameter === undefined) {
+            if (i !== 0 && start === -1 && (code === 0x20 || code === 0x09)) {
+                continue;
+            }
+            if (isTokenChar(code)) {
+                if (start === -1) {
+                    start = i;
+                }
+            }
+            else if (code === 0x3D && start !== -1) {
+                parameter = value.slice(start, i).toLowerCase();
+                start = -1;
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            if (isEscaping && (code === 0x09 || isPrint(code) || isExtended(code))) {
+                isEscaping = false;
+            }
+            else if (isTokenChar(code)) {
+                if (end !== -1) {
+                    return undefined;
+                }
+                if (start === -1) {
+                    start = i;
+                }
+            }
+            else if (isDelimiter(code) || isExtended(code)) {
+                if (inQuotes) {
+                    if (code === 0x22) {
+                        inQuotes = false;
+                        end = i;
+                    }
+                    else if (code === 0x5C) {
+                        if (start === -1) {
+                            start = i;
+                        }
+                        isEscaping = mustUnescape = true;
+                    }
+                    else if (start === -1) {
+                        start = i;
+                    }
+                }
+                else if (code === 0x22 && value.charCodeAt(i - 1) === 0x3D) {
+                    inQuotes = true;
+                }
+                else if ((code === 0x2C || code === 0x3B) && (start !== -1 || end !== -1)) {
+                    assert(parameter, "Variable 'parameter' not defined.");
+                    if (start !== -1) {
+                        if (end === -1) {
+                            end = i;
+                        }
+                        forwarded[parameter] = mustUnescape
+                            ? decode(value.slice(start, end))
+                            : value.slice(start, end);
+                    }
+                    else {
+                        forwarded[parameter] = "";
+                    }
+                    if (code === 0x2C) {
+                        output.push(forwarded);
+                        forwarded = {};
+                    }
+                    parameter = undefined;
+                    start = end = -1;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else if (code === 0x20 || code === 0x09) {
+                if (end !== -1) {
+                    continue;
+                }
+                if (inQuotes) {
+                    if (start === -1) {
+                        start = i;
+                    }
+                }
+                else if (start !== -1) {
+                    end = i;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            else {
+                return undefined;
+            }
+        }
+    }
+    if (parameter === undefined || inQuotes || (start === -1 && end === -1) ||
+        code === 0x20 || code === 0x09) {
+        return undefined;
+    }
+    if (start !== -1) {
+        if (end === -1) {
+            end = i;
+        }
+        forwarded[parameter] = mustUnescape
+            ? decode(value.slice(start, end))
+            : value.slice(start, end);
+    }
+    else {
+        forwarded[parameter] = "";
+    }
+    output.push(forwarded);
+    return output;
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/header_utils.d.ts

@@ -0,0 +1,6 @@
+/** With a provided attribute pattern, return a RegExp which will match and
+ * capture in the first group the value of the attribute from a header value. */
+export declare function toParamRegExp(attributePattern: string, flags?: string): RegExp;
+/** Unquotes attribute values that might be pass as part of a header. */
+export declare function unquote(value: string): string;
+//# sourceMappingURL=header_utils.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/header_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header_utils.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/header_utils.ts"],"names":[],"mappings":"AAEA;gFACgF;AAChF,wBAAgB,aAAa,CAC3B,gBAAgB,EAAE,MAAM,EACxB,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CAWR;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAc7C"}

package/esm/deps/jsr.io/@oak/commons/1.0.0/header_utils.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
+/** With a provided attribute pattern, return a RegExp which will match and
+ * capture in the first group the value of the attribute from a header value. */
+export function toParamRegExp(attributePattern, flags) {
+    // deno-fmt-ignore
+    return new RegExp(`(?:^|;)\\s*${attributePattern}\\s*=\\s*` +
+        `(` +
+        `[^";\\s][^;\\s]*` +
+        `|` +
+        `"(?:[^"\\\\]|\\\\"?)+"?` +
+        `)`, flags);
+}
+/** Unquotes attribute values that might be pass as part of a header. */
+export function unquote(value) {
+    if (value.startsWith(`"`)) {
+        const parts = value.slice(1).split(`\\"`);
+        for (let i = 0; i < parts.length; ++i) {
+            const quoteIndex = parts[i].indexOf(`"`);
+            if (quoteIndex !== -1) {
+                parts[i] = parts[i].slice(0, quoteIndex);
+                parts.length = i + 1; // Truncates and stops the loop
+            }
+            parts[i] = parts[i].replace(/\\(.)/g, "$1");
+        }
+        value = parts.join(`"`);
+    }
+    return value;
+}

package/esm/deps/jsr.io/@oak/commons/1.0.0/http_errors.d.ts

@@ -0,0 +1,123 @@
+import { type ErrorStatus, Status } from "./status.js";
+declare const ERROR_STATUS_MAP: {
+    readonly BadRequest: 400;
+    readonly Unauthorized: 401;
+    readonly PaymentRequired: 402;
+    readonly Forbidden: 403;
+    readonly NotFound: 404;
+    readonly MethodNotAllowed: 405;
+    readonly NotAcceptable: 406;
+    readonly ProxyAuthRequired: 407;
+    readonly RequestTimeout: 408;
+    readonly Conflict: 409;
+    readonly Gone: 410;
+    readonly LengthRequired: 411;
+    readonly PreconditionFailed: 412;
+    readonly RequestEntityTooLarge: 413;
+    readonly RequestURITooLong: 414;
+    readonly UnsupportedMediaType: 415;
+    readonly RequestedRangeNotSatisfiable: 416;
+    readonly ExpectationFailed: 417;
+    readonly Teapot: 418;
+    readonly MisdirectedRequest: 421;
+    readonly UnprocessableEntity: 422;
+    readonly Locked: 423;
+    readonly FailedDependency: 424;
+    readonly UpgradeRequired: 426;
+    readonly PreconditionRequired: 428;
+    readonly TooManyRequests: 429;
+    readonly RequestHeaderFieldsTooLarge: 431;
+    readonly UnavailableForLegalReasons: 451;
+    readonly InternalServerError: 500;
+    readonly NotImplemented: 501;
+    readonly BadGateway: 502;
+    readonly ServiceUnavailable: 503;
+    readonly GatewayTimeout: 504;
+    readonly HTTPVersionNotSupported: 505;
+    readonly VariantAlsoNegotiates: 506;
+    readonly InsufficientStorage: 507;
+    readonly LoopDetected: 508;
+    readonly NotExtended: 510;
+    readonly NetworkAuthenticationRequired: 511;
+};
+/**
+ * A type alias which is a set of all the string literal names of the error
+ * status codes.
+ */
+export type ErrorStatusKeys = keyof typeof ERROR_STATUS_MAP;
+/**
+ * Options which can be set when initializing an {@linkcode HttpError}
+ */
+export interface HttpErrorOptions extends ErrorOptions {
+    /** Determine if the underlying error stack should be exposed to a client. */
+    expose?: boolean;
+}
+export interface AsResponseOptions {
+    /**
+     * Any additional headers that should be included when creating the
+     * response.
+     */
+    headers?: HeadersInit;
+    /**
+     * When determining what format to respond in, prefer either a JSON or HTML
+     * response. If a request is provided, the accept header will be used to
+     * determine the final response content type.
+     *
+     * Defaults to `"json"`.
+     */
+    prefer?: "json" | "html";
+    /**
+     * An optional {@linkcode Request}, which will be used to determine what
+     * type of response the request can accept.
+     */
+    request?: Request;
+}
+/**
+ * The base class that all derivative HTTP extend, providing a `status` and an
+ * `expose` property.
+ */
+export declare class HttpError<S extends ErrorStatus = Status.InternalServerError> extends Error {
+    #private;
+    constructor(message?: string, options?: HttpErrorOptions);
+    /** A flag to indicate if the internals of the error, like the stack, should
+     * be exposed to a client, or if they are "private" and should not be leaked.
+     * By default, all client errors are `true` and all server errors are
+     * `false`. */
+    get expose(): boolean;
+    /** The error status that is set on the error. */
+    get status(): S;
+    /**
+     * Format the error as a {@linkcode Response} which can be sent to a client.
+     */
+    asResponse(options?: AsResponseOptions): Response;
+}
+/**
+ * A namespace that contains each error constructor. Each error extends
+ * `HTTPError` and provides `.status` and `.expose` properties, where the
+ * `.status` will be an error `Status` value and `.expose` indicates if
+ * information, like a stack trace, should be shared in the response.
+ *
+ * By default, `.expose` is set to false in server errors, and true for client
+ * errors.
+ *
+ * @example
+ * ```ts
+ * import { errors } from "jsr:@oak/commons/http_errors";
+ *
+ * throw new errors.InternalServerError("Ooops!");
+ * ```
+ */
+export declare const errors: Record<ErrorStatusKeys, typeof HttpError<ErrorStatus>>;
+/**
+ * A factory function which provides a way to create errors. It takes up to 3
+ * arguments, the error `Status`, an message, which defaults to the status text
+ * and error options, which includes the `expose` property to set the `.expose`
+ * value on the error.
+ */
+export declare function createHttpError<S extends ErrorStatus = Status.InternalServerError>(status?: S, message?: string, options?: HttpErrorOptions): HttpError<S>;
+/**
+ * A type guard that determines if the value is an HttpError or not.
+ */
+export declare function isHttpError(value: unknown): value is HttpError<ErrorStatus>;
+export {};
+//# sourceMappingURL=http_errors.d.ts.map

package/esm/deps/jsr.io/@oak/commons/1.0.0/http_errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http_errors.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/http_errors.ts"],"names":[],"mappings":"AAmDA,OAAO,EACL,KAAK,WAAW,EAEhB,MAAM,EAEP,MAAM,aAAa,CAAC;AAErB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCZ,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,gBAAgB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,MAAM,CAAC,mBAAmB,CACvE,SAAQ,KAAK;;gBAGX,OAAO,SAAe,EACtB,OAAO,CAAC,EAAE,gBAAgB;IAQ5B;;;kBAGc;IACd,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,iDAAiD;IACjD,IAAI,MAAM,IAAI,CAAC,CAEd;IAED;;OAEG;IACH,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,QAAQ;CA4DtD;AA2BD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,SAAS,CAAC,WAAW,CAAC,CAIvE,CAAC;AAMJ;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,WAAW,GAAG,MAAM,CAAC,mBAAmB,EAElD,MAAM,GAAE,CAAmC,EAC3C,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,gBAAgB,GACzB,SAAS,CAAC,CAAC,CAAC,CAKd;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC,WAAW,CAAC,CAE3E"}