glotto 2.9.0 → 3.0.0

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

@@ -1,72 +0,0 @@
-// 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-5 | base64url}
- * encoding and decoding.
- *
- * @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);
-/**
- * Convert data into a base64url-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
- *
- * @param data The data to encode.
- * @returns The base64url-encoded string.
- *
- * @example Usage
- * ```ts
- * import { encodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeBase64Url("foobar"), "Zm9vYmFy");
- * ```
- */
-export function encodeBase64Url(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));
-    let o = encode(output, i, 0, alphabet, padding);
-    o = output.indexOf(padding, o - 2);
-    return new TextDecoder().decode(
-    // deno-lint-ignore no-explicit-any
-    o > 0 ? new Uint8Array(output.buffer.transfer(o)) : output);
-}
-/**
- * Decodes a given base64url-encoded string.
- *
- * @see {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5}
- *
- * @param b64url The base64url-encoded string to decode.
- * @returns The decoded data.
- *
- * @example Usage
- * ```ts
- * import { decodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(
- *   decodeBase64Url("Zm9vYmFy"),
- *   new TextEncoder().encode("foobar")
- * );
- * ```
- */
-export function decodeBase64Url(b64url) {
-    const output = new TextEncoder().encode(b64url);
-    // 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/hex.d.ts

@@ -1,39 +0,0 @@
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-/**
- * 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 declare function encodeHex(src: string | Uint8Array | ArrayBuffer): string;
-/**
- * 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 declare function decodeHex(src: string): Uint8Array_;
-//# sourceMappingURL=hex.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/hex.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAU5B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAWxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAKlD"}

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)));
-}

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

@@ -1,98 +0,0 @@
-/**
- * Utilities for encoding and decoding common formats like hex, base64, and varint.
- *
- * ## Basic Usage
- *
- * ```ts
- * import { encodeBase64, decodeBase64 } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * const foobar = new TextEncoder().encode("foobar");
- * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
- * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
- * ```
- *
- * ## Various Encoding Formats
- *
- * ```ts
- * import {
- *   encodeHex,
- *   encodeBase32,
- *   encodeBase58,
- *   encodeBase64,
- *   encodeAscii85,
- *   decodeHex,
- *   decodeBase32,
- *   decodeBase58,
- *   decodeBase64,
- *   decodeAscii85,
- * } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Many different encodings for different character sets
- * assertEquals(encodeHex("Hello world!"), "48656c6c6f20776f726c6421");
- * assertEquals(encodeBase32("Hello world!"), "JBSWY3DPEB3W64TMMQQQ====");
- * assertEquals(encodeBase58("Hello world!"), "2NEpo7TZRhna7vSvL");
- * assertEquals(encodeBase64("Hello world!"), "SGVsbG8gd29ybGQh");
- * assertEquals(encodeAscii85("Hello world!"), "87cURD]j7BEbo80");
- *
- * // Decoding
- * assertEquals(new TextDecoder().decode(decodeHex("48656c6c6f20776f726c6421")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase32("JBSWY3DPEB3W64TMMQQQ====")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase58("2NEpo7TZRhna7vSvL")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase64("SGVsbG8gd29ybGQh")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeAscii85("87cURD]j7BEbo80")), "Hello world!");
- * ```
- *
- * ## URL-Safe Base64
- *
- * ```ts
- * import { encodeBase64, encodeBase64Url } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeBase64("ice creams"), "aWNlIGNyZWFtcw=="); // Not url-safe because of `=`
- * assertEquals(encodeBase64Url("ice creams"), "aWNlIGNyZWFtcw"); // URL-safe!
- *
- * // Base64Url replaces + with - and / with _
- * assertEquals(encodeBase64("subjects?"), "c3ViamVjdHM/"); // slash is not URL-safe
- * assertEquals(encodeBase64Url("subjects?"), "c3ViamVjdHM_"); // _ is URL-safe
- * ```
- *
- * ## Binary Data Encoding
- *
- * ```ts
- * import { encodeHex, encodeBase64 } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Working with binary data
- * const binaryData = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
- * assertEquals(encodeHex(binaryData), "deadbeef");
- * assertEquals(encodeBase64(binaryData), "3q2+7w==");
- * ```
- *
- * ## Varint Encoding
- *
- * Learn more from the [protobuf Varint encoding docs](https://protobuf.dev/programming-guides/encoding/#varints).
- *
- * ```ts
- * import { encodeVarint, decodeVarint } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Varint encoding support
- * assertEquals(encodeVarint(9601n), [new Uint8Array([129, 75]), 2]);
- *
- * // Decode a varint
- * const bytes = new Uint8Array([129, 75]);
- * assertEquals(decodeVarint(bytes), [9601n, 2]);
- * ```
- *
- * @module
- */
-export * from "./ascii85.js";
-export * from "./base32.js";
-export * from "./base58.js";
-export * from "./base64.js";
-export * from "./base64url.js";
-export * from "./hex.js";
-export * from "./varint.js";
-//# sourceMappingURL=mod.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

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

@@ -1,99 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-/**
- * Utilities for encoding and decoding common formats like hex, base64, and varint.
- *
- * ## Basic Usage
- *
- * ```ts
- * import { encodeBase64, decodeBase64 } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * const foobar = new TextEncoder().encode("foobar");
- * assertEquals(encodeBase64(foobar), "Zm9vYmFy");
- * assertEquals(decodeBase64("Zm9vYmFy"), foobar);
- * ```
- *
- * ## Various Encoding Formats
- *
- * ```ts
- * import {
- *   encodeHex,
- *   encodeBase32,
- *   encodeBase58,
- *   encodeBase64,
- *   encodeAscii85,
- *   decodeHex,
- *   decodeBase32,
- *   decodeBase58,
- *   decodeBase64,
- *   decodeAscii85,
- * } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Many different encodings for different character sets
- * assertEquals(encodeHex("Hello world!"), "48656c6c6f20776f726c6421");
- * assertEquals(encodeBase32("Hello world!"), "JBSWY3DPEB3W64TMMQQQ====");
- * assertEquals(encodeBase58("Hello world!"), "2NEpo7TZRhna7vSvL");
- * assertEquals(encodeBase64("Hello world!"), "SGVsbG8gd29ybGQh");
- * assertEquals(encodeAscii85("Hello world!"), "87cURD]j7BEbo80");
- *
- * // Decoding
- * assertEquals(new TextDecoder().decode(decodeHex("48656c6c6f20776f726c6421")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase32("JBSWY3DPEB3W64TMMQQQ====")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase58("2NEpo7TZRhna7vSvL")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeBase64("SGVsbG8gd29ybGQh")), "Hello world!");
- * assertEquals(new TextDecoder().decode(decodeAscii85("87cURD]j7BEbo80")), "Hello world!");
- * ```
- *
- * ## URL-Safe Base64
- *
- * ```ts
- * import { encodeBase64, encodeBase64Url } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(encodeBase64("ice creams"), "aWNlIGNyZWFtcw=="); // Not url-safe because of `=`
- * assertEquals(encodeBase64Url("ice creams"), "aWNlIGNyZWFtcw"); // URL-safe!
- *
- * // Base64Url replaces + with - and / with _
- * assertEquals(encodeBase64("subjects?"), "c3ViamVjdHM/"); // slash is not URL-safe
- * assertEquals(encodeBase64Url("subjects?"), "c3ViamVjdHM_"); // _ is URL-safe
- * ```
- *
- * ## Binary Data Encoding
- *
- * ```ts
- * import { encodeHex, encodeBase64 } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Working with binary data
- * const binaryData = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
- * assertEquals(encodeHex(binaryData), "deadbeef");
- * assertEquals(encodeBase64(binaryData), "3q2+7w==");
- * ```
- *
- * ## Varint Encoding
- *
- * Learn more from the [protobuf Varint encoding docs](https://protobuf.dev/programming-guides/encoding/#varints).
- *
- * ```ts
- * import { encodeVarint, decodeVarint } from "@std/encoding";
- * import { assertEquals } from "@std/assert";
- *
- * // Varint encoding support
- * assertEquals(encodeVarint(9601n), [new Uint8Array([129, 75]), 2]);
- *
- * // Decode a varint
- * const bytes = new Uint8Array([129, 75]);
- * assertEquals(decodeVarint(bytes), [9601n, 2]);
- * ```
- *
- * @module
- */
-export * from "./ascii85.js";
-export * from "./base32.js";
-export * from "./base58.js";
-export * from "./base64.js";
-export * from "./base64url.js";
-export * from "./hex.js";
-export * from "./varint.js";

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

@@ -1,120 +0,0 @@
-/**
- * Utilities for {@link https://protobuf.dev/programming-guides/encoding/#varints Varint} encoding
- * of typed integers. Varint encoding represents integers using a variable number of bytes, with
- * smaller values requiring fewer bytes.
- *
- * ```ts
- * import { encodeVarint, decodeVarint } from "@std/encoding/varint";
- * import { assertEquals } from "@std/assert";
- *
- * const buf = new Uint8Array(10);
- * assertEquals(
- *   encodeVarint(42n, buf),
- *   [new Uint8Array([42]), 1]
- * );
- *
- * assertEquals(
- *   decodeVarint(new Uint8Array([42])),
- *   [ 42n, 1 ]
- * );
- * ```
- *
- * @module
- */
-import type { Uint8Array_ } from "./_types.js";
-export type { Uint8Array_ };
-/**
- * The maximum value of an unsigned 64-bit integer.
- * Equivalent to `2n**64n - 1n`
- */
-export declare const MaxUint64 = 18446744073709551615n;
-/**
- * The maximum length, in bytes, of a Varint encoded 64-bit integer.
- */
-export declare const MaxVarintLen64 = 10;
-/**
- * The maximum length, in bytes, of a Varint encoded 32-bit integer.
- */
-export declare const MaxVarintLen32 = 5;
-/**
- * Given a non empty `buf`, starting at `offset` (default: 0), begin decoding bytes as
- * Varint encoded bytes, for a maximum of 10 bytes (offset + 10). The returned
- * tuple is of the decoded varint 32-bit number, and the new offset with which
- * to continue decoding other data.
- *
- * If a `bigint` in return is undesired, the `decode32` function will return a
- * `number`, but this should only be used in cases where the varint is
- * _assured_ to be 32-bits. If in doubt, use `decode()`.
- *
- * To know how many bytes the Varint took to encode, simply negate `offset`
- * from the returned new `offset`.
- *
- * @param buf The buffer to decode from.
- * @param offset The offset to start decoding from.
- * @returns A tuple of the decoded varint 64-bit number, and the new offset.
- *
- * @example Usage
- * ```ts
- * import { decodeVarint } from "@std/encoding/varint";
- * import { assertEquals } from "@std/assert";
- *
- * const buf = new Uint8Array([0x8E, 0x02]);
- * assertEquals(decodeVarint(buf), [270n, 2]);
- * ```
- */
-export declare function decodeVarint(buf: Uint8Array, offset?: number): [bigint, number];
-/**
- * Given a `buf`, starting at `offset` (default: 0), begin decoding bytes as
- * Varint encoded bytes, for a maximum of 5 bytes (offset + 5). The returned
- * tuple is of the decoded varint 32-bit number, and the new offset with which
- * to continue decoding other data.
- *
- * Varints are _not 32-bit by default_ so this should only be used in cases
- * where the varint is _assured_ to be 32-bits. If in doubt, use `decode()`.
- *
- * To know how many bytes the Varint took to encode, simply negate `offset`
- * from the returned new `offset`.
- *
- * @param buf The buffer to decode from.
- * @param offset The offset to start decoding from.
- * @returns A tuple of the decoded varint 32-bit number, and the new offset.
- *
- * @example Usage
- * ```ts
- * import { decodeVarint32 } from "@std/encoding/varint";
- * import { assertEquals } from "@std/assert";
- *
- * const buf = new Uint8Array([0x8E, 0x02]);
- * assertEquals(decodeVarint32(buf), [270, 2]);
- * ```
- */
-export declare function decodeVarint32(buf: Uint8Array, offset?: number): [number, number];
-/**
- * Takes unsigned number `num` and converts it into a Varint encoded
- * `Uint8Array`, returning a tuple consisting of a `Uint8Array` slice of the
- * encoded Varint, and an offset where the Varint encoded bytes end within the
- * `Uint8Array`.
- *
- * If `buf` is not given then a Uint8Array will be created.
- * `offset` defaults to `0`.
- *
- * If passed `buf` then that will be written into, starting at `offset`. The
- * resulting returned `Uint8Array` will be a slice of `buf`. The resulting
- * returned number is effectively `offset + bytesWritten`.
- *
- * @param num The number to encode.
- * @param buf The buffer to write into.
- * @param offset The offset to start writing at.
- * @returns A tuple of the encoded Varint `Uint8Array` and the new offset.
- *
- * @example Usage
- * ```ts
- * import { encodeVarint } from "@std/encoding/varint";
- * import { assertEquals } from "@std/assert";
- *
- * const buf = new Uint8Array(10);
- * assertEquals(encodeVarint(42n, buf), [new Uint8Array([42]), 1]);
- * ```
- */
-export declare function encodeVarint(num: bigint | number, buf?: Uint8Array, offset?: number): [Uint8Array_, number];
-//# sourceMappingURL=varint.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"varint.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/varint.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;GAGG;AACH,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC;;GAEG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAahC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA6D1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAe5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,GAAG,GAAE,UAA2C,EAChD,MAAM,SAAI,GACT,CAAC,WAAW,EAAE,MAAM,CAAC,CAuBvB"}