@mtkruto/node 0.1.0 → 0.1.101

package/script/deps/deno.land/std@0.203.0/crypto/_wasm/mod.d.ts

@@ -0,0 +1,12 @@
+export { DigestContext, instantiate as instantiateWasm, } from "./lib/deno_std_wasm_crypto.generated.js";
+/**
+ * All cryptographic hash/digest algorithms supported by std/crypto/_wasm.
+ *
+ * For algorithms that are supported by WebCrypto, the name here must match the
+ * one used by WebCrypto. Otherwise we should prefer the formatting used in the
+ * official specification. All names are uppercase to facilitate case-insensitive
+ * comparisons required by the WebCrypto spec.
+ */
+export declare const digestAlgorithms: readonly ["BLAKE2B-224", "BLAKE2B-256", "BLAKE2B-384", "BLAKE2B", "BLAKE2S", "BLAKE3", "KECCAK-224", "KECCAK-256", "KECCAK-384", "KECCAK-512", "SHA-384", "SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512", "SHAKE128", "SHAKE256", "TIGER", "RIPEMD-160", "SHA-224", "SHA-256", "SHA-512", "MD4", "MD5", "SHA-1"];
+/** An algorithm name supported by std/crypto/_wasm. */
+export type DigestAlgorithm = typeof digestAlgorithms[number];

package/script/deps/deno.land/std@0.203.0/crypto/_wasm/mod.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestAlgorithms = exports.instantiateWasm = exports.DigestContext = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+var deno_std_wasm_crypto_generated_js_1 = require("./lib/deno_std_wasm_crypto.generated.js");
+Object.defineProperty(exports, "DigestContext", { enumerable: true, get: function () { return deno_std_wasm_crypto_generated_js_1.DigestContext; } });
+Object.defineProperty(exports, "instantiateWasm", { enumerable: true, get: function () { return deno_std_wasm_crypto_generated_js_1.instantiate; } });
+/**
+ * All cryptographic hash/digest algorithms supported by std/crypto/_wasm.
+ *
+ * For algorithms that are supported by WebCrypto, the name here must match the
+ * one used by WebCrypto. Otherwise we should prefer the formatting used in the
+ * official specification. All names are uppercase to facilitate case-insensitive
+ * comparisons required by the WebCrypto spec.
+ */
+exports.digestAlgorithms = [
+    "BLAKE2B-224",
+    "BLAKE2B-256",
+    "BLAKE2B-384",
+    "BLAKE2B",
+    "BLAKE2S",
+    "BLAKE3",
+    "KECCAK-224",
+    "KECCAK-256",
+    "KECCAK-384",
+    "KECCAK-512",
+    "SHA-384",
+    "SHA3-224",
+    "SHA3-256",
+    "SHA3-384",
+    "SHA3-512",
+    "SHAKE128",
+    "SHAKE256",
+    "TIGER",
+    // insecure (length-extendable):
+    "RIPEMD-160",
+    "SHA-224",
+    "SHA-256",
+    "SHA-512",
+    // insecure (collidable and length-extendable):
+    "MD4",
+    "MD5",
+    "SHA-1",
+];

package/script/deps/deno.land/std@0.203.0/crypto/crypto.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Extensions to the
+ * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
+ *
+ * Provides additional digest algorithms that are not part of the WebCrypto
+ * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
+ * also provides a `subtle.timingSafeEqual()` method to compare array buffers
+ * or data views in a way that isn't prone to timing based attacks.
+ *
+ * The "polyfill" delegates to `WebCrypto` where possible.
+ *
+ * The {@linkcode KeyStack} export implements the {@linkcode KeyRing} interface
+ * for managing rotatable keys for signing data to prevent tampering, like with
+ * HTTP cookies.
+ *
+ * ## Supported algorithms
+ *
+ * Here is a list of supported algorithms. If the algorithm name in WebCrypto
+ * and Wasm/Rust is the same, this library prefers to use algorithms that are
+ * supported by WebCrypto.
+ *
+ * WebCrypto
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/crypto.ts
+ * const webCryptoDigestAlgorithms = [
+ *   "SHA-384",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (length-extendable and collidable):
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * Wasm/Rust
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/_wasm/mod.ts
+ * export const digestAlgorithms = [
+ *   "BLAKE2B-224",
+ *   "BLAKE2B-256",
+ *   "BLAKE2B-384",
+ *   "BLAKE2B",
+ *   "BLAKE2S",
+ *   "BLAKE3",
+ *   "KECCAK-224",
+ *   "KECCAK-256",
+ *   "KECCAK-384",
+ *   "KECCAK-512",
+ *   "SHA-384",
+ *   "SHA3-224",
+ *   "SHA3-256",
+ *   "SHA3-384",
+ *   "SHA3-512",
+ *   "SHAKE128",
+ *   "SHAKE256",
+ *   "TIGER",
+ *   // insecure (length-extendable):
+ *   "RIPEMD-160",
+ *   "SHA-224",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (collidable and length-extendable):
+ *   "MD4",
+ *   "MD5",
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * // This will delegate to the runtime's WebCrypto implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "SHA-384",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ *
+ * // This will use a bundled Wasm/Rust implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "BLAKE3",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * @example Convert hash to a string
+ *
+ * ```ts
+ * import {
+ *   crypto,
+ *   toHashString,
+ * } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * const hash = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("You hear that Mr. Anderson?"),
+ * );
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ *
+ * @module
+ */
+import * as dntShim from "../../../../_dnt.shims.js";
+import { DigestAlgorithm as WasmDigestAlgorithm } from "./_wasm/mod.js";
+/** Extensions to the web standard `SubtleCrypto` interface. */
+export interface StdSubtleCrypto extends dntShim.SubtleCrypto {
+    /**
+     * Returns a new `Promise` object that will digest `data` using the specified
+     * `AlgorithmIdentifier`.
+     */
+    digest(algorithm: DigestAlgorithm, data: dntShim.BufferSource | AsyncIterable<dntShim.BufferSource> | Iterable<dntShim.BufferSource>): Promise<ArrayBuffer>;
+    /**
+     * Returns a ArrayBuffer with the result of digesting `data` using the
+     * specified `AlgorithmIdentifier`.
+     */
+    digestSync(algorithm: DigestAlgorithm, data: dntShim.BufferSource | Iterable<dntShim.BufferSource>): ArrayBuffer;
+    /**
+     * @deprecated (will be removed in 0.207.0) Import from `std/crypto/timing_safe_equal.ts` instead
+     *
+     * Compare to array buffers or data views in a way that timing based attacks
+     * cannot gain information about the platform. */
+    timingSafeEqual(a: ArrayBufferLike | DataView, b: ArrayBufferLike | DataView): boolean;
+}
+/** Extensions to the Web {@linkcode Crypto} interface. */
+export interface StdCrypto extends dntShim.Crypto {
+    readonly subtle: StdSubtleCrypto;
+}
+/**
+ * An wrapper for WebCrypto adding support for additional non-standard
+ * algorithms, but delegating to the runtime WebCrypto implementation whenever
+ * possible.
+ */
+declare const stdCrypto: StdCrypto;
+export type FNVAlgorithms = "FNV32" | "FNV32A" | "FNV64" | "FNV64A";
+export type DigestAlgorithmName = WasmDigestAlgorithm | FNVAlgorithms;
+export type DigestAlgorithmObject = {
+    name: DigestAlgorithmName;
+    length?: number;
+};
+export type DigestAlgorithm = DigestAlgorithmName | DigestAlgorithmObject;
+export { stdCrypto as crypto };

package/script/deps/deno.land/std@0.203.0/crypto/crypto.js

@@ -0,0 +1,292 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crypto = void 0;
+/**
+ * Extensions to the
+ * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
+ *
+ * Provides additional digest algorithms that are not part of the WebCrypto
+ * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
+ * also provides a `subtle.timingSafeEqual()` method to compare array buffers
+ * or data views in a way that isn't prone to timing based attacks.
+ *
+ * The "polyfill" delegates to `WebCrypto` where possible.
+ *
+ * The {@linkcode KeyStack} export implements the {@linkcode KeyRing} interface
+ * for managing rotatable keys for signing data to prevent tampering, like with
+ * HTTP cookies.
+ *
+ * ## Supported algorithms
+ *
+ * Here is a list of supported algorithms. If the algorithm name in WebCrypto
+ * and Wasm/Rust is the same, this library prefers to use algorithms that are
+ * supported by WebCrypto.
+ *
+ * WebCrypto
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/crypto.ts
+ * const webCryptoDigestAlgorithms = [
+ *   "SHA-384",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (length-extendable and collidable):
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * Wasm/Rust
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/_wasm/mod.ts
+ * export const digestAlgorithms = [
+ *   "BLAKE2B-224",
+ *   "BLAKE2B-256",
+ *   "BLAKE2B-384",
+ *   "BLAKE2B",
+ *   "BLAKE2S",
+ *   "BLAKE3",
+ *   "KECCAK-224",
+ *   "KECCAK-256",
+ *   "KECCAK-384",
+ *   "KECCAK-512",
+ *   "SHA-384",
+ *   "SHA3-224",
+ *   "SHA3-256",
+ *   "SHA3-384",
+ *   "SHA3-512",
+ *   "SHAKE128",
+ *   "SHAKE256",
+ *   "TIGER",
+ *   // insecure (length-extendable):
+ *   "RIPEMD-160",
+ *   "SHA-224",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (collidable and length-extendable):
+ *   "MD4",
+ *   "MD5",
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * // This will delegate to the runtime's WebCrypto implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "SHA-384",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ *
+ * // This will use a bundled Wasm/Rust implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "BLAKE3",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * @example Convert hash to a string
+ *
+ * ```ts
+ * import {
+ *   crypto,
+ *   toHashString,
+ * } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * const hash = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("You hear that Mr. Anderson?"),
+ * );
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ *
+ * @module
+ */
+const dntShim = __importStar(require("../../../../_dnt.shims.js"));
+const mod_js_1 = require("./_wasm/mod.js");
+const timing_safe_equal_js_1 = require("./timing_safe_equal.js");
+const mod_js_2 = require("./_fnv/mod.js");
+/**
+ * A copy of the global WebCrypto interface, with methods bound so they're
+ * safe to re-export.
+ */
+const webCrypto = ((crypto) => ({
+    getRandomValues: crypto.getRandomValues?.bind(crypto),
+    randomUUID: crypto.randomUUID?.bind(crypto),
+    subtle: {
+        decrypt: crypto.subtle?.decrypt?.bind(crypto.subtle),
+        deriveBits: crypto.subtle?.deriveBits?.bind(crypto.subtle),
+        deriveKey: crypto.subtle?.deriveKey?.bind(crypto.subtle),
+        digest: crypto.subtle?.digest?.bind(crypto.subtle),
+        encrypt: crypto.subtle?.encrypt?.bind(crypto.subtle),
+        exportKey: crypto.subtle?.exportKey?.bind(crypto.subtle),
+        generateKey: crypto.subtle?.generateKey?.bind(crypto.subtle),
+        importKey: crypto.subtle?.importKey?.bind(crypto.subtle),
+        sign: crypto.subtle?.sign?.bind(crypto.subtle),
+        unwrapKey: crypto.subtle?.unwrapKey?.bind(crypto.subtle),
+        verify: crypto.subtle?.verify?.bind(crypto.subtle),
+        wrapKey: crypto.subtle?.wrapKey?.bind(crypto.subtle),
+    },
+}))(dntShim.dntGlobalThis.crypto);
+const bufferSourceBytes = (data) => {
+    let bytes;
+    if (data instanceof Uint8Array) {
+        bytes = data;
+    }
+    else if (ArrayBuffer.isView(data)) {
+        bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    else if (data instanceof ArrayBuffer) {
+        bytes = new Uint8Array(data);
+    }
+    return bytes;
+};
+/**
+ * An wrapper for WebCrypto adding support for additional non-standard
+ * algorithms, but delegating to the runtime WebCrypto implementation whenever
+ * possible.
+ */
+const stdCrypto = ((x) => x)({
+    ...webCrypto,
+    subtle: {
+        ...webCrypto.subtle,
+        /**
+         * Polyfills stream support until the Web Crypto API does so:
+         * @see {@link https://github.com/wintercg/proposal-webcrypto-streams}
+         */
+        async digest(algorithm, data) {
+            const { name, length } = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data);
+            if (FNVAlgorithms.includes(name)) {
+                return (0, mod_js_2.fnv)(name, bytes);
+            }
+            // We delegate to WebCrypto whenever possible,
+            if (
+            // if the algorithm is supported by the WebCrypto standard,
+            webCryptoDigestAlgorithms.includes(name) &&
+                // and the data is a single buffer,
+                bytes) {
+                return webCrypto.subtle.digest(algorithm, bytes);
+            }
+            else if (mod_js_1.digestAlgorithms.includes(name)) {
+                if (bytes) {
+                    // Otherwise, we use our bundled Wasm implementation via digestSync
+                    // if it supports the algorithm.
+                    return stdCrypto.subtle.digestSync(algorithm, bytes);
+                }
+                else if (data[Symbol.iterator]) {
+                    return stdCrypto.subtle.digestSync(algorithm, data);
+                }
+                else if (data[Symbol.asyncIterator]) {
+                    const wasmCrypto = (0, mod_js_1.instantiateWasm)();
+                    const context = new wasmCrypto.DigestContext(name);
+                    for await (const chunk of data) {
+                        const chunkBytes = bufferSourceBytes(chunk);
+                        if (!chunkBytes) {
+                            throw new TypeError("data contained chunk of the wrong type");
+                        }
+                        context.update(chunkBytes);
+                    }
+                    return context.digestAndDrop(length).buffer;
+                }
+                else {
+                    throw new TypeError("data must be a BufferSource or [Async]Iterable<BufferSource>");
+                }
+            }
+            else if (webCrypto.subtle?.digest) {
+                // (TypeScript type definitions prohibit this case.) If they're trying
+                // to call an algorithm we don't recognize, pass it along to WebCrypto
+                // in case it's a non-standard algorithm supported by the the runtime
+                // they're using.
+                return webCrypto.subtle.digest(algorithm, data);
+            }
+            else {
+                throw new TypeError(`unsupported digest algorithm: ${algorithm}`);
+            }
+        },
+        digestSync(algorithm, data) {
+            algorithm = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data);
+            if (FNVAlgorithms.includes(algorithm.name)) {
+                return (0, mod_js_2.fnv)(algorithm.name, bytes);
+            }
+            const wasmCrypto = (0, mod_js_1.instantiateWasm)();
+            if (bytes) {
+                return wasmCrypto.digest(algorithm.name, bytes, algorithm.length)
+                    .buffer;
+            }
+            else if (data[Symbol.iterator]) {
+                const context = new wasmCrypto.DigestContext(algorithm.name);
+                for (const chunk of data) {
+                    const chunkBytes = bufferSourceBytes(chunk);
+                    if (!chunkBytes) {
+                        throw new TypeError("data contained chunk of the wrong type");
+                    }
+                    context.update(chunkBytes);
+                }
+                return context.digestAndDrop(algorithm.length).buffer;
+            }
+            else {
+                throw new TypeError("data must be a BufferSource or Iterable<BufferSource>");
+            }
+        },
+        // TODO(@kitsonk): rework when https://github.com/w3c/webcrypto/issues/270 resolved
+        timingSafeEqual: timing_safe_equal_js_1.timingSafeEqual,
+    },
+});
+exports.crypto = stdCrypto;
+const FNVAlgorithms = ["FNV32", "FNV32A", "FNV64", "FNV64A"];
+/** Digest algorithms supported by WebCrypto. */
+const webCryptoDigestAlgorithms = [
+    "SHA-384",
+    "SHA-256",
+    "SHA-512",
+    // insecure (length-extendable and collidable):
+    "SHA-1",
+];
+const normalizeAlgorithm = (algorithm) => ((typeof algorithm === "string") ? { name: algorithm.toUpperCase() } : {
+    ...algorithm,
+    name: algorithm.name.toUpperCase(),
+});

package/script/deps/deno.land/std@0.203.0/crypto/keystack.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated (will be removed after 0.209.0) Import from `std/crypto/unstable/keystack.ts` instead.
+ */
+export * from "./unstable/keystack.js";

package/script/deps/deno.land/std@0.203.0/crypto/keystack.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @deprecated (will be removed after 0.209.0) Import from `std/crypto/unstable/keystack.ts` instead.
+ */
+__exportStar(require("./unstable/keystack.js"), exports);

package/script/deps/deno.land/std@0.203.0/crypto/mod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extensions to the
+ * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
+ *
+ * @module
+ */
+export * from "./crypto.js";
+export * from "./keystack.js";
+export * from "./timing_safe_equal.js";
+export * from "./to_hash_string.js";

package/script/deps/deno.land/std@0.203.0/crypto/mod.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Extensions to the
+ * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
+ *
+ * @module
+ */
+__exportStar(require("./crypto.js"), exports);
+__exportStar(require("./keystack.js"), exports);
+__exportStar(require("./timing_safe_equal.js"), exports);
+__exportStar(require("./to_hash_string.js"), exports);

package/script/deps/deno.land/std@0.203.0/crypto/timing_safe_equal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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:
+ * [w3c/webcrypto#270](https://github.com/w3c/webcrypto/issues/270)), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * ```ts
+ * import { timingSafeEqual } from "https://deno.land/std@$STD_VERSION/crypto/timing_safe_equal.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * 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));
+ * ```
+ */
+export declare function timingSafeEqual(a: ArrayBufferView | ArrayBufferLike | DataView, b: ArrayBufferView | ArrayBufferLike | DataView): boolean;

package/script/deps/deno.land/std@0.203.0/crypto/timing_safe_equal.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timingSafeEqual = void 0;
+const assert_js_1 = require("../assert/assert.js");
+/**
+ * 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:
+ * [w3c/webcrypto#270](https://github.com/w3c/webcrypto/issues/270)), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * ```ts
+ * import { timingSafeEqual } from "https://deno.land/std@$STD_VERSION/crypto/timing_safe_equal.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * 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));
+ * ```
+ */
+function timingSafeEqual(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    if (!(a instanceof DataView)) {
+        a = ArrayBuffer.isView(a)
+            ? new DataView(a.buffer, a.byteOffset, a.byteLength)
+            : new DataView(a);
+    }
+    if (!(b instanceof DataView)) {
+        b = ArrayBuffer.isView(b)
+            ? new DataView(b.buffer, b.byteOffset, b.byteLength)
+            : new DataView(b);
+    }
+    (0, assert_js_1.assert)(a instanceof DataView);
+    (0, assert_js_1.assert)(b instanceof DataView);
+    const length = a.byteLength;
+    let out = 0;
+    let i = -1;
+    while (++i < length) {
+        out |= a.getUint8(i) ^ b.getUint8(i);
+    }
+    return out === 0;
+}
+exports.timingSafeEqual = timingSafeEqual;