git-remote-ops 0.1.0

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

@@ -0,0 +1,46 @@
+// 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

@@ -0,0 +1,132 @@
+// 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

@@ -0,0 +1,270 @@
+// 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

@@ -0,0 +1,23 @@
+// 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

@@ -0,0 +1,61 @@
+// 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

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,13 @@
+// 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

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

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

@@ -0,0 +1,87 @@
+// 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)));
+}