git-remote-ops 0.1.0 → 0.2.0

package/esm/deps/jsr.io/@std/crypto/1.1.0/_wasm/mod.js

@@ -1,46 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-export { digest, DigestContext } from "./lib/deno_std_wasm_crypto.js";
-/**
- * All cryptographic hash/digest algorithms supported by std/crypto.
- *
- * For algorithms that are supported by WebCrypto, the name here will match the
- * one used by WebCrypto. Otherwise we prefer the formatting used in the
- * algorithm's official specification. All names are uppercase to facilitate
- * case-insensitive comparisons required by the WebCrypto spec.
- */
-export const DIGEST_ALGORITHM_NAMES = [
-    "BLAKE2B",
-    "BLAKE2B-128",
-    "BLAKE2B-160",
-    "BLAKE2B-224",
-    "BLAKE2B-256",
-    "BLAKE2B-384",
-    "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 (length-extendable and collidable):
-    "MD4",
-    "MD5",
-    "SHA-1",
-    // insecure (non-cryptographic)
-    "FNV32",
-    "FNV32A",
-    "FNV64",
-    "FNV64A",
-];

package/esm/deps/jsr.io/@std/crypto/1.1.0/aes_gcm.js

@@ -1,132 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import * as dntShim from "../../../../../_dnt.shims.js";
-/**
- * High-level AES-GCM authenticated encryption with automatic nonce generation.
- *
- * With random nonces, do not encrypt more than ~2^32 messages under the same
- * key. Beyond this limit, nonce collision probability becomes non-negligible.
- *
- * @example Usage
- * ```ts
- * import { encryptAesGcm, decryptAesGcm } from "@std/crypto/aes-gcm";
- * import { assertEquals } from "@std/assert";
- *
- * const key = await crypto.subtle.generateKey(
- *   { name: "AES-GCM", length: 256 },
- *   false,
- *   ["encrypt", "decrypt"],
- * );
- *
- * const plaintext = new TextEncoder().encode("hello world");
- * const encrypted = await encryptAesGcm(key, plaintext);
- * const decrypted = await decryptAesGcm(key, encrypted);
- *
- * assertEquals(decrypted, plaintext);
- * ```
- *
- * @module
- */
-const NONCE_LENGTH = 12;
-const TAG_LENGTH = 16;
-const OVERHEAD = NONCE_LENGTH + TAG_LENGTH;
-/**
- * Encrypts plaintext using AES-GCM with a random 96-bit nonce.
- *
- * Returns `nonce (12 bytes) || ciphertext || tag (16 bytes)`.
- *
- * @example Usage
- * ```ts
- * import { encryptAesGcm } from "@std/crypto/aes-gcm";
- * import { assertNotEquals } from "@std/assert";
- *
- * const key = await crypto.subtle.generateKey(
- *   { name: "AES-GCM", length: 256 },
- *   false,
- *   ["encrypt", "decrypt"],
- * );
- *
- * const encrypted = await encryptAesGcm(
- *   key,
- *   new TextEncoder().encode("hello world"),
- * );
- *
- * assertNotEquals(encrypted.length, 0);
- * ```
- *
- * @param key The AES-GCM `CryptoKey` to encrypt with.
- * @param plaintext The data to encrypt.
- * @param options Optional additional authenticated data.
- * @returns The concatenated nonce, ciphertext, and authentication tag.
- *
- * @remarks With random nonces, do not encrypt more than ~2^32 messages
- * under the same key. Beyond this limit, nonce collision probability
- * becomes non-negligible.
- *
- * @see {@link https://csrc.nist.gov/pubs/sp/800/38/d/final | NIST SP 800-38D} Section 8.3
- */
-export async function encryptAesGcm(key, plaintext, options) {
-    const nonce = dntShim.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
-    const params = {
-        name: "AES-GCM",
-        iv: nonce,
-        tagLength: TAG_LENGTH * 8,
-    };
-    if (options?.additionalData !== undefined) {
-        params.additionalData = options.additionalData;
-    }
-    const ciphertextAndTag = new Uint8Array(await dntShim.crypto.subtle.encrypt(params, key, plaintext));
-    const result = new Uint8Array(NONCE_LENGTH + ciphertextAndTag.byteLength);
-    result.set(nonce);
-    result.set(ciphertextAndTag, NONCE_LENGTH);
-    return result;
-}
-/**
- * Decrypts data produced by {@linkcode encryptAesGcm}.
- *
- * Expects input in the format `nonce (12 bytes) || ciphertext || tag (16 bytes)`.
- *
- * @example Usage
- * ```ts
- * import { decryptAesGcm, encryptAesGcm } from "@std/crypto/aes-gcm";
- * import { assertEquals } from "@std/assert";
- *
- * const key = await crypto.subtle.generateKey(
- *   { name: "AES-GCM", length: 256 },
- *   false,
- *   ["encrypt", "decrypt"],
- * );
- *
- * const plaintext = new TextEncoder().encode("hello world");
- * const encrypted = await encryptAesGcm(key, plaintext);
- *
- * assertEquals(await decryptAesGcm(key, encrypted), plaintext);
- * ```
- *
- * @param key The AES-GCM `CryptoKey` to decrypt with.
- * @param data The wire-format output from {@linkcode encryptAesGcm}: nonce (12 B) || ciphertext || tag (16 B).
- * @param options Optional additional authenticated data (must match what was used during encryption).
- * @returns The decrypted plaintext.
- * @throws {RangeError} If `data` is shorter than 28 bytes (12 nonce + 16 tag).
- * @throws {DOMException} If authentication fails (wrong key, tampered data, or
- * mismatched additional data).
- */
-export async function decryptAesGcm(key, data, options) {
-    const bytes = ArrayBuffer.isView(data)
-        ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-        : new Uint8Array(data);
-    if (bytes.byteLength < OVERHEAD) {
-        throw new RangeError(`Data is too short: expected at least ${OVERHEAD} bytes, got ${bytes.byteLength}`);
-    }
-    const nonce = bytes.subarray(0, NONCE_LENGTH);
-    const ciphertextAndTag = bytes.subarray(NONCE_LENGTH);
-    const params = {
-        name: "AES-GCM",
-        iv: nonce,
-        tagLength: TAG_LENGTH * 8,
-    };
-    if (options?.additionalData !== undefined) {
-        params.additionalData = options.additionalData;
-    }
-    return new Uint8Array(await dntShim.crypto.subtle.decrypt(params, key, ciphertextAndTag));
-}

package/esm/deps/jsr.io/@std/crypto/1.1.0/crypto.js

@@ -1,270 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Extensions to the
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_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.
- *
- * 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 the implementation
- * provided by WebCrypto.
- *
- * Length-adjustable algorithms support the
- * {@linkcode DigestAlgorithmObject.length} option.
- *
- * WebCrypto:
- * - `SHA-384`
- * - `SHA-256` (length-extendable)
- * - `SHA-512` (length-extendable)
- *
- * Wasm/Rust:
- * - `BLAKE2B`
- * - `BLAKE2B-128`
- * - `BLAKE2B-160`
- * - `BLAKE2B-224`
- * - `BLAKE2B-256`
- * - `BLAKE2B-384`
- * - `BLAKE2S`
- * - `BLAKE3` (length-adjustable)
- * - `KECCAK-224`
- * - `KECCAK-256`
- * - `KECCAK-384`
- * - `KECCAK-512`
- * - `SHA-384`
- * - `SHA3-224`
- * - `SHA3-256`
- * - `SHA3-384`
- * - `SHA3-512`
- * - `SHAKE128` (length-adjustable)
- * - `SHAKE256` (length-adjustable)
- * - `TIGER`
- * - `RIPEMD-160` (length-extendable)
- * - `SHA-224` (length-extendable)
- * - `SHA-256` (length-extendable)
- * - `SHA-512` (length-extendable)
- * - `MD4` (length-extendable and collidable)
- * - `MD5` (length-extendable and collidable)
- * - `SHA-1` (length-extendable and collidable)
- * - `FNV32` (non-cryptographic)
- * - `FNV32A` (non-cryptographic)
- * - `FNV64` (non-cryptographic)
- * - `FNV64A` (non-cryptographic)
- *
- * @example
- * ```ts
- * import { crypto } from "@std/crypto";
- *
- * // 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,
- * } from "@std/crypto";
- * import { encodeHex } from "@std/encoding/hex"
- * import { encodeBase64 } from "@std/encoding/base64"
- *
- * const hash = await crypto.subtle.digest(
- *   "SHA-384",
- *   new TextEncoder().encode("You hear that Mr. Anderson?"),
- * );
- *
- * // Hex encoding
- * console.log(encodeHex(hash));
- *
- * // Or with base64 encoding
- * console.log(encodeBase64(hash));
- * ```
- *
- * @module
- */
-import * as dntShim from "../../../../../_dnt.shims.js";
-import { digest, DIGEST_ALGORITHM_NAMES, DigestContext, } from "./_wasm/mod.js";
-export { DIGEST_ALGORITHM_NAMES };
-/** Digest algorithms supported by WebCrypto. */
-const WEB_CRYPTO_DIGEST_ALGORITHM_NAMES = [
-    "SHA-384",
-    "SHA-256",
-    "SHA-512",
-    // insecure (length-extendable and collidable):
-    "SHA-1",
-];
-/**
- * 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);
-function toUint8Array(data) {
-    if (data instanceof Uint8Array) {
-        return data;
-    }
-    else if (ArrayBuffer.isView(data)) {
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    else if (data instanceof ArrayBuffer) {
-        return new Uint8Array(data);
-    }
-    return undefined;
-}
-/**
- * A wrapper for WebCrypto which adds support for additional non-standard
- * algorithms, but delegates 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);
-            assertValidDigestLength(length);
-            // We delegate to WebCrypto whenever possible,
-            if (
-            // if the algorithm is supported by the WebCrypto standard,
-            WEB_CRYPTO_DIGEST_ALGORITHM_NAMES.includes(name) &&
-                // and the data is a single buffer,
-                isBufferSource(data)) {
-                return await webCrypto.subtle.digest(algorithm, data);
-            }
-            else if (DIGEST_ALGORITHM_NAMES.includes(name)) {
-                if (isBufferSource(data)) {
-                    // Otherwise, we use our bundled Wasm implementation via digestSync
-                    // if it supports the algorithm.
-                    return stdCrypto.subtle.digestSync(algorithm, data);
-                }
-                else if (isIterable(data)) {
-                    return stdCrypto.subtle.digestSync(algorithm, data);
-                }
-                else if (isAsyncIterable(data)) {
-                    const context = new DigestContext(name);
-                    for await (const chunk of data) {
-                        const chunkBytes = toUint8Array(chunk);
-                        if (!chunkBytes) {
-                            throw new TypeError("Cannot digest the data: A chunk is not ArrayBuffer nor ArrayBufferView");
-                        }
-                        context.update(chunkBytes);
-                    }
-                    return context.digestAndDrop(length).buffer;
-                }
-                else {
-                    throw new TypeError(
-                    // deno-lint-ignore deno-style-guide/error-message
-                    "data must be a BufferSource or [Async]Iterable<BufferSource>");
-                }
-            }
-            // (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 await webCrypto.subtle.digest(algorithm, data);
-        },
-        digestSync(algorithm, data) {
-            const { name, length } = normalizeAlgorithm(algorithm);
-            assertValidDigestLength(length);
-            if (isBufferSource(data)) {
-                const bytes = toUint8Array(data);
-                return digest(name, bytes, length).buffer;
-            }
-            if (isIterable(data)) {
-                const context = new DigestContext(name);
-                for (const chunk of data) {
-                    const chunkBytes = toUint8Array(chunk);
-                    if (!chunkBytes) {
-                        throw new TypeError("Cannot digest the data: A chunk is not ArrayBuffer nor ArrayBufferView");
-                    }
-                    context.update(chunkBytes);
-                }
-                return context.digestAndDrop(length).buffer;
-            }
-            throw new TypeError(
-            // deno-lint-ignore deno-style-guide/error-message
-            "data must be a BufferSource or Iterable<BufferSource>");
-        },
-    },
-});
-/*
- * The largest digest length the current Wasm implementation can support. This
- * is the value of `isize::MAX` on 32-bit platforms like Wasm, which is the
- * maximum allowed capacity of a Rust `Vec<u8>`.
- */
-const MAX_DIGEST_LENGTH = 0x7FFF_FFFF;
-/**
- * Asserts that a number is a valid length for a digest, which must be an
- * integer that fits in a Rust `Vec<u8>`, or be undefined.
- */
-function assertValidDigestLength(value) {
-    if (value !== undefined &&
-        (value < 0 || value > MAX_DIGEST_LENGTH ||
-            !Number.isInteger(value))) {
-        throw new RangeError(`length must be an integer between 0 and ${MAX_DIGEST_LENGTH}, inclusive`);
-    }
-}
-function normalizeAlgorithm(algorithm) {
-    return ((typeof algorithm === "string")
-        ? { name: algorithm.toUpperCase() }
-        : {
-            ...algorithm,
-            name: algorithm.name.toUpperCase(),
-        });
-}
-function isBufferSource(obj) {
-    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
-}
-function isIterable(obj) {
-    return typeof obj[Symbol.iterator] === "function";
-}
-function isAsyncIterable(obj) {
-    return typeof obj[Symbol.asyncIterator] === "function";
-}
-export { stdCrypto as crypto };

package/esm/deps/jsr.io/@std/crypto/1.1.0/mod.js

@@ -1,23 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Extensions to the
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API | Web Crypto}
- * supporting additional encryption APIs, but also delegating to the built-in
- * APIs when possible.
- *
- * ```ts no-assert
- * import { crypto } from "@std/crypto/crypto";
- *
- * const message = "Hello, Deno!";
- * const encoder = new TextEncoder();
- * const data = encoder.encode(message);
- *
- * await crypto.subtle.digest("BLAKE3", data);
- * ```
- *
- * @module
- */
-export * from "./aes_gcm.js";
-export * from "./crypto.js";
-export * from "./timing_safe_equal.js";

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

@@ -1,61 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-function toUint8Array(value) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    return ArrayBuffer.isView(value)
-        ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
-        : new Uint8Array(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.
- *
- * Note: This is a best-effort constant-time comparison implemented in
- * JavaScript. The V8 JIT compiler does not provide formal constant-time
- * guarantees, and inputs backed by `SharedArrayBuffer` are susceptible to
- * concurrent modification during comparison.
- *
- * @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`.
- * @throws {TypeError} If the byte lengths of the two buffers are not equal.
- */
-export function timingSafeEqual(a, b) {
-    if (a.byteLength !== b.byteLength) {
-        throw new TypeError(`Cannot compare buffers of different byte lengths (${a.byteLength} vs ${b.byteLength})`);
-    }
-    const ua = toUint8Array(a);
-    const ub = toUint8Array(b);
-    const length = ua.length;
-    let out = 0;
-    for (let i = 0; i < length; i++) {
-        out |= ua[i] ^ ub[i];
-    }
-    return out === 0;
-}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common16.js

@@ -1,51 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-export const alphabet = new TextEncoder().encode("0123456789abcdef");
-export const rAlphabet = new Uint8Array(128).fill(16); // alphabet.Hex.length
-alphabet.forEach((byte, i) => rAlphabet[byte] = i);
-new TextEncoder()
-    .encode("ABCDEF")
-    .forEach((byte, i) => rAlphabet[byte] = i + 10);
-/**
- * Calculate the output size needed to encode a given input size for
- * {@linkcode encodeIntoHex}.
- *
- * @param originalSize The size of the input buffer.
- * @returns The size of the output buffer.
- *
- * @example Basic Usage
- * ```ts
- * import { assertEquals } from "@std/assert";
- * import { calcSizeHex } from "@std/encoding/unstable-hex";
- *
- * assertEquals(calcSizeHex(1), 2);
- * ```
- */
-export function calcSizeHex(originalSize) {
-    return originalSize * 2;
-}
-export function encode(buffer, i, o, alphabet) {
-    for (; i < buffer.length; ++i) {
-        const x = buffer[i];
-        buffer[o++] = alphabet[x >> 4];
-        buffer[o++] = alphabet[x & 0xF];
-    }
-    return o;
-}
-export function decode(buffer, i, o, alphabet) {
-    if ((buffer.length - o) % 2 === 1) {
-        throw new RangeError(`Cannot decode input as hex: Length (${buffer.length - o}) must be divisible by 2`);
-    }
-    i += 1;
-    for (; i < buffer.length; i += 2) {
-        buffer[o++] = (getByte(buffer[i - 1], alphabet) << 4) |
-            getByte(buffer[i], alphabet);
-    }
-    return o;
-}
-function getByte(char, alphabet) {
-    const byte = alphabet[char] ?? 16;
-    if (byte === 16) { // alphabet.Hex.length
-        throw new TypeError(`Cannot decode input as hex: Invalid character (${String.fromCharCode(char)})`);
-    }
-    return byte;
-}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common_detach.js

@@ -1,13 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-export function detach(buffer, maxSize) {
-    const originalSize = buffer.length;
-    if (buffer.byteOffset) {
-        const b = new Uint8Array(buffer.buffer);
-        b.set(buffer);
-        buffer = b.subarray(0, originalSize);
-    }
-    // deno-lint-ignore no-explicit-any
-    buffer = new Uint8Array(buffer.buffer.transfer(maxSize));
-    buffer.set(buffer.subarray(0, originalSize), maxSize - originalSize);
-    return [buffer, maxSize - originalSize];
-}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_types.js

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

package/esm/deps/jsr.io/@std/encoding/1.0.10/hex.js

@@ -1,87 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// https://github.com/golang/go/blob/master/LICENSE
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Port of the Go
- * {@link https://github.com/golang/go/blob/go1.12.5/src/encoding/hex/hex.go | encoding/hex}
- * library.
- *
- * ```ts
- * import {
- *   decodeHex,
- *   encodeHex,
- * } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeHex("abc"), "616263");
- *
- * assertEquals(
- *   decodeHex("616263"),
- *   new TextEncoder().encode("abc"),
- * );
- * ```
- *
- * @module
- */
-import { calcSizeHex, decode, encode } from "./_common16.js";
-import { detach } from "./_common_detach.js";
-const alphabet = new TextEncoder()
-    .encode("0123456789abcdef");
-const rAlphabet = new Uint8Array(128).fill(16); // alphabet.length
-alphabet.forEach((byte, i) => rAlphabet[byte] = i);
-new TextEncoder()
-    .encode("ABCDEF")
-    .forEach((byte, i) => rAlphabet[byte] = i + 10);
-/**
- * Converts data into a hex-encoded string.
- *
- * @param src The data to encode.
- *
- * @returns The hex-encoded string.
- *
- * @example Usage
- * ```ts
- * import { encodeHex } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeHex("abc"), "616263");
- * ```
- */
-export function encodeHex(src) {
-    if (typeof src === "string") {
-        src = new TextEncoder().encode(src);
-    }
-    else if (src instanceof ArrayBuffer)
-        src = new Uint8Array(src).slice();
-    else
-        src = src.slice();
-    const [output, i] = detach(src, calcSizeHex(src.length));
-    encode(output, i, 0, alphabet);
-    return new TextDecoder().decode(output);
-}
-/**
- * Decodes the given hex-encoded string. If the input is malformed, an error is
- * thrown.
- *
- * @param src The hex-encoded string to decode.
- *
- * @returns The decoded data.
- *
- * @example Usage
- * ```ts
- * import { decodeHex } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(
- *   decodeHex("616263"),
- *   new TextEncoder().encode("abc"),
- * );
- * ```
- */
-export function decodeHex(src) {
-    const output = new TextEncoder().encode(src);
-    // deno-lint-ignore no-explicit-any
-    return new Uint8Array(output.buffer
-        .transfer(decode(output, 0, 0, rAlphabet)));
-}