glotto 1.0.2 → 2.9.0

package/esm/deps/jsr.io/@std/cli/1.0.29/unstable_spinner.d.ts

@@ -0,0 +1,176 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * This is a hack to allow us to use the same type for both the color name and
+ * an ANSI escape code.
+ *
+ * @see {@link https://github.com/microsoft/TypeScript/issues/29729#issuecomment-460346421}
+ *
+ * @internal
+ */
+export type Ansi = string & {};
+/**
+ * Color options for {@linkcode SpinnerOptions.color}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export type Color = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | Ansi;
+/**
+ * Options for {@linkcode Spinner}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export interface SpinnerOptions {
+    /**
+     * The sequence of characters to be iterated through for animation.
+     *
+     * @default {["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]}
+     */
+    spinner?: string[];
+    /**
+     * The message to display next to the spinner. This can be changed while the
+     * spinner is active.
+     */
+    message?: string;
+    /**
+     * The time between each frame of the spinner in milliseconds.
+     *
+     * @default {75}
+     */
+    interval?: number;
+    /**
+     * The color of the spinner. Defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     */
+    color?: Color;
+    /**
+     * The stream to write the spinner to.
+     *
+     * @default {Deno.stdout}
+     */
+    output?: typeof dntShim.Deno.stderr | typeof dntShim.Deno.stdout;
+}
+/**
+ * A spinner that can be used to indicate that something is loading.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { Spinner } from "@std/cli/unstable-spinner";
+ *
+ * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+ * spinner.start();
+ *
+ * setTimeout(() => {
+ *  spinner.stop();
+ *  console.log("Finished loading!");
+ * }, 3_000);
+ *
+ * // You can also use the spinner with `Deno.stderr`
+ * const spinner2 = new Spinner({ message: "Loading...", color: "yellow", output: Deno.stderr });
+ * spinner2.start();
+ *
+ * setTimeout(() => {
+ *  spinner2.stop();
+ *  console.error("Finished loading!");
+ * }, 3_000);
+ * ```
+ */
+export declare class Spinner {
+    #private;
+    /**
+     * The message to display next to the spinner.
+     * This can be changed while the spinner is active.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Working..." });
+     * spinner.start();
+     *
+     * for (let step = 0; step < 5; step++) {
+     *   // do some work
+     *   await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     *   spinner.message = `Finished Step #${step}`;
+     * }
+     *
+     * spinner.stop();
+     * console.log("Done!");
+     * ```
+     */
+    message: string;
+    /**
+     * Creates a new spinner.
+     *
+     * @param options Options for the spinner.
+     */
+    constructor(options?: SpinnerOptions);
+    /**
+     * Set the color of the spinner. This defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     *
+     * Providing `undefined` will use the default terminal color.
+     *
+     * @param value Color to set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+     * spinner.start();
+     *
+     * // do some work
+     * await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     * spinner.color = "magenta";
+     * ```
+     */
+    set color(value: Color | undefined);
+    /**
+     * Get the current color of the spinner.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading", color: "blue" });
+     *
+     * spinner.color; // Blue ANSI escape sequence
+     * ```
+     * @returns The color of the spinner or `undefined` if it's using the terminal default.
+     */
+    get color(): Color | undefined;
+    /**
+     * Starts the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     * ```
+     */
+    start(): void;
+    /**
+     * Stops the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     *
+     * setTimeout(() => {
+     *  spinner.stop();
+     *  console.log("Finished loading!");
+     * }, 3_000);
+     * ```
+     */
+    stop(): void;
+}
+//# sourceMappingURL=unstable_spinner.d.ts.map

package/esm/deps/jsr.io/@std/cli/1.0.29/unstable_spinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstable_spinner.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cli/1.0.29/unstable_spinner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAUxD;;;;;;;GAOG;AAEH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,EAAE,CAAC;AAE/B;;;;GAIG;AACH,MAAM,MAAM,KAAK,GACb,OAAO,GACP,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,IAAI,CAAC;AAcT;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,OAAO;;IAGlB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,EAAE,MAAM,CAAC;IAOhB;;;;OAIG;gBACS,OAAO,CAAC,EAAE,cAAc;IAcpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAEjC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,KAAK,IAAI,KAAK,GAAG,SAAS,CAE7B;IAED;;;;;;;;;;OAUG;IACH,KAAK;IA4BL;;;;;;;;;;;;;;;OAeG;IACH,IAAI;CAML"}

package/esm/deps/jsr.io/@std/cli/1.0.29/unstable_spinner.js

@@ -0,0 +1,202 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Spinner_spinner, _Spinner_interval, _Spinner_color, _Spinner_intervalId, _Spinner_output;
+// Copyright 2018-2026 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+const encoder = new TextEncoder();
+const LINE_CLEAR = encoder.encode("\r\u001b[K"); // From cli/prompt_secret.ts
+const COLOR_RESET = "\u001b[0m";
+const DEFAULT_INTERVAL = 75;
+const DEFAULT_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const COLORS = {
+    black: "\u001b[30m",
+    red: "\u001b[31m",
+    green: "\u001b[32m",
+    yellow: "\u001b[33m",
+    blue: "\u001b[34m",
+    magenta: "\u001b[35m",
+    cyan: "\u001b[36m",
+    white: "\u001b[37m",
+    gray: "\u001b[90m",
+};
+/**
+ * A spinner that can be used to indicate that something is loading.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { Spinner } from "@std/cli/unstable-spinner";
+ *
+ * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+ * spinner.start();
+ *
+ * setTimeout(() => {
+ *  spinner.stop();
+ *  console.log("Finished loading!");
+ * }, 3_000);
+ *
+ * // You can also use the spinner with `Deno.stderr`
+ * const spinner2 = new Spinner({ message: "Loading...", color: "yellow", output: Deno.stderr });
+ * spinner2.start();
+ *
+ * setTimeout(() => {
+ *  spinner2.stop();
+ *  console.error("Finished loading!");
+ * }, 3_000);
+ * ```
+ */
+export class Spinner {
+    /**
+     * Creates a new spinner.
+     *
+     * @param options Options for the spinner.
+     */
+    constructor(options) {
+        _Spinner_spinner.set(this, void 0);
+        /**
+         * The message to display next to the spinner.
+         * This can be changed while the spinner is active.
+         *
+         * @example Usage
+         * ```ts ignore
+         * import { Spinner } from "@std/cli/unstable-spinner";
+         *
+         * const spinner = new Spinner({ message: "Working..." });
+         * spinner.start();
+         *
+         * for (let step = 0; step < 5; step++) {
+         *   // do some work
+         *   await new Promise((resolve) => setTimeout(resolve, 1000));
+         *
+         *   spinner.message = `Finished Step #${step}`;
+         * }
+         *
+         * spinner.stop();
+         * console.log("Done!");
+         * ```
+         */
+        Object.defineProperty(this, "message", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _Spinner_interval.set(this, void 0);
+        _Spinner_color.set(this, void 0);
+        _Spinner_intervalId.set(this, null);
+        _Spinner_output.set(this, void 0);
+        const { spinner = DEFAULT_SPINNER, message = "", interval = DEFAULT_INTERVAL, color, } = options ?? {};
+        __classPrivateFieldSet(this, _Spinner_spinner, spinner, "f");
+        this.message = message;
+        __classPrivateFieldSet(this, _Spinner_interval, interval, "f");
+        __classPrivateFieldSet(this, _Spinner_output, options?.output ?? dntShim.Deno.stdout, "f");
+        this.color = color;
+    }
+    /**
+     * Set the color of the spinner. This defaults to the default terminal color.
+     * This can be changed while the spinner is active.
+     *
+     * Providing `undefined` will use the default terminal color.
+     *
+     * @param value Color to set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading...", color: "yellow" });
+     * spinner.start();
+     *
+     * // do some work
+     * await new Promise((resolve) => setTimeout(resolve, 1000));
+     *
+     * spinner.color = "magenta";
+     * ```
+     */
+    set color(value) {
+        __classPrivateFieldSet(this, _Spinner_color, value ? COLORS[value] : undefined, "f");
+    }
+    /**
+     * Get the current color of the spinner.
+     *
+     * @example Usage
+     * ```ts no-assert
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading", color: "blue" });
+     *
+     * spinner.color; // Blue ANSI escape sequence
+     * ```
+     * @returns The color of the spinner or `undefined` if it's using the terminal default.
+     */
+    get color() {
+        return __classPrivateFieldGet(this, _Spinner_color, "f");
+    }
+    /**
+     * Starts the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     * ```
+     */
+    start() {
+        if (__classPrivateFieldGet(this, _Spinner_intervalId, "f") !== null || __classPrivateFieldGet(this, _Spinner_output, "f").writable.locked) {
+            return;
+        }
+        let i = 0;
+        const noColor = dntShim.Deno.noColor;
+        // Updates the spinner after the given interval.
+        const updateFrame = () => {
+            const color = __classPrivateFieldGet(this, _Spinner_color, "f") ?? "";
+            const frame = encoder.encode(noColor
+                ? __classPrivateFieldGet(this, _Spinner_spinner, "f")[i] + " " + this.message
+                : color + __classPrivateFieldGet(this, _Spinner_spinner, "f")[i] + COLOR_RESET + " " + this.message);
+            // call writeSync once to reduce flickering
+            const writeData = new Uint8Array(LINE_CLEAR.length + frame.length);
+            writeData.set(LINE_CLEAR);
+            writeData.set(frame, LINE_CLEAR.length);
+            __classPrivateFieldGet(this, _Spinner_output, "f").writeSync(writeData);
+            i = (i + 1) % __classPrivateFieldGet(this, _Spinner_spinner, "f").length;
+        };
+        __classPrivateFieldSet(this, _Spinner_intervalId, setInterval(updateFrame, __classPrivateFieldGet(this, _Spinner_interval, "f")), "f");
+        updateFrame();
+    }
+    /**
+     * Stops the spinner.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { Spinner } from "@std/cli/unstable-spinner";
+     *
+     * const spinner = new Spinner({ message: "Loading..." });
+     * spinner.start();
+     *
+     * setTimeout(() => {
+     *  spinner.stop();
+     *  console.log("Finished loading!");
+     * }, 3_000);
+     * ```
+     */
+    stop() {
+        if (__classPrivateFieldGet(this, _Spinner_intervalId, "f") === null)
+            return;
+        clearInterval(__classPrivateFieldGet(this, _Spinner_intervalId, "f"));
+        __classPrivateFieldSet(this, _Spinner_intervalId, null, "f");
+        __classPrivateFieldGet(this, _Spinner_output, "f").writeSync(LINE_CLEAR); // Clear the current line
+    }
+}
+_Spinner_spinner = new WeakMap(), _Spinner_interval = new WeakMap(), _Spinner_color = new WeakMap(), _Spinner_intervalId = new WeakMap(), _Spinner_output = new WeakMap();

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

@@ -0,0 +1,23 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+export declare const alphabet: Uint8Array<ArrayBufferLike>;
+export declare const rAlphabet: Uint8Array<ArrayBuffer>;
+/**
+ * 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 declare function calcSizeHex(originalSize: number): number;
+export declare function encode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;
+export declare function decode(buffer: Uint8Array_, i: number, o: number, alphabet: Uint8Array): number;
+//# sourceMappingURL=_common16.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_common16.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common16.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B,eAAO,MAAM,QAAQ,6BAA+C,CAAC;AACrE,eAAO,MAAM,SAAS,yBAA+B,CAAC;AAMtD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,GACnB,MAAM,CAOR;AAED,wBAAgB,MAAM,CACpB,MAAM,EAAE,WAAW,EACnB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,UAAU,GACnB,MAAM,CAeR"}

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/_common32.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<Base32Alphabet, Uint8Array>;
+export declare const rAlphabet: Record<Base32Alphabet, Uint8Array>;
+/**
+ * Options for encoding and decoding base32 strings.
+ */
+export interface Base32Options {
+    /** The base32 alphabet. Defaults to "base32" */
+    alphabet?: Base32Alphabet;
+}
+/**
+ * The base32 alphabets.
+ */
+export type Base32Alphabet = "base32" | "base32hex" | "base32crockford";
+/**
+ * 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 declare function calcSizeBase32(rawSize: 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=_common32.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"_common32.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.10/_common32.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,CAIvD,CAAC;AACF,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,CAIxD,CAAC;AAQF;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,WAAW,GAAG,iBAAiB,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;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,CAmER;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,CAyFR"}