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

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

@@ -0,0 +1,386 @@
+// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
+/**
+ * Contains the {@linkcode STATUS_CODE} object which contains standard HTTP
+ * status codes and provides several type guards for handling status codes
+ * with type safety.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   STATUS_CODE,
+ *   STATUS_TEXT,
+ * } from "jsr:@oak/commons/status";
+ *
+ * console.log(STATUS_CODE.NotFound); // Returns 404
+ * console.log(STATUS_TEXT[STATUS_CODE.NotFound]); // Returns "Not Found"
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { isErrorStatus } from "jsr:@oak/commons/status";
+ *
+ * const res = await fetch("https://example.com/");
+ *
+ * if (isErrorStatus(res.status)) {
+ *   // error handling here...
+ * }
+ * ```
+ *
+ * @module
+ */
+/**
+ * Standard HTTP status codes.
+ */
+export var Status;
+(function (Status) {
+    /** RFC 7231, 6.2.1 */
+    Status[Status["Continue"] = 100] = "Continue";
+    /** RFC 7231, 6.2.2 */
+    Status[Status["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    /** RFC 2518, 10.1 */
+    Status[Status["Processing"] = 102] = "Processing";
+    /** RFC 8297 **/
+    Status[Status["EarlyHints"] = 103] = "EarlyHints";
+    /** RFC 7231, 6.3.1 */
+    Status[Status["OK"] = 200] = "OK";
+    /** RFC 7231, 6.3.2 */
+    Status[Status["Created"] = 201] = "Created";
+    /** RFC 7231, 6.3.3 */
+    Status[Status["Accepted"] = 202] = "Accepted";
+    /** RFC 7231, 6.3.4 */
+    Status[Status["NonAuthoritativeInfo"] = 203] = "NonAuthoritativeInfo";
+    /** RFC 7231, 6.3.5 */
+    Status[Status["NoContent"] = 204] = "NoContent";
+    /** RFC 7231, 6.3.6 */
+    Status[Status["ResetContent"] = 205] = "ResetContent";
+    /** RFC 7233, 4.1 */
+    Status[Status["PartialContent"] = 206] = "PartialContent";
+    /** RFC 4918, 11.1 */
+    Status[Status["MultiStatus"] = 207] = "MultiStatus";
+    /** RFC 5842, 7.1 */
+    Status[Status["AlreadyReported"] = 208] = "AlreadyReported";
+    /** RFC 3229, 10.4.1 */
+    Status[Status["IMUsed"] = 226] = "IMUsed";
+    /** RFC 7231, 6.4.1 */
+    Status[Status["MultipleChoices"] = 300] = "MultipleChoices";
+    /** RFC 7231, 6.4.2 */
+    Status[Status["MovedPermanently"] = 301] = "MovedPermanently";
+    /** RFC 7231, 6.4.3 */
+    Status[Status["Found"] = 302] = "Found";
+    /** RFC 7231, 6.4.4 */
+    Status[Status["SeeOther"] = 303] = "SeeOther";
+    /** RFC 7232, 4.1 */
+    Status[Status["NotModified"] = 304] = "NotModified";
+    /** RFC 7231, 6.4.5 */
+    Status[Status["UseProxy"] = 305] = "UseProxy";
+    /** RFC 7231, 6.4.7 */
+    Status[Status["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    /** RFC 7538, 3 */
+    Status[Status["PermanentRedirect"] = 308] = "PermanentRedirect";
+    /** RFC 7231, 6.5.1 */
+    Status[Status["BadRequest"] = 400] = "BadRequest";
+    /** RFC 7235, 3.1 */
+    Status[Status["Unauthorized"] = 401] = "Unauthorized";
+    /** RFC 7231, 6.5.2 */
+    Status[Status["PaymentRequired"] = 402] = "PaymentRequired";
+    /** RFC 7231, 6.5.3 */
+    Status[Status["Forbidden"] = 403] = "Forbidden";
+    /** RFC 7231, 6.5.4 */
+    Status[Status["NotFound"] = 404] = "NotFound";
+    /** RFC 7231, 6.5.5 */
+    Status[Status["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    /** RFC 7231, 6.5.6 */
+    Status[Status["NotAcceptable"] = 406] = "NotAcceptable";
+    /** RFC 7235, 3.2 */
+    Status[Status["ProxyAuthRequired"] = 407] = "ProxyAuthRequired";
+    /** RFC 7231, 6.5.7 */
+    Status[Status["RequestTimeout"] = 408] = "RequestTimeout";
+    /** RFC 7231, 6.5.8 */
+    Status[Status["Conflict"] = 409] = "Conflict";
+    /** RFC 7231, 6.5.9 */
+    Status[Status["Gone"] = 410] = "Gone";
+    /** RFC 7231, 6.5.10 */
+    Status[Status["LengthRequired"] = 411] = "LengthRequired";
+    /** RFC 7232, 4.2 */
+    Status[Status["PreconditionFailed"] = 412] = "PreconditionFailed";
+    /** RFC 7231, 6.5.11 */
+    Status[Status["RequestEntityTooLarge"] = 413] = "RequestEntityTooLarge";
+    /** RFC 7231, 6.5.12 */
+    Status[Status["RequestURITooLong"] = 414] = "RequestURITooLong";
+    /** RFC 7231, 6.5.13 */
+    Status[Status["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    /** RFC 7233, 4.4 */
+    Status[Status["RequestedRangeNotSatisfiable"] = 416] = "RequestedRangeNotSatisfiable";
+    /** RFC 7231, 6.5.14 */
+    Status[Status["ExpectationFailed"] = 417] = "ExpectationFailed";
+    /** RFC 7168, 2.3.3 */
+    Status[Status["Teapot"] = 418] = "Teapot";
+    /** RFC 7540, 9.1.2 */
+    Status[Status["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    /** RFC 4918, 11.2 */
+    Status[Status["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    /** RFC 4918, 11.3 */
+    Status[Status["Locked"] = 423] = "Locked";
+    /** RFC 4918, 11.4 */
+    Status[Status["FailedDependency"] = 424] = "FailedDependency";
+    /** RFC 8470, 5.2 */
+    Status[Status["TooEarly"] = 425] = "TooEarly";
+    /** RFC 7231, 6.5.15 */
+    Status[Status["UpgradeRequired"] = 426] = "UpgradeRequired";
+    /** RFC 6585, 3 */
+    Status[Status["PreconditionRequired"] = 428] = "PreconditionRequired";
+    /** RFC 6585, 4 */
+    Status[Status["TooManyRequests"] = 429] = "TooManyRequests";
+    /** RFC 6585, 5 */
+    Status[Status["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    /** RFC 7725, 3 */
+    Status[Status["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    /** RFC 7231, 6.6.1 */
+    Status[Status["InternalServerError"] = 500] = "InternalServerError";
+    /** RFC 7231, 6.6.2 */
+    Status[Status["NotImplemented"] = 501] = "NotImplemented";
+    /** RFC 7231, 6.6.3 */
+    Status[Status["BadGateway"] = 502] = "BadGateway";
+    /** RFC 7231, 6.6.4 */
+    Status[Status["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    /** RFC 7231, 6.6.5 */
+    Status[Status["GatewayTimeout"] = 504] = "GatewayTimeout";
+    /** RFC 7231, 6.6.6 */
+    Status[Status["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    /** RFC 2295, 8.1 */
+    Status[Status["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    /** RFC 4918, 11.5 */
+    Status[Status["InsufficientStorage"] = 507] = "InsufficientStorage";
+    /** RFC 5842, 7.2 */
+    Status[Status["LoopDetected"] = 508] = "LoopDetected";
+    /** RFC 2774, 7 */
+    Status[Status["NotExtended"] = 510] = "NotExtended";
+    /** RFC 6585, 6 */
+    Status[Status["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(Status || (Status = {}));
+/**
+ * A constant hash of all the standard HTTP status codes.
+ */
+export const STATUS_CODE = {
+    /** RFC 7231, 6.2.1 */
+    Continue: 100,
+    /** RFC 7231, 6.2.2 */
+    SwitchingProtocols: 101,
+    /** RFC 2518, 10.1 */
+    Processing: 102,
+    /** RFC 8297 **/
+    EarlyHints: 103,
+    /** RFC 7231, 6.3.1 */
+    OK: 200,
+    /** RFC 7231, 6.3.2 */
+    Created: 201,
+    /** RFC 7231, 6.3.3 */
+    Accepted: 202,
+    /** RFC 7231, 6.3.4 */
+    NonAuthoritativeInfo: 203,
+    /** RFC 7231, 6.3.5 */
+    NoContent: 204,
+    /** RFC 7231, 6.3.6 */
+    ResetContent: 205,
+    /** RFC 7233, 4.1 */
+    PartialContent: 206,
+    /** RFC 4918, 11.1 */
+    MultiStatus: 207,
+    /** RFC 5842, 7.1 */
+    AlreadyReported: 208,
+    /** RFC 3229, 10.4.1 */
+    IMUsed: 226,
+    /** RFC 7231, 6.4.1 */
+    MultipleChoices: 300,
+    /** RFC 7231, 6.4.2 */
+    MovedPermanently: 301,
+    /** RFC 7231, 6.4.3 */
+    Found: 302,
+    /** RFC 7231, 6.4.4 */
+    SeeOther: 303,
+    /** RFC 7232, 4.1 */
+    NotModified: 304,
+    /** RFC 7231, 6.4.5 */
+    UseProxy: 305,
+    /** RFC 7231, 6.4.7 */
+    TemporaryRedirect: 307,
+    /** RFC 7538, 3 */
+    PermanentRedirect: 308,
+    /** RFC 7231, 6.5.1 */
+    BadRequest: 400,
+    /** RFC 7235, 3.1 */
+    Unauthorized: 401,
+    /** RFC 7231, 6.5.2 */
+    PaymentRequired: 402,
+    /** RFC 7231, 6.5.3 */
+    Forbidden: 403,
+    /** RFC 7231, 6.5.4 */
+    NotFound: 404,
+    /** RFC 7231, 6.5.5 */
+    MethodNotAllowed: 405,
+    /** RFC 7231, 6.5.6 */
+    NotAcceptable: 406,
+    /** RFC 7235, 3.2 */
+    ProxyAuthRequired: 407,
+    /** RFC 7231, 6.5.7 */
+    RequestTimeout: 408,
+    /** RFC 7231, 6.5.8 */
+    Conflict: 409,
+    /** RFC 7231, 6.5.9 */
+    Gone: 410,
+    /** RFC 7231, 6.5.10 */
+    LengthRequired: 411,
+    /** RFC 7232, 4.2 */
+    PreconditionFailed: 412,
+    /** RFC 7231, 6.5.11 */
+    ContentTooLarge: 413,
+    /** RFC 7231, 6.5.12 */
+    URITooLong: 414,
+    /** RFC 7231, 6.5.13 */
+    UnsupportedMediaType: 415,
+    /** RFC 7233, 4.4 */
+    RangeNotSatisfiable: 416,
+    /** RFC 7231, 6.5.14 */
+    ExpectationFailed: 417,
+    /** RFC 7168, 2.3.3 */
+    Teapot: 418,
+    /** RFC 7540, 9.1.2 */
+    MisdirectedRequest: 421,
+    /** RFC 4918, 11.2 */
+    UnprocessableEntity: 422,
+    /** RFC 4918, 11.3 */
+    Locked: 423,
+    /** RFC 4918, 11.4 */
+    FailedDependency: 424,
+    /** RFC 8470, 5.2 */
+    TooEarly: 425,
+    /** RFC 7231, 6.5.15 */
+    UpgradeRequired: 426,
+    /** RFC 6585, 3 */
+    PreconditionRequired: 428,
+    /** RFC 6585, 4 */
+    TooManyRequests: 429,
+    /** RFC 6585, 5 */
+    RequestHeaderFieldsTooLarge: 431,
+    /** RFC 7725, 3 */
+    UnavailableForLegalReasons: 451,
+    /** RFC 7231, 6.6.1 */
+    InternalServerError: 500,
+    /** RFC 7231, 6.6.2 */
+    NotImplemented: 501,
+    /** RFC 7231, 6.6.3 */
+    BadGateway: 502,
+    /** RFC 7231, 6.6.4 */
+    ServiceUnavailable: 503,
+    /** RFC 7231, 6.6.5 */
+    GatewayTimeout: 504,
+    /** RFC 7231, 6.6.6 */
+    HTTPVersionNotSupported: 505,
+    /** RFC 2295, 8.1 */
+    VariantAlsoNegotiates: 506,
+    /** RFC 4918, 11.5 */
+    InsufficientStorage: 507,
+    /** RFC 5842, 7.2 */
+    LoopDetected: 508,
+    /** RFC 2774, 7 */
+    NotExtended: 510,
+    /** RFC 6585, 6 */
+    NetworkAuthenticationRequired: 511,
+};
+/**
+ * A record of all the status codes text.
+ */
+export const STATUS_TEXT = {
+    [STATUS_CODE.Accepted]: "Accepted",
+    [STATUS_CODE.AlreadyReported]: "Already Reported",
+    [STATUS_CODE.BadGateway]: "Bad Gateway",
+    [STATUS_CODE.BadRequest]: "Bad Request",
+    [STATUS_CODE.Conflict]: "Conflict",
+    [STATUS_CODE.Continue]: "Continue",
+    [STATUS_CODE.Created]: "Created",
+    [STATUS_CODE.EarlyHints]: "Early Hints",
+    [STATUS_CODE.ExpectationFailed]: "Expectation Failed",
+    [STATUS_CODE.FailedDependency]: "Failed Dependency",
+    [STATUS_CODE.Forbidden]: "Forbidden",
+    [STATUS_CODE.Found]: "Found",
+    [STATUS_CODE.GatewayTimeout]: "Gateway Timeout",
+    [STATUS_CODE.Gone]: "Gone",
+    [STATUS_CODE.HTTPVersionNotSupported]: "HTTP Version Not Supported",
+    [STATUS_CODE.IMUsed]: "IM Used",
+    [STATUS_CODE.InsufficientStorage]: "Insufficient Storage",
+    [STATUS_CODE.InternalServerError]: "Internal Server Error",
+    [STATUS_CODE.LengthRequired]: "Length Required",
+    [STATUS_CODE.Locked]: "Locked",
+    [STATUS_CODE.LoopDetected]: "Loop Detected",
+    [STATUS_CODE.MethodNotAllowed]: "Method Not Allowed",
+    [STATUS_CODE.MisdirectedRequest]: "Misdirected Request",
+    [STATUS_CODE.MovedPermanently]: "Moved Permanently",
+    [STATUS_CODE.MultiStatus]: "Multi Status",
+    [STATUS_CODE.MultipleChoices]: "Multiple Choices",
+    [STATUS_CODE.NetworkAuthenticationRequired]: "Network Authentication Required",
+    [STATUS_CODE.NoContent]: "No Content",
+    [STATUS_CODE.NonAuthoritativeInfo]: "Non Authoritative Info",
+    [STATUS_CODE.NotAcceptable]: "Not Acceptable",
+    [STATUS_CODE.NotExtended]: "Not Extended",
+    [STATUS_CODE.NotFound]: "Not Found",
+    [STATUS_CODE.NotImplemented]: "Not Implemented",
+    [STATUS_CODE.NotModified]: "Not Modified",
+    [STATUS_CODE.OK]: "OK",
+    [STATUS_CODE.PartialContent]: "Partial Content",
+    [STATUS_CODE.PaymentRequired]: "Payment Required",
+    [STATUS_CODE.PermanentRedirect]: "Permanent Redirect",
+    [STATUS_CODE.PreconditionFailed]: "Precondition Failed",
+    [STATUS_CODE.PreconditionRequired]: "Precondition Required",
+    [STATUS_CODE.Processing]: "Processing",
+    [STATUS_CODE.ProxyAuthRequired]: "Proxy Auth Required",
+    [STATUS_CODE.ContentTooLarge]: "Content Too Large",
+    [STATUS_CODE.RequestHeaderFieldsTooLarge]: "Request Header Fields Too Large",
+    [STATUS_CODE.RequestTimeout]: "Request Timeout",
+    [STATUS_CODE.URITooLong]: "URI Too Long",
+    [STATUS_CODE.RangeNotSatisfiable]: "Range Not Satisfiable",
+    [STATUS_CODE.ResetContent]: "Reset Content",
+    [STATUS_CODE.SeeOther]: "See Other",
+    [STATUS_CODE.ServiceUnavailable]: "Service Unavailable",
+    [STATUS_CODE.SwitchingProtocols]: "Switching Protocols",
+    [STATUS_CODE.Teapot]: "I'm a teapot",
+    [STATUS_CODE.TemporaryRedirect]: "Temporary Redirect",
+    [STATUS_CODE.TooEarly]: "Too Early",
+    [STATUS_CODE.TooManyRequests]: "Too Many Requests",
+    [STATUS_CODE.Unauthorized]: "Unauthorized",
+    [STATUS_CODE.UnavailableForLegalReasons]: "Unavailable For Legal Reasons",
+    [STATUS_CODE.UnprocessableEntity]: "Unprocessable Entity",
+    [STATUS_CODE.UnsupportedMediaType]: "Unsupported Media Type",
+    [STATUS_CODE.UpgradeRequired]: "Upgrade Required",
+    [STATUS_CODE.UseProxy]: "Use Proxy",
+    [STATUS_CODE.VariantAlsoNegotiates]: "Variant Also Negotiates",
+};
+/**
+ * A type guard that determines if the value is a valid {@linkcode StatusCode}.
+ */
+export function isStatus(status) {
+    return Object.values(STATUS_CODE).includes(status);
+}
+/** A type guard that determines if the status code is informational. */
+export function isInformationalStatus(status) {
+    return isStatus(status) && status >= 100 && status < 200;
+}
+/** A type guard that determines if the status code is successful. */
+export function isSuccessfulStatus(status) {
+    return isStatus(status) && status >= 200 && status < 300;
+}
+/** A type guard that determines if the status code is a redirection. */
+export function isRedirectStatus(status) {
+    return isStatus(status) && status >= 300 && status < 400;
+}
+/** A type guard that determines if the status code is a client error. */
+export function isClientErrorStatus(status) {
+    return isStatus(status) && status >= 400 && status < 500;
+}
+/** A type guard that determines if the status code is a server error. */
+export function isServerErrorStatus(status) {
+    return isStatus(status) && status >= 500 && status < 600;
+}
+/** A type guard that determines if the status code is an error. */
+export function isErrorStatus(status) {
+    return isStatus(status) && status >= 400 && status < 600;
+}

package/esm/deps/jsr.io/@std/assert/1.0.11/assert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+//# sourceMappingURL=assert.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.11/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/esm/deps/jsr.io/@std/assert/1.0.11/assert.js

@@ -0,0 +1,22 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/jsr.io/@std/assert/1.0.11/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.11/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.11/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/esm/deps/jsr.io/@std/assert/1.0.11/assertion_error.js

@@ -0,0 +1,30 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}

package/esm/deps/jsr.io/@std/bytes/1.0.5/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

package/esm/deps/jsr.io/@std/bytes/1.0.5/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/esm/deps/jsr.io/@std/bytes/1.0.5/_types.js

@@ -0,0 +1,2 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export {};

package/esm/deps/jsr.io/@std/bytes/1.0.5/concat.d.ts

@@ -0,0 +1,21 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns A new byte slice containing all the input slices concatenated.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
+ * ```
+ */
+export declare function concat(buffers: Uint8Array[]): Uint8Array_;
+//# sourceMappingURL=concat.d.ts.map

package/esm/deps/jsr.io/@std/bytes/1.0.5/concat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/concat.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,WAAW,CAazD"}

package/esm/deps/jsr.io/@std/bytes/1.0.5/concat.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns A new byte slice containing all the input slices concatenated.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
+ * ```
+ */
+export function concat(buffers) {
+    let length = 0;
+    for (const buffer of buffers) {
+        length += buffer.length;
+    }
+    const output = new Uint8Array(length);
+    let index = 0;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
+    }
+    return output;
+}

package/esm/deps/jsr.io/@std/crypto/1.0.4/timing_safe_equal.d.ts

@@ -0,0 +1,34 @@
+/**
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * {@link https://github.com/w3c/webcrypto/issues/270 | w3c/webcrypto#270}), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * @example Usage
+ * ```ts
+ * import { timingSafeEqual } from "@std/crypto/timing-safe-equal";
+ * import { assert } from "@std/assert";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns `true` if the values are equal, otherwise `false`.
+ */
+export declare function timingSafeEqual(a: ArrayBufferView | ArrayBufferLike | DataView, b: ArrayBufferView | ArrayBufferLike | DataView): boolean;
+//# sourceMappingURL=timing_safe_equal.d.ts.map

package/esm/deps/jsr.io/@std/crypto/1.0.4/timing_safe_equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing_safe_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/crypto/1.0.4/timing_safe_equal.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,QAAQ,EAC/C,CAAC,EAAE,eAAe,GAAG,eAAe,GAAG,QAAQ,GAC9C,OAAO,CAWT"}

package/esm/deps/jsr.io/@std/crypto/1.0.4/timing_safe_equal.js

@@ -0,0 +1,55 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+function toDataView(value) {
+    if (value instanceof DataView) {
+        return value;
+    }
+    return ArrayBuffer.isView(value)
+        ? new DataView(value.buffer, value.byteOffset, value.byteLength)
+        : new DataView(value);
+}
+/**
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * {@link https://github.com/w3c/webcrypto/issues/270 | w3c/webcrypto#270}), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * @example Usage
+ * ```ts
+ * import { timingSafeEqual } from "@std/crypto/timing-safe-equal";
+ * import { assert } from "@std/assert";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns `true` if the values are equal, otherwise `false`.
+ */
+export function timingSafeEqual(a, b) {
+    if (a.byteLength !== b.byteLength)
+        return false;
+    const dataViewA = toDataView(a);
+    const dataViewB = toDataView(b);
+    const length = a.byteLength;
+    let out = 0;
+    let i = -1;
+    while (++i < length) {
+        out |= dataViewA.getUint8(i) ^ dataViewB.getUint8(i);
+    }
+    return out === 0;
+}

package/esm/deps/jsr.io/@std/encoding/1.0.7/_types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy type of {@code Uint8Array<ArrayBuffer} or {@code Uint8Array} in TypeScript 5.7 or below respectively.
+ *
+ * This type is internal utility type and should not be used directly.
+ *
+ * @internal @private
+ */
+export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+//# sourceMappingURL=_types.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.7/_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/_types.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC"}