glotto 1.0.2 → 2.9.0

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

@@ -0,0 +1,192 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export const padding = "=".charCodeAt(0);
+export const alphabet = {
+    base32: new TextEncoder().encode("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"),
+    base32hex: new TextEncoder().encode("0123456789ABCDEFGHIJKLMNOPQRSTUV"),
+    base32crockford: new TextEncoder().encode("0123456789ABCDEFGHJKMNPQRSTVWXYZ"),
+};
+export const rAlphabet = {
+    base32: new Uint8Array(128).fill(32), // alphabet.base32.length
+    base32hex: new Uint8Array(128).fill(32),
+    base32crockford: new Uint8Array(128).fill(32),
+};
+alphabet.base32
+    .forEach((byte, i) => rAlphabet.base32[byte] = i);
+alphabet.base32hex
+    .forEach((byte, i) => rAlphabet.base32hex[byte] = i);
+alphabet.base32crockford
+    .forEach((byte, i) => rAlphabet.base32crockford[byte] = i);
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoBase32}.
+ *
+ * @param rawSize The size of the input buffer.
+ * @returns The size of the output buffer.
+ *
+ * @example Basic Usage
+ * ```ts
+ * import { assertEquals } from "@std/assert";
+ * import { calcSizeBase32 } from "@std/encoding/unstable-base32";
+ *
+ * assertEquals(calcSizeBase32(1), 8);
+ * ```
+ */
+export function calcSizeBase32(rawSize) {
+    return ((rawSize + 4) / 5 | 0) * 8;
+}
+export function encode(buffer, i, o, alphabet, padding) {
+    i += 4;
+    for (; i < buffer.length; i += 5) {
+        let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
+        buffer[o++] = alphabet[x >> 19];
+        buffer[o++] = alphabet[x >> 14 & 0x1F];
+        buffer[o++] = alphabet[x >> 9 & 0x1F];
+        buffer[o++] = alphabet[x >> 4 & 0x1F];
+        x = (x << 16) | (buffer[i - 1] << 8) | buffer[i];
+        buffer[o++] = alphabet[x >> 15 & 0x1F];
+        buffer[o++] = alphabet[x >> 10 & 0x1F];
+        buffer[o++] = alphabet[x >> 5 & 0x1F];
+        buffer[o++] = alphabet[x & 0x1F];
+    }
+    switch (i) {
+        case buffer.length + 3: {
+            const x = buffer[i - 4] << 16;
+            buffer[o++] = alphabet[x >> 19];
+            buffer[o++] = alphabet[x >> 14 & 0x1F];
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            break;
+        }
+        case buffer.length + 2: {
+            const x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8);
+            buffer[o++] = alphabet[x >> 19];
+            buffer[o++] = alphabet[x >> 14 & 0x1F];
+            buffer[o++] = alphabet[x >> 9 & 0x1F];
+            buffer[o++] = alphabet[x >> 4 & 0x1F];
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            break;
+        }
+        case buffer.length + 1: {
+            let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
+            buffer[o++] = alphabet[x >> 19];
+            buffer[o++] = alphabet[x >> 14 & 0x1F];
+            buffer[o++] = alphabet[x >> 9 & 0x1F];
+            buffer[o++] = alphabet[x >> 4 & 0x1F];
+            x <<= 16;
+            buffer[o++] = alphabet[x >> 15 & 0x1F];
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            break;
+        }
+        case buffer.length: {
+            let x = (buffer[i - 4] << 16) | (buffer[i - 3] << 8) | buffer[i - 2];
+            buffer[o++] = alphabet[x >> 19];
+            buffer[o++] = alphabet[x >> 14 & 0x1F];
+            buffer[o++] = alphabet[x >> 9 & 0x1F];
+            buffer[o++] = alphabet[x >> 4 & 0x1F];
+            x = (x << 16) | (buffer[i - 1] << 8);
+            buffer[o++] = alphabet[x >> 15 & 0x1F];
+            buffer[o++] = alphabet[x >> 10 & 0x1F];
+            buffer[o++] = alphabet[x >> 5 & 0x1F];
+            buffer[o++] = padding;
+            break;
+        }
+    }
+    return o;
+}
+export function decode(buffer, i, o, alphabet, padding) {
+    for (let x = buffer.length - 6; x < buffer.length; ++x) {
+        if (buffer[x] === padding) {
+            for (let y = x + 1; y < buffer.length; ++y) {
+                if (buffer[y] !== padding) {
+                    throw new TypeError(`Cannot decode input as base32: Invalid character (${String.fromCharCode(buffer[y])})`);
+                }
+            }
+            buffer = buffer.subarray(0, x);
+            break;
+        }
+    }
+    switch ((buffer.length - o) % 8) {
+        case 6:
+        case 3:
+        case 1:
+            throw new RangeError(`Cannot decode input as base32: Length (${buffer.length - o}), excluding padding, must not have a remainder of 1, 3, or 6 when divided by 8`);
+    }
+    i += 7;
+    for (; i < buffer.length; i += 8) {
+        let x = (getByte(buffer[i - 7], alphabet) << 19) |
+            (getByte(buffer[i - 6], alphabet) << 14) |
+            (getByte(buffer[i - 5], alphabet) << 9) |
+            (getByte(buffer[i - 4], alphabet) << 4);
+        buffer[o++] = x >> 16;
+        buffer[o++] = x >> 8 & 0xFF;
+        x = (x << 16) |
+            (getByte(buffer[i - 3], alphabet) << 15) |
+            (getByte(buffer[i - 2], alphabet) << 10) |
+            (getByte(buffer[i - 1], alphabet) << 5) |
+            getByte(buffer[i], alphabet);
+        buffer[o++] = x >> 16 & 0xFF;
+        buffer[o++] = x >> 8 & 0xFF;
+        buffer[o++] = x & 0xFF;
+    }
+    switch (i) {
+        case buffer.length + 5: {
+            const x = (getByte(buffer[i - 7], alphabet) << 19) |
+                (getByte(buffer[i - 6], alphabet) << 14);
+            buffer[o++] = x >> 16;
+            break;
+        }
+        case buffer.length + 3: {
+            const x = (getByte(buffer[i - 7], alphabet) << 19) |
+                (getByte(buffer[i - 6], alphabet) << 14) |
+                (getByte(buffer[i - 5], alphabet) << 9) |
+                (getByte(buffer[i - 4], alphabet) << 4);
+            buffer[o++] = x >> 16;
+            buffer[o++] = x >> 8 & 0xFF;
+            break;
+        }
+        case buffer.length + 2: {
+            let x = (getByte(buffer[i - 7], alphabet) << 19) |
+                (getByte(buffer[i - 6], alphabet) << 14) |
+                (getByte(buffer[i - 5], alphabet) << 9) |
+                (getByte(buffer[i - 4], alphabet) << 4);
+            buffer[o++] = x >> 16;
+            buffer[o++] = x >> 8 & 0xFF;
+            x = (x << 16) |
+                (getByte(buffer[i - 3], alphabet) << 15);
+            buffer[o++] = x >> 16 & 0xFF;
+            break;
+        }
+        case buffer.length: {
+            let x = (getByte(buffer[i - 7], alphabet) << 19) |
+                (getByte(buffer[i - 6], alphabet) << 14) |
+                (getByte(buffer[i - 5], alphabet) << 9) |
+                (getByte(buffer[i - 4], alphabet) << 4);
+            buffer[o++] = x >> 16;
+            buffer[o++] = x >> 8 & 0xFF;
+            x = (x << 16) |
+                (getByte(buffer[i - 3], alphabet) << 15) |
+                (getByte(buffer[i - 2], alphabet) << 10) |
+                (getByte(buffer[i - 1], alphabet) << 5);
+            buffer[o++] = x >> 16 & 0xFF;
+            buffer[o++] = x >> 8 & 0xFF;
+            break;
+        }
+    }
+    return o;
+}
+function getByte(char, alphabet) {
+    const byte = alphabet[char] ?? 32;
+    if (byte === 32) { // alphabet.Base32.length
+        throw new TypeError(`Cannot decode input as base32: Invalid character (${String.fromCharCode(char)})`);
+    }
+    return byte;
+}

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common64.d.ts

@@ -0,0 +1,35 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare const padding: number;
+export declare const alphabet: Record<Base64Alphabet, Uint8Array>;
+export declare const rAlphabet: Record<Base64Alphabet, Uint8Array>;
+/**
+ * Options for encoding and decoding base64 strings.
+ */
+export interface Base64Options {
+    /** The base64 alphabet. Defaults to "base64" */
+    alphabet?: Base64Alphabet;
+}
+/**
+ * The base64 alphabets.
+ */
+export type Base64Alphabet = "base64" | "base64url";
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoBase64}.
+ *
+ * @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 { calcSizeBase64 } from "@std/encoding/unstable-base64";
+ *
+ * assertEquals(calcSizeBase64(1), 4);
+ * ```
+ */
+export declare function calcSizeBase64(originalSize: number): number;
+export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
+export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array, padding: number): number;
+//# sourceMappingURL=_common64.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common64.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,eAAO,MAAM,OAAO,QAAoB,CAAC;AACzC,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAKvD,CAAC;AACF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAGxD,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,GACd,MAAM,CA4BR;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,GACd,MAAM,CAmDR"}

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

@@ -0,0 +1,113 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+export const padding = "=".charCodeAt(0);
+export const alphabet = {
+    base64: new TextEncoder()
+        .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),
+    base64url: new TextEncoder()
+        .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"),
+};
+export const rAlphabet = {
+    base64: new Uint8Array(128).fill(64), // alphabet.base64.length
+    base64url: new Uint8Array(128).fill(64),
+};
+alphabet.base64
+    .forEach((byte, i) => rAlphabet.base64[byte] = i);
+alphabet.base64url
+    .forEach((byte, i) => rAlphabet.base64url[byte] = i);
+/**
+ * Calculate the output size needed to encode a given input size for
+ * {@linkcode encodeIntoBase64}.
+ *
+ * @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 { calcSizeBase64 } from "@std/encoding/unstable-base64";
+ *
+ * assertEquals(calcSizeBase64(1), 4);
+ * ```
+ */
+export function calcSizeBase64(originalSize) {
+    return ((originalSize + 2) / 3 | 0) * 4;
+}
+export function encode(buffer, i, o, alphabet, padding) {
+    i += 2;
+    for (; i < buffer.length; i += 3) {
+        const x = (buffer[i - 2] << 16) | (buffer[i - 1] << 8) | buffer[i];
+        buffer[o++] = alphabet[x >> 18];
+        buffer[o++] = alphabet[x >> 12 & 0x3F];
+        buffer[o++] = alphabet[x >> 6 & 0x3F];
+        buffer[o++] = alphabet[x & 0x3F];
+    }
+    switch (i) {
+        case buffer.length + 1: {
+            const x = buffer[i - 2] << 16;
+            buffer[o++] = alphabet[x >> 18];
+            buffer[o++] = alphabet[x >> 12 & 0x3F];
+            buffer[o++] = padding;
+            buffer[o++] = padding;
+            break;
+        }
+        case buffer.length: {
+            const x = (buffer[i - 2] << 16) | (buffer[i - 1] << 8);
+            buffer[o++] = alphabet[x >> 18];
+            buffer[o++] = alphabet[x >> 12 & 0x3F];
+            buffer[o++] = alphabet[x >> 6 & 0x3F];
+            buffer[o++] = padding;
+            break;
+        }
+    }
+    return o;
+}
+export function decode(buffer, i, o, alphabet, padding) {
+    for (let x = buffer.length - 2; x < buffer.length; ++x) {
+        if (buffer[x] === padding) {
+            for (let y = x + 1; y < buffer.length; ++y) {
+                if (buffer[y] !== padding) {
+                    throw new TypeError(`Cannot decode input as base64: Invalid character (${String.fromCharCode(buffer[y])})`);
+                }
+            }
+            buffer = buffer.subarray(0, x);
+            break;
+        }
+    }
+    if ((buffer.length - o) % 4 === 1) {
+        throw new RangeError(`Cannot decode input as base64: Length (${buffer.length - o}), excluding padding, must not have a remainder of 1 when divided by 4`);
+    }
+    i += 3;
+    for (; i < buffer.length; i += 4) {
+        const x = (getByte(buffer[i - 3], alphabet) << 18) |
+            (getByte(buffer[i - 2], alphabet) << 12) |
+            (getByte(buffer[i - 1], alphabet) << 6) |
+            getByte(buffer[i], alphabet);
+        buffer[o++] = x >> 16;
+        buffer[o++] = x >> 8 & 0xFF;
+        buffer[o++] = x & 0xFF;
+    }
+    switch (i) {
+        case buffer.length + 1: {
+            const x = (getByte(buffer[i - 3], alphabet) << 18) |
+                (getByte(buffer[i - 2], alphabet) << 12);
+            buffer[o++] = x >> 16;
+            break;
+        }
+        case buffer.length: {
+            const x = (getByte(buffer[i - 3], alphabet) << 18) |
+                (getByte(buffer[i - 2], alphabet) << 12) |
+                (getByte(buffer[i - 1], alphabet) << 6);
+            buffer[o++] = x >> 16;
+            buffer[o++] = x >> 8 & 0xFF;
+            break;
+        }
+    }
+    return o;
+}
+function getByte(char, alphabet) {
+    const byte = alphabet[char] ?? 64;
+    if (byte === 64) { // alphabet.Base64.length
+        throw new TypeError(`Cannot decode input as base64: Invalid character (${String.fromCharCode(char)})`);
+    }
+    return byte;
+}

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

@@ -0,0 +1,4 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare function detach(buffer: Uint8Array_, maxSize: number): [Uint8Array_, number];
+//# sourceMappingURL=_common_detach.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/_common_detach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_common_detach.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common_detach.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,MAAM,GACd,CAAC,WAAW,EAAE,MAAM,CAAC,CAWvB"}

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.d.ts.map

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

package/esm/deps/jsr.io/@std/encoding/1.0.10/_validate_binary_like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_validate_binary_like.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_validate_binary_like.ts"],"names":[],"mappings":"AAeA,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,UAAU,CAa9D"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/ascii85.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ascii85.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/ascii85.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAwB5B;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;AAEpE,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAOD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,EACvC,OAAO,GAAE,oBAAyB,GACjC,MAAM,CA6DR;AAED,6CAA6C;AAC7C,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,WAAW,CA4Cb"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/base32.d.ts

@@ -0,0 +1,40 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Converts data into a base32-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @param data The data to encode.
+ * @returns The base32-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase32 } from "@std/encoding/base32";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
+ * ```
+ */
+export declare function encodeBase32(data: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Decodes a base32-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @param b32 The base32-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase32 } from "@std/encoding/base32";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase32("GZRTMMDDGA======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
+ * ```
+ */
+export declare function decodeBase32(b32: string): Uint8Array_;
+//# sourceMappingURL=base32.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.10/base32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/base32.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAQ5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAW5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAUrD"}

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

@@ -0,0 +1,87 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright (c) 2014 Jameson Little. MIT License.
+// This module is browser compatible.
+/**
+ * Utilities for
+ * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6 | base32}
+ * encoding and decoding.
+ *
+ * Modified from {@link https://github.com/beatgammit/base64-js}.
+ *
+ * ```ts
+ * import { encodeBase32, decodeBase32 } from "@std/encoding/base32";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32("foobar"), "MZXW6YTBOI======");
+ *
+ * assertEquals(
+ *   decodeBase32("MZXW6YTBOI======"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ *
+ * @module
+ */
+import { calcSizeBase32, decode, encode } from "./_common32.js";
+import { detach } from "./_common_detach.js";
+const padding = "=".charCodeAt(0);
+const alphabet = new TextEncoder()
+    .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
+const rAlphabet = new Uint8Array(128).fill(32); //alphabet.length
+alphabet.forEach((byte, i) => rAlphabet[byte] = i);
+/**
+ * Converts data into a base32-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @param data The data to encode.
+ * @returns The base32-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase32 } from "@std/encoding/base32";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase32("6c60c0"), "GZRTMMDDGA======");
+ * ```
+ */
+export function encodeBase32(data) {
+    if (typeof data === "string") {
+        data = new TextEncoder().encode(data);
+    }
+    else if (data instanceof ArrayBuffer)
+        data = new Uint8Array(data).slice();
+    else
+        data = data.slice();
+    const [output, i] = detach(data, calcSizeBase32(data.length));
+    encode(output, i, 0, alphabet, padding);
+    return new TextDecoder().decode(output);
+}
+/**
+ * Decodes a base32-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-6}
+ *
+ * @param b32 The base32-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase32 } from "@std/encoding/base32";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase32("GZRTMMDDGA======"),
+ *   new TextEncoder().encode("6c60c0"),
+ * );
+ * ```
+ */
+export function decodeBase32(b32) {
+    const output = new TextEncoder().encode(b32);
+    if (output.length % 8) {
+        throw new TypeError(`Invalid base32 string: length (${output.length}) must be a multiple of 8`);
+    }
+    // deno-lint-ignore no-explicit-any
+    return new Uint8Array(output.buffer
+        .transfer(decode(output, 0, 0, rAlphabet, padding)));
+}

package/esm/deps/jsr.io/@std/encoding/1.0.10/base58.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/base58.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAe5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAgD5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAkDrD"}

package/esm/deps/jsr.io/@std/encoding/1.0.10/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/base64.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAQ5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAW5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAKrD"}

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

@@ -0,0 +1,82 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Utilities for
+ * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4 | base64}
+ * encoding and decoding.
+ *
+ * ```ts
+ * import {
+ *   encodeBase64,
+ *   decodeBase64,
+ * } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const foobar = new TextEncoder().encode("foobar");
+ *
+ * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
+ * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
+ * ```
+ *
+ * @module
+ */
+import { calcSizeBase64, decode, encode } from "./_common64.js";
+import { detach } from "./_common_detach.js";
+const padding = "=".charCodeAt(0);
+const alphabet = new TextEncoder()
+    .encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+const rAlphabet = new Uint8Array(128).fill(64); // alphabet.length
+alphabet.forEach((byte, i) => rAlphabet[byte] = i);
+/**
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
+ * ```
+ */
+export function encodeBase64(data) {
+    if (typeof data === "string") {
+        data = new TextEncoder().encode(data);
+    }
+    else if (data instanceof ArrayBuffer)
+        data = new Uint8Array(data).slice();
+    else
+        data = data.slice();
+    const [output, i] = detach(data, calcSizeBase64(data.length));
+    encode(output, i, 0, alphabet, padding);
+    return new TextDecoder().decode(output);
+}
+/**
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4}
+ *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeBase64 } from "@std/encoding/base64";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeBase64("Zm9vYmFy"),
+ *   new TextEncoder().encode("foobar")
+ * );
+ * ```
+ */
+export function decodeBase64(b64) {
+    const output = new TextEncoder().encode(b64);
+    // deno-lint-ignore no-explicit-any
+    return new Uint8Array(output.buffer
+        .transfer(decode(output, 0, 0, rAlphabet, padding)));
+}

package/esm/deps/jsr.io/@std/encoding/1.0.10/base64url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64url.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/base64url.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAQ5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GACtC,MAAM,CAeR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAK3D"}