@mtkruto/node 0.1.101 → 0.1.103

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

@@ -1,12 +0,0 @@
-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/esm/deps/deno.land/std@0.203.0/crypto/_wasm/mod.js

@@ -1,39 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-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 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",
-];

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

@@ -1,157 +0,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
- */
-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/esm/deps/deno.land/std@0.203.0/crypto/crypto.js

@@ -1,266 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * 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 { digestAlgorithms as wasmDigestAlgorithms, instantiateWasm, } from "./_wasm/mod.js";
-import { timingSafeEqual } from "./timing_safe_equal.js";
-import { fnv } from "./_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 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 (wasmDigestAlgorithms.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 = 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 fnv(algorithm.name, bytes);
-            }
-            const wasmCrypto = 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,
-    },
-});
-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(),
-});
-export { stdCrypto as crypto };

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

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

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

@@ -1,6 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * @deprecated (will be removed after 0.209.0) Import from `std/crypto/unstable/keystack.ts` instead.
- */
-export * from "./unstable/keystack.js";

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

@@ -1,12 +0,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.
- *
- * @module
- */
-export * from "./crypto.js";
-export * from "./keystack.js";
-export * from "./timing_safe_equal.js";
-export * from "./to_hash_string.js";

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

@@ -1,14 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * 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/esm/deps/deno.land/std@0.203.0/crypto/timing_safe_equal.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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/esm/deps/deno.land/std@0.203.0/crypto/timing_safe_equal.js

@@ -1,54 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { assert } from "../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));
- * ```
- */
-export 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);
-    }
-    assert(a instanceof DataView);
-    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;
-}

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

@@ -1,19 +0,0 @@
-/**
- * @deprecated (will be removed after 0.209.0) Use `std/encoding/hex.ts` or `std/encoding/base64.ts` instead.
- *
- * Converts a hash to a string with a given encoding.
- * @example
- * ```ts
- * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/crypto.ts";
- * import { toHashString } from "https://deno.land/std@$STD_VERSION/crypto/to_hash_string.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"));
- * ```
- */
-export declare function toHashString(hash: ArrayBuffer, encoding?: "hex" | "base64"): string;

package/esm/deps/deno.land/std@0.203.0/crypto/to_hash_string.js

@@ -1,31 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { encode as hexEncode } from "../encoding/hex.js";
-import { encode as base64Encode } from "../encoding/base64.js";
-const decoder = new TextDecoder();
-/**
- * @deprecated (will be removed after 0.209.0) Use `std/encoding/hex.ts` or `std/encoding/base64.ts` instead.
- *
- * Converts a hash to a string with a given encoding.
- * @example
- * ```ts
- * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/crypto.ts";
- * import { toHashString } from "https://deno.land/std@$STD_VERSION/crypto/to_hash_string.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"));
- * ```
- */
-export function toHashString(hash, encoding = "hex") {
-    switch (encoding) {
-        case "hex":
-            return decoder.decode(hexEncode(new Uint8Array(hash)));
-        case "base64":
-            return base64Encode(hash);
-    }
-}