glotto 1.0.2 → 2.9.0

package/script/deps/jsr.io/@std/cli/1.0.13/parse_args.js

@@ -1,360 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-const FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
-const LETTER_REGEXP = /[A-Za-z]/;
-const NUMBER_REGEXP = /-?\d+(\.\d*)?(e-?\d+)?$/;
-const HYPHEN_REGEXP = /^(-|--)[^-]/;
-const VALUE_REGEXP = /=(?<value>.+)/;
-const FLAG_NAME_REGEXP = /^--[^=]+$/;
-const SPECIAL_CHAR_REGEXP = /\W/;
-const NON_WHITESPACE_REGEXP = /\S/;
-function isNumber(string) {
-    return NON_WHITESPACE_REGEXP.test(string) && Number.isFinite(Number(string));
-}
-function setNested(object, keys, value, collect = false) {
-    keys = [...keys];
-    const key = keys.pop();
-    keys.forEach((key) => object = (object[key] ??= {}));
-    if (collect) {
-        const v = object[key];
-        if (Array.isArray(v)) {
-            v.push(value);
-            return;
-        }
-        value = v ? [v, value] : [value];
-    }
-    object[key] = value;
-}
-function hasNested(object, keys) {
-    for (const key of keys) {
-        const value = object[key];
-        if (!Object.hasOwn(object, key))
-            return false;
-        object = value;
-    }
-    return true;
-}
-function aliasIsBoolean(aliasMap, booleanSet, key) {
-    const set = aliasMap.get(key);
-    if (set === undefined)
-        return false;
-    for (const alias of set)
-        if (booleanSet.has(alias))
-            return true;
-    return false;
-}
-function isBooleanString(value) {
-    return value === "true" || value === "false";
-}
-function parseBooleanString(value) {
-    return value !== "false";
-}
-/**
- * Take a set of command line arguments, optionally with a set of options, and
- * return an object representing the flags found in the passed arguments.
- *
- * By default, any arguments starting with `-` or `--` are considered boolean
- * flags. If the argument name is followed by an equal sign (`=`) it is
- * considered a key-value pair. Any arguments which could not be parsed are
- * available in the `_` property of the returned object.
- *
- * By default, this module tries to determine the type of all arguments
- * automatically and the return type of this function will have an index
- * signature with `any` as value (`{ [x: string]: any }`).
- *
- * If the `string`, `boolean` or `collect` option is set, the return value of
- * this function will be fully typed and the index signature of the return
- * type will change to `{ [x: string]: unknown }`.
- *
- * Any arguments after `'--'` will not be parsed and will end up in `parsedArgs._`.
- *
- * Numeric-looking arguments will be returned as numbers unless `options.string`
- * or `options.boolean` is set for that argument name.
- *
- * See {@linkcode ParseOptions} for more information.
- *
- * @param args An array of command line arguments.
- * @param options Options for the parse function.
- *
- * @typeParam TArgs Type of result.
- * @typeParam TDoubleDash Used by `TArgs` for the result.
- * @typeParam TBooleans Used by `TArgs` for the result.
- * @typeParam TStrings Used by `TArgs` for the result.
- * @typeParam TCollectable Used by `TArgs` for the result.
- * @typeParam TNegatable Used by `TArgs` for the result.
- * @typeParam TDefaults Used by `TArgs` for the result.
- * @typeParam TAliases Used by `TArgs` for the result.
- * @typeParam TAliasArgNames Used by `TArgs` for the result.
- * @typeParam TAliasNames Used by `TArgs` for the result.
- *
- * @return The parsed arguments.
- *
- * @example Usage
- * ```ts
- * import { parseArgs } from "@std/cli/parse-args";
- * import { assertEquals } from "@std/assert/equals";
- *
- * // For proper use, one should use `parseArgs(Deno.args)`
- * assertEquals(parseArgs(["--foo", "--bar=baz", "./quux.txt"]), {
- *   foo: true,
- *   bar: "baz",
- *   _: ["./quux.txt"],
- * });
- * ```
- *
- * @example `string` and `boolean` options
- *
- * Use `string` and `boolean` options to specify the type of the argument.
- *
- * ```ts
- * import { parseArgs } from "@std/cli/parse-args";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const args = parseArgs(["--foo", "--bar", "baz"], {
- *   boolean: ["foo"],
- *   string: ["bar"],
- * });
- *
- * assertEquals(args, { foo: true, bar: "baz", _: [] });
- * ```
- *
- * @example `collect` option
- *
- * `collect` option tells the parser to treat the option as an array. All
- * values will be collected into one array. If a non-collectable option is used
- * multiple times, the last value is used.
- *
- * ```ts
- * import { parseArgs } from "@std/cli/parse-args";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const args = parseArgs(["--foo", "bar", "--foo", "baz"], {
- *  collect: ["foo"],
- * });
- *
- * assertEquals(args, { foo: ["bar", "baz"], _: [] });
- * ```
- *
- * @example `negatable` option
- *
- * `negatable` option tells the parser to treat the option can be negated by
- * prefixing them with `--no-`, like `--no-config`.
- *
- * ```ts
- * import { parseArgs } from "@std/cli/parse-args";
- * import { assertEquals } from "@std/assert/equals";
- *
- * const args = parseArgs(["--no-foo"], {
- *   boolean: ["foo"],
- *   negatable: ["foo"],
- * });
- *
- * assertEquals(args, { foo: false, _: [] });
- * ```
- */
-function parseArgs(args, options) {
-    const { "--": doubleDash = false, alias = {}, boolean = false, default: defaults = {}, stopEarly = false, string = [], collect = [], negatable = [], unknown: unknownFn = (i) => i, } = options ?? {};
-    const aliasMap = new Map();
-    const booleanSet = new Set();
-    const stringSet = new Set();
-    const collectSet = new Set();
-    const negatableSet = new Set();
-    let allBools = false;
-    if (alias) {
-        for (const [key, value] of Object.entries(alias)) {
-            if (value === undefined) {
-                throw new TypeError("Alias value must be defined");
-            }
-            const aliases = Array.isArray(value) ? value : [value];
-            aliasMap.set(key, new Set(aliases));
-            aliases.forEach((alias) => aliasMap.set(alias, new Set([key, ...aliases.filter((it) => it !== alias)])));
-        }
-    }
-    if (boolean) {
-        if (typeof boolean === "boolean") {
-            allBools = boolean;
-        }
-        else {
-            const booleanArgs = Array.isArray(boolean) ? boolean : [boolean];
-            for (const key of booleanArgs.filter(Boolean)) {
-                booleanSet.add(key);
-                aliasMap.get(key)?.forEach((al) => {
-                    booleanSet.add(al);
-                });
-            }
-        }
-    }
-    if (string) {
-        const stringArgs = Array.isArray(string) ? string : [string];
-        for (const key of stringArgs.filter(Boolean)) {
-            stringSet.add(key);
-            aliasMap.get(key)?.forEach((al) => stringSet.add(al));
-        }
-    }
-    if (collect) {
-        const collectArgs = Array.isArray(collect) ? collect : [collect];
-        for (const key of collectArgs.filter(Boolean)) {
-            collectSet.add(key);
-            aliasMap.get(key)?.forEach((al) => collectSet.add(al));
-        }
-    }
-    if (negatable) {
-        const negatableArgs = Array.isArray(negatable) ? negatable : [negatable];
-        for (const key of negatableArgs.filter(Boolean)) {
-            negatableSet.add(key);
-            aliasMap.get(key)?.forEach((alias) => negatableSet.add(alias));
-        }
-    }
-    const argv = { _: [] };
-    function setArgument(key, value, arg, collect) {
-        if (!booleanSet.has(key) &&
-            !stringSet.has(key) &&
-            !aliasMap.has(key) &&
-            !(allBools && FLAG_NAME_REGEXP.test(arg)) &&
-            unknownFn?.(arg, key, value) === false) {
-            return;
-        }
-        if (typeof value === "string" && !stringSet.has(key)) {
-            value = isNumber(value) ? Number(value) : value;
-        }
-        const collectable = collect && collectSet.has(key);
-        setNested(argv, key.split("."), value, collectable);
-        aliasMap.get(key)?.forEach((key) => {
-            setNested(argv, key.split("."), value, collectable);
-        });
-    }
-    let notFlags = [];
-    // all args after "--" are not parsed
-    const index = args.indexOf("--");
-    if (index !== -1) {
-        notFlags = args.slice(index + 1);
-        args = args.slice(0, index);
-    }
-    argsLoop: for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        const groups = arg.match(FLAG_REGEXP)?.groups;
-        if (groups) {
-            const { doubleDash, negated } = groups;
-            let key = groups.key;
-            let value = groups.value;
-            if (doubleDash) {
-                if (value) {
-                    if (booleanSet.has(key))
-                        value = parseBooleanString(value);
-                    setArgument(key, value, arg, true);
-                    continue;
-                }
-                if (negated) {
-                    if (negatableSet.has(key)) {
-                        setArgument(key, false, arg, false);
-                        continue;
-                    }
-                    key = `no-${key}`;
-                }
-                const next = args[i + 1];
-                if (next) {
-                    if (!booleanSet.has(key) &&
-                        !allBools &&
-                        !next.startsWith("-") &&
-                        (!aliasMap.has(key) || !aliasIsBoolean(aliasMap, booleanSet, key))) {
-                        value = next;
-                        i++;
-                        setArgument(key, value, arg, true);
-                        continue;
-                    }
-                    if (isBooleanString(next)) {
-                        value = parseBooleanString(next);
-                        i++;
-                        setArgument(key, value, arg, true);
-                        continue;
-                    }
-                }
-                value = stringSet.has(key) ? "" : true;
-                setArgument(key, value, arg, true);
-                continue;
-            }
-            const letters = arg.slice(1, -1).split("");
-            for (const [j, letter] of letters.entries()) {
-                const next = arg.slice(j + 2);
-                if (next === "-") {
-                    setArgument(letter, next, arg, true);
-                    continue;
-                }
-                if (LETTER_REGEXP.test(letter)) {
-                    const groups = VALUE_REGEXP.exec(next)?.groups;
-                    if (groups) {
-                        setArgument(letter, groups.value, arg, true);
-                        continue argsLoop;
-                    }
-                    if (NUMBER_REGEXP.test(next)) {
-                        setArgument(letter, next, arg, true);
-                        continue argsLoop;
-                    }
-                }
-                if (letters[j + 1]?.match(SPECIAL_CHAR_REGEXP)) {
-                    setArgument(letter, arg.slice(j + 2), arg, true);
-                    continue argsLoop;
-                }
-                setArgument(letter, stringSet.has(letter) ? "" : true, arg, true);
-            }
-            key = arg.slice(-1);
-            if (key === "-")
-                continue;
-            const nextArg = args[i + 1];
-            if (nextArg) {
-                if (!HYPHEN_REGEXP.test(nextArg) &&
-                    !booleanSet.has(key) &&
-                    (!aliasMap.has(key) || !aliasIsBoolean(aliasMap, booleanSet, key))) {
-                    setArgument(key, nextArg, arg, true);
-                    i++;
-                    continue;
-                }
-                if (isBooleanString(nextArg)) {
-                    const value = parseBooleanString(nextArg);
-                    setArgument(key, value, arg, true);
-                    i++;
-                    continue;
-                }
-            }
-            setArgument(key, stringSet.has(key) ? "" : true, arg, true);
-            continue;
-        }
-        if (unknownFn?.(arg) !== false) {
-            argv._.push(stringSet.has("_") || !isNumber(arg) ? arg : Number(arg));
-        }
-        if (stopEarly) {
-            argv._.push(...args.slice(i + 1));
-            break;
-        }
-    }
-    for (const [key, value] of Object.entries(defaults)) {
-        const keys = key.split(".");
-        if (!hasNested(argv, keys)) {
-            setNested(argv, keys, value);
-            aliasMap.get(key)?.forEach((key) => setNested(argv, key.split("."), value));
-        }
-    }
-    for (const key of booleanSet.keys()) {
-        const keys = key.split(".");
-        if (!hasNested(argv, keys)) {
-            const value = collectSet.has(key) ? [] : false;
-            setNested(argv, keys, value);
-        }
-    }
-    for (const key of stringSet.keys()) {
-        const keys = key.split(".");
-        if (!hasNested(argv, keys) && collectSet.has(key)) {
-            setNested(argv, keys, []);
-        }
-    }
-    if (doubleDash) {
-        argv["--"] = notFlags;
-    }
-    else {
-        argv._.push(...notFlags);
-    }
-    return argv;
-}

package/script/deps/jsr.io/@std/cli/1.0.13/prompt_secret.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt_secret.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cli/1.0.13/prompt_secret.ts"],"names":[],"mappings":"AAoBA,4CAA4C;AAC5C,MAAM,MAAM,mBAAmB,GAAG;IAChC,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,SAAW,EAClB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,GAAG,IAAI,CAuDf"}

package/script/deps/jsr.io/@std/cli/1.0.13/prompt_secret.js

@@ -1,136 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptSecret = promptSecret;
-// Copyright 2018-2025 the Deno authors. MIT license.
-const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
-const input = dntShim.Deno.stdin;
-const output = dntShim.Deno.stdout;
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-const LF = "\n".charCodeAt(0); // ^J - Enter on Linux
-const CR = "\r".charCodeAt(0); // ^M - Enter on macOS and Windows (CRLF)
-const BS = "\b".charCodeAt(0); // ^H - Backspace on Linux and Windows
-const DEL = 0x7f; // ^? - Backspace on macOS
-const CLR = encoder.encode("\r\u001b[K"); // Clear the current line
-const MOVE_LINE_UP = encoder.encode("\r\u001b[1F"); // Move to previous line
-// The `cbreak` option is not supported on Windows
-const setRawOptions = dntShim.Deno.build.os === "windows"
-    ? undefined
-    : { cbreak: true };
-/**
- * Shows the given message and waits for the user's input. Returns the user's input as string.
- * This is similar to `prompt()` but it print user's input as `*` to prevent password from being shown.
- * Use an empty `mask` if you don't want to show any character.
- *
- * @param message The prompt message to show to the user.
- * @param options The options for the prompt.
- * @returns The string that was entered or `null` if stdin is not a TTY.
- *
- * @example Usage
- * ```ts ignore
- * import { promptSecret } from "@std/cli/prompt-secret";
- *
- * const password = promptSecret("Please provide the password:");
- * if (password !== "some-password") {
- *   throw new Error("Access denied");
- * }
- * ```
- */
-function promptSecret(message = "Secret", options) {
-    const { mask = "*", clear } = options ?? {};
-    if (!input.isTerminal()) {
-        return null;
-    }
-    const { columns } = dntShim.Deno.consoleSize();
-    let previousLength = 0;
-    // Make the output consistent with the built-in prompt()
-    message += " ";
-    const callback = !mask ? undefined : (n) => {
-        let line = `${message}${mask.repeat(n)}`;
-        const currentLength = line.length;
-        const charsPastLineLength = line.length % columns;
-        if (line.length > columns) {
-            line = line.slice(-1 * (charsPastLineLength === 0 ? columns : charsPastLineLength));
-        }
-        // If the user has deleted a character
-        if (currentLength < previousLength) {
-            // Then clear the current line.
-            output.writeSync(CLR);
-            if (charsPastLineLength === 0) {
-                // And if there's no characters on the current line, return to previous line.
-                output.writeSync(MOVE_LINE_UP);
-            }
-        }
-        else {
-            // Always jump the cursor back to the beginning of the line unless it's the first character.
-            if (charsPastLineLength !== 1) {
-                output.writeSync(CLR);
-            }
-        }
-        output.writeSync(encoder.encode(line));
-        previousLength = currentLength;
-    };
-    output.writeSync(encoder.encode(message));
-    dntShim.Deno.stdin.setRaw(true, setRawOptions);
-    try {
-        return readLineFromStdinSync(callback);
-    }
-    finally {
-        if (clear) {
-            output.writeSync(CLR);
-        }
-        else {
-            output.writeSync(encoder.encode("\n"));
-        }
-        dntShim.Deno.stdin.setRaw(false);
-    }
-}
-// Slightly modified from Deno's runtime/js/41_prompt.js
-// This implementation immediately break on CR or LF and accept callback.
-// The original version waits LF when CR is received.
-// https://github.com/denoland/deno/blob/e4593873a9c791238685dfbb45e64b4485884174/runtime/js/41_prompt.js#L52-L77
-function readLineFromStdinSync(callback) {
-    const c = new Uint8Array(1);
-    const buf = [];
-    while (true) {
-        const n = input.readSync(c);
-        if (n === null || n === 0) {
-            break;
-        }
-        if (c[0] === CR || c[0] === LF) {
-            break;
-        }
-        if (c[0] === BS || c[0] === DEL) {
-            buf.pop();
-        }
-        else {
-            buf.push(c[0]);
-        }
-        if (callback)
-            callback(buf.length);
-    }
-    return decoder.decode(new Uint8Array(buf));
-}

package/script/deps/jsr.io/@std/cli/1.0.13/unicode_width.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unicode_width.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cli/1.0.13/unicode_width.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/script/deps/jsr.io/@std/cli/1.0.13/unicode_width.js

@@ -1,80 +0,0 @@
-"use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
-// This module is browser compatible.
-// Ported from unicode_width rust crate, Copyright (c) 2015 The Rust Project Developers. MIT license.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unicodeWidth = unicodeWidth;
-const _data_js_1 = __importDefault(require("./_data.js"));
-const _run_length_js_1 = require("./_run_length.js");
-let tables = null;
-function lookupWidth(cp) {
-    if (!tables)
-        tables = _data_js_1.default.tables.map(_run_length_js_1.runLengthDecode);
-    const t1Offset = tables[0][(cp >> 13) & 0xff];
-    const t2Offset = tables[1][128 * t1Offset + ((cp >> 6) & 0x7f)];
-    const packedWidths = tables[2][16 * t2Offset + ((cp >> 2) & 0xf)];
-    const width = (packedWidths >> (2 * (cp & 0b11))) & 0b11;
-    return width === 3 ? 1 : width;
-}
-const cache = new Map();
-function charWidth(char) {
-    if (cache.has(char))
-        return cache.get(char);
-    const codePoint = char.codePointAt(0);
-    let width = null;
-    if (codePoint < 0x7f) {
-        width = codePoint >= 0x20 ? 1 : codePoint === 0 ? 0 : null;
-    }
-    else if (codePoint >= 0xa0) {
-        width = lookupWidth(codePoint);
-    }
-    else {
-        width = null;
-    }
-    cache.set(char, width);
-    return width;
-}
-/**
- * Calculate the physical width of a string in a TTY-like environment. This is
- * useful for cases such as calculating where a line-wrap will occur and
- * underlining strings.
- *
- * The physical width is given by the number of columns required to display
- * the string. The number of columns a given unicode character occupies can
- * vary depending on the character itself.
- *
- * @param str The string to measure.
- * @returns The unicode width of the string.
- *
- * @example Calculating the unicode width of a string
- * ```ts
- * import { unicodeWidth } from "@std/cli/unicode-width";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(unicodeWidth("hello world"), 11);
- * assertEquals(unicodeWidth("天地玄黃宇宙洪荒"), 16);
- * assertEquals(unicodeWidth("ｆｕｌｌｗｉｄｔｈ"), 18);
- * ```
- *
- * @example Calculating the unicode width of a color-encoded string
- * ```ts
- * import { unicodeWidth } from "@std/cli/unicode-width";
- * import { stripAnsiCode } from "@std/fmt/colors";
- * import { assertEquals } from "@std/assert";
- *
- * assertEquals(unicodeWidth(stripAnsiCode("\x1b[36mголубой\x1b[39m")), 7);
- * assertEquals(unicodeWidth(stripAnsiCode("\x1b[31m紅色\x1b[39m")), 4);
- * assertEquals(unicodeWidth(stripAnsiCode("\x1B]8;;https://deno.land\x07🦕\x1B]8;;\x07")), 2);
- * ```
- *
- * Use
- * {@linkcode https://jsr.io/@std/fmt/doc/colors/~/stripAnsiCode | stripAnsiCode}
- * to remove ANSI escape codes from a string before passing it to
- * {@linkcode unicodeWidth}.
- */
-function unicodeWidth(str) {
-    return [...str].map((ch) => charWidth(ch) ?? 0).reduce((a, b) => a + b, 0);
-}