@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/auth-store/dist/provider-store.d.ts

@@ -1,4 +1,4 @@
-import type { SecretStore } from "./types.js";
+import type { SecretStore } from "./secret-store.js";
 export declare function key(providerId: string): string;
 export declare class MigratingSecretStore implements SecretStore {
     private readonly store;

package/node_modules/toolcraft/node_modules/auth-store/dist/provider-store.js

@@ -19,6 +19,9 @@ export class MigratingSecretStore {
             await this.mutate(async () => {
                 if (await this.store.get() === null) {
                     try {
+                        if (await this.legacyStore?.get() !== legacyValue) {
+                            return;
+                        }
                         await this.store.set(legacyValue);
                     }
                     catch {

package/node_modules/toolcraft/node_modules/auth-store/dist/safe-fs-secret-store.d.ts

@@ -0,0 +1,21 @@
+import { type FileSystem } from "@poe-code/safe-fs/core";
+import type { SecretStore } from "./secret-store.js";
+export interface SafeFsSecretStoreInput {
+    /** Host-owned filesystem with exclusive creation and atomic rename support. */
+    fs: FileSystem;
+    /** Absolute path inside a trusted, host-controlled filesystem namespace. */
+    filePath: string;
+    /** Host-managed AES-256-GCM key, with encrypt and decrypt usages. */
+    key: CryptoKey;
+}
+/** Portable encrypted storage. Hosts own key management and transaction coordination. */
+export declare class SafeFsSecretStore implements SecretStore {
+    private readonly fs;
+    private readonly filePath;
+    private readonly key;
+    constructor(input: SafeFsSecretStoreInput);
+    get(): Promise<string | null>;
+    set(value: string): Promise<void>;
+    delete(): Promise<void>;
+    private assertSafePath;
+}

package/node_modules/toolcraft/node_modules/auth-store/dist/safe-fs-secret-store.js

@@ -0,0 +1,119 @@
+import { dirname, normalizePath } from "@poe-code/safe-fs/core";
+import { hasOwnErrorCode } from "./error-codes.js";
+/** Portable encrypted storage. Hosts own key management and transaction coordination. */
+export class SafeFsSecretStore {
+    fs;
+    filePath;
+    key;
+    constructor(input) {
+        this.fs = input.fs;
+        if (!input.filePath.startsWith("/"))
+            throw new Error("Credential filePath must be absolute");
+        this.filePath = normalizePath(input.filePath);
+        if (this.filePath === "/")
+            throw new Error("Credential filePath must name a file");
+        this.key = input.key;
+        if (this.key.type !== "secret" || this.key.algorithm.name !== "AES-GCM" ||
+            this.key.algorithm.length !== 256 ||
+            !this.key.usages.includes("encrypt") || !this.key.usages.includes("decrypt")) {
+            throw new Error("Credential key must be an AES-256-GCM key with encrypt and decrypt usages");
+        }
+    }
+    async get() {
+        await this.assertSafePath();
+        let bytes;
+        try {
+            bytes = await this.fs.readFile(this.filePath);
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "ENOENT"))
+                return null;
+            throw error;
+        }
+        try {
+            const document = JSON.parse(new TextDecoder().decode(bytes));
+            if (!document || typeof document !== "object" || Array.isArray(document))
+                throw new Error();
+            const record = document;
+            if (!["version", "iv", "authTag", "ciphertext"].every(key => Object.hasOwn(record, key)) ||
+                record.version !== 1 || typeof record.iv !== "string" ||
+                typeof record.authTag !== "string" || typeof record.ciphertext !== "string")
+                throw new Error();
+            const iv = decodeBase64(record.iv);
+            const tag = decodeBase64(record.authTag);
+            const ciphertext = decodeBase64(record.ciphertext);
+            if (iv.length !== 12 || tag.length !== 16)
+                throw new Error();
+            const sealed = new Uint8Array(ciphertext.length + tag.length);
+            sealed.set(ciphertext);
+            sealed.set(tag, ciphertext.length);
+            const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, this.key, sealed);
+            return new TextDecoder("utf-8", { fatal: true }).decode(plaintext);
+        }
+        catch {
+            throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
+        }
+    }
+    async set(value) {
+        await this.assertSafePath();
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const sealed = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, this.key, new TextEncoder().encode(value)));
+        const document = JSON.stringify({
+            version: 1, iv: encodeBase64(iv),
+            authTag: encodeBase64(sealed.subarray(sealed.length - 16)),
+            ciphertext: encodeBase64(sealed.subarray(0, sealed.length - 16)),
+        });
+        await this.fs.mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        await this.assertSafePath();
+        const staging = `${this.filePath}.${crypto.randomUUID()}.tmp`;
+        // Exclusive creation must succeed before this operation owns staging cleanup.
+        await this.fs.writeFile(staging, new TextEncoder().encode(document), { flag: "wx", mode: 0o600 });
+        try {
+            await this.fs.rename(staging, this.filePath);
+        }
+        catch (error) {
+            try {
+                await this.fs.rm(staging);
+            }
+            catch (cleanup) {
+                throw new AggregateError([error, cleanup], "Credential publication and cleanup failed");
+            }
+            throw error;
+        }
+    }
+    async delete() {
+        await this.assertSafePath();
+        try {
+            await this.fs.rm(this.filePath);
+        }
+        catch (error) {
+            if (!hasOwnErrorCode(error, "ENOENT"))
+                throw error;
+        }
+    }
+    async assertSafePath() {
+        let current = "";
+        for (const segment of this.filePath.slice(1).split("/")) {
+            current += `/${segment}`;
+            try {
+                if ((await this.fs.lstat(current)).type === "symlink") {
+                    throw new Error("Refusing encrypted credential path through symbolic link");
+                }
+            }
+            catch (error) {
+                if (hasOwnErrorCode(error, "ENOENT"))
+                    return;
+                throw error;
+            }
+        }
+    }
+}
+function encodeBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function decodeBase64(value) {
+    return Uint8Array.from(atob(value), character => character.charCodeAt(0));
+}

package/node_modules/toolcraft/node_modules/auth-store/dist/secret-store.d.ts

@@ -0,0 +1,12 @@
+export interface SecretStoreLockOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface SecretStore {
+    get(options?: {
+        readOnly?: boolean;
+    }): Promise<string | null>;
+    set(value: string): Promise<void>;
+    delete(): Promise<void>;
+    withLock?<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
+}

package/node_modules/toolcraft/node_modules/auth-store/dist/secret-store.js

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft/node_modules/auth-store/dist/transaction-lock.d.ts

@@ -0,0 +1,22 @@
+import type { SecretStoreLockOptions } from "./secret-store.js";
+export type { SecretStoreLockOptions } from "./secret-store.js";
+export interface SecretStoreLockFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, value: string, options: {
+        encoding: BufferEncoding;
+        flag: string;
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+}
+/** Filesystem bakery lock: unique claims allow dead-owner cleanup without deleting a replacement owner's lock. */
+export declare function withSecretStoreFileLock<T>(fs: SecretStoreLockFileSystem, lockDirectory: string, operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;

package/node_modules/toolcraft/node_modules/auth-store/dist/transaction-lock.js

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { hasOwnErrorCode } from "./error-codes.js";
+/** Filesystem bakery lock: unique claims allow dead-owner cleanup without deleting a replacement owner's lock. */
+export async function withSecretStoreFileLock(fs, lockDirectory, operation, options = {}) {
+    options = { ...options, signal: options.signal, timeoutMs: options.timeoutMs };
+    const timeoutMs = options.timeoutMs ?? Infinity;
+    if (timeoutMs !== Infinity && (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647))
+        throw new Error("Invalid secret-store transaction lock timeout");
+    options.signal?.throwIfAborted();
+    const deadline = performance.now() + timeoutMs;
+    const directory = path.resolve(lockDirectory);
+    await assertLockDirectoryPath(fs, directory);
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    await assertLockDirectoryPath(fs, directory);
+    const name = `${process.pid}-${randomUUID()}.claim`;
+    const claimPath = path.join(directory, name);
+    const temporaryPath = `${claimPath}.tmp`;
+    let claimed = true;
+    let temporaryCreated = false;
+    let outcome;
+    try {
+        try {
+            await fs.writeFile(claimPath, JSON.stringify({ ticket: null }), { encoding: "utf8", flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "EEXIST"))
+                claimed = false;
+            throw error;
+        }
+        const existing = await readClaims(fs, directory, name);
+        const ticket = existing.reduce((max, claim) => Math.max(max, claim.ticket ?? 0), 0) + 1;
+        if (!Number.isSafeInteger(ticket))
+            throw new Error("Secret-store transaction lock ticket overflow");
+        temporaryCreated = true;
+        try {
+            await fs.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "EEXIST"))
+                temporaryCreated = false;
+            throw error;
+        }
+        await fs.rename(temporaryPath, claimPath);
+        temporaryCreated = false;
+        for (;;) {
+            options.signal?.throwIfAborted();
+            const peers = await readClaims(fs, directory, name);
+            if (!peers.some(peer => peer.ticket === null || peer.ticket < ticket || (peer.ticket === ticket && peer.name < name)))
+                break;
+            const remaining = deadline - performance.now();
+            if (remaining <= 0)
+                throw new Error("Timed out waiting for secret-store transaction lock");
+            await new Promise((resolve, reject) => {
+                const abort = () => { clearTimeout(timer); options.signal?.removeEventListener("abort", abort); reject(options.signal?.reason); };
+                const timer = setTimeout(() => { options.signal?.removeEventListener("abort", abort); resolve(); }, Math.min(10, remaining));
+                options.signal?.addEventListener("abort", abort, { once: true });
+                if (options.signal?.aborted)
+                    abort();
+            });
+        }
+        options.signal?.throwIfAborted();
+        outcome = { result: await operation() };
+    }
+    catch (error) {
+        outcome = { error };
+    }
+    const cleanup = [];
+    for (const target of [...(temporaryCreated ? [temporaryPath] : []), ...(claimed ? [claimPath] : [])]) {
+        try {
+            await fs.unlink(target);
+        }
+        catch (error) {
+            if (!hasOwnErrorCode(error, "ENOENT"))
+                cleanup.push(error);
+        }
+    }
+    if (cleanup.length)
+        throw new AggregateError([...("error" in outcome ? [outcome.error] : []), ...cleanup], "Secret-store transaction lock cleanup failed");
+    if ("error" in outcome)
+        throw outcome.error;
+    return outcome.result;
+}
+async function assertNoSymbolicLink(fs, target) {
+    try {
+        if ((await fs.lstat(target)).isSymbolicLink())
+            throw new Error("Refusing secret-store transaction lock through symbolic link");
+    }
+    catch (error) {
+        if (!hasOwnErrorCode(error, "ENOENT"))
+            throw error;
+    }
+}
+async function assertLockDirectoryPath(fs, directory) {
+    const root = path.parse(directory).root;
+    const segments = directory.slice(root.length).split(path.sep).filter(Boolean);
+    let current = root;
+    for (const [index, segment] of segments.entries()) {
+        current = path.join(current, segment);
+        // Match encrypted credential paths: allow OS root aliases such as macOS /var.
+        if (index > 0 || segments.length === 1)
+            await assertNoSymbolicLink(fs, current);
+    }
+}
+async function readClaims(fs, directory, ownName) {
+    const claims = [];
+    for (const name of await fs.readdir(directory)) {
+        if (name === ownName || !name.endsWith(".claim"))
+            continue;
+        const pidText = name.slice(0, name.indexOf("-"));
+        const pid = Number(pidText);
+        if (!Number.isSafeInteger(pid) || pid < 1 || String(pid) !== pidText)
+            throw new Error("Malformed secret-store transaction lock owner");
+        const target = path.join(directory, name);
+        await assertNoSymbolicLink(fs, target);
+        let alive = true;
+        try {
+            process.kill(pid, 0);
+        }
+        catch (error) {
+            alive = !hasOwnErrorCode(error, "ESRCH");
+        }
+        if (!alive) {
+            try {
+                await fs.unlink(target);
+            }
+            catch (error) {
+                if (!hasOwnErrorCode(error, "ENOENT"))
+                    throw error;
+            }
+            continue;
+        }
+        let ticket = null;
+        let raw;
+        try {
+            raw = await fs.readFile(target, "utf8");
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "ENOENT"))
+                continue;
+            throw error;
+        }
+        try {
+            const value = JSON.parse(raw);
+            if (value !== null && typeof value === "object" && "ticket" in value &&
+                typeof value.ticket === "number" && Number.isSafeInteger(value.ticket) && value.ticket > 0)
+                ticket = value.ticket;
+        }
+        catch { /* Incomplete live claims remain in the choosing phase; never steal them by age. */ }
+        claims.push({ name, ticket });
+    }
+    return claims;
+}

package/node_modules/toolcraft/node_modules/auth-store/dist/types.d.ts

@@ -1,12 +1,7 @@
 import type { EncryptedFileStoreInput } from "./encrypted-file-store.js";
 import type { KeychainStoreInput } from "./keychain-store.js";
-export interface SecretStore {
-    get(options?: {
-        readOnly?: boolean;
-    }): Promise<string | null>;
-    set(value: string): Promise<void>;
-    delete(): Promise<void>;
-}
+import type { SecretStore } from "./secret-store.js";
+export type { SecretStore } from "./secret-store.js";
 export type StoreBackend = "file" | "keychain";
 export interface CreateSecretStoreInput {
     backend?: StoreBackend;

package/node_modules/toolcraft/node_modules/auth-store/package.json

@@ -1,21 +1,36 @@
 {
-  "name": "auth-store",
-  "version": "0.0.1",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": {
+        "workerd": "./dist/index.browser.d.ts",
+        "browser": "./dist/index.browser.d.ts",
+        "worker": "./dist/index.browser.d.ts",
+        "node": "./dist/index.d.ts",
+        "default": "./dist/index.browser.d.ts"
+      },
+      "workerd": "./dist/index.browser.js",
+      "browser": "./dist/index.browser.js",
+      "worker": "./dist/index.browser.js",
+      "node": "./dist/index.js",
+      "default": "./dist/index.browser.js"
+    },
+    "./portable": {
+      "types": "./dist/index.browser.d.ts",
+      "default": "./dist/index.browser.js"
     }
   },
   "scripts": {
-    "build": "node ../../scripts/guard-package-dist.mjs && tsc"
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test:unit": "cd ../.. && vitest run packages/auth-store/src"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "repository": {
     "type": "git",

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { TruncationOptions, WidthOptions, Result } from './types.js';
+declare const getStringTruncatedWidth: (input: string, truncationOptions?: TruncationOptions, widthOptions?: WidthOptions) => Result;
+export default getStringTruncatedWidth;
+export type { TruncationOptions, WidthOptions, Result };

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/index.js

@@ -0,0 +1,111 @@
+/* IMPORT */
+import { getCodePointsLength, isFullWidth, isWideNotCJKTNotEmoji } from './utils.js';
+/* HELPERS */
+const ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const NO_TRUNCATION = { limit: Infinity, ellipsis: '' };
+/* MAIN */
+const getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+    /* CONSTANTS */
+    const LIMIT = truncationOptions.limit ?? Infinity;
+    const ELLIPSIS = truncationOptions.ellipsis ?? '';
+    const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+    const ANSI_WIDTH = 0;
+    const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+    const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+    const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+    const FULL_WIDTH_WIDTH = 2;
+    const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+    const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+    const PARSE_BLOCKS = [
+        [LATIN_RE, REGULAR_WIDTH],
+        [ANSI_RE, ANSI_WIDTH],
+        [CONTROL_RE, CONTROL_WIDTH],
+        [TAB_RE, TAB_WIDTH],
+        [EMOJI_RE, EMOJI_WIDTH],
+        [CJKT_WIDE_RE, WIDE_WIDTH],
+    ];
+    /* STATE */
+    let indexPrev = 0;
+    let index = 0;
+    let length = input.length;
+    let lengthExtra = 0;
+    let truncationEnabled = false;
+    let truncationIndex = length;
+    let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+    let unmatchedStart = 0;
+    let unmatchedEnd = 0;
+    let width = 0;
+    let widthExtra = 0;
+    /* PARSE LOOP */
+    outer: while (true) {
+        /* UNMATCHED */
+        if ((unmatchedEnd > unmatchedStart) || (index >= length && index > indexPrev)) {
+            const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+            lengthExtra = 0;
+            for (const char of unmatched.replaceAll(MODIFIER_RE, '')) {
+                const codePoint = char.codePointAt(0) || 0;
+                if (isFullWidth(codePoint)) {
+                    widthExtra = FULL_WIDTH_WIDTH;
+                }
+                else if (isWideNotCJKTNotEmoji(codePoint)) {
+                    widthExtra = WIDE_WIDTH;
+                }
+                else {
+                    widthExtra = REGULAR_WIDTH;
+                }
+                if ((width + widthExtra) > truncationLimit) {
+                    truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+                }
+                if ((width + widthExtra) > LIMIT) {
+                    truncationEnabled = true;
+                    break outer;
+                }
+                lengthExtra += char.length;
+                width += widthExtra;
+            }
+            unmatchedStart = unmatchedEnd = 0;
+        }
+        /* EXITING */
+        if (index >= length) {
+            break outer;
+        }
+        /* PARSE BLOCKS */
+        for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+            const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+            BLOCK_RE.lastIndex = index;
+            if (BLOCK_RE.test(input)) {
+                lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+                widthExtra = lengthExtra * BLOCK_WIDTH;
+                if ((width + widthExtra) > truncationLimit) {
+                    truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+                }
+                if ((width + widthExtra) > LIMIT) {
+                    truncationEnabled = true;
+                    break outer;
+                }
+                width += widthExtra;
+                unmatchedStart = indexPrev;
+                unmatchedEnd = index;
+                index = indexPrev = BLOCK_RE.lastIndex;
+                continue outer;
+            }
+        }
+        /* UNMATCHED INDEX */
+        index += 1;
+    }
+    /* RETURN */
+    return {
+        width: truncationEnabled ? truncationLimit : width,
+        index: truncationEnabled ? truncationIndex : length,
+        truncated: truncationEnabled,
+        ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+    };
+};
+/* EXPORT */
+export default getStringTruncatedWidth;

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/types.d.ts

@@ -0,0 +1,19 @@
+type TruncationOptions = {
+    limit?: number;
+    ellipsis?: string;
+    ellipsisWidth?: number;
+};
+type WidthOptions = {
+    controlWidth?: number;
+    tabWidth?: number;
+    emojiWidth?: number;
+    regularWidth?: number;
+    wideWidth?: number;
+};
+type Result = {
+    width: number;
+    index: number;
+    truncated: boolean;
+    ellipsed: boolean;
+};
+export type { TruncationOptions, WidthOptions, Result };

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/types.js

@@ -0,0 +1,2 @@
+/* MAIN */
+export {};

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/utils.d.ts

@@ -0,0 +1,4 @@
+declare const getCodePointsLength: (input: string) => number;
+declare const isFullWidth: (x: number) => boolean;
+declare const isWideNotCJKTNotEmoji: (x: number) => boolean;
+export { getCodePointsLength, isFullWidth, isWideNotCJKTNotEmoji };

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/dist/utils.js

@@ -0,0 +1,20 @@
+/* MAIN */
+const getCodePointsLength = (() => {
+    const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+    return (input) => {
+        let surrogatePairsNr = 0;
+        SURROGATE_PAIR_RE.lastIndex = 0;
+        while (SURROGATE_PAIR_RE.test(input)) {
+            surrogatePairsNr += 1;
+        }
+        return input.length - surrogatePairsNr;
+    };
+})();
+const isFullWidth = (x) => {
+    return x === 0x3000 || x >= 0xFF01 && x <= 0xFF60 || x >= 0xFFE0 && x <= 0xFFE6;
+};
+const isWideNotCJKTNotEmoji = (x) => {
+    return x === 0x231B || x === 0x2329 || x >= 0x2FF0 && x <= 0x2FFF || x >= 0x3001 && x <= 0x303E || x >= 0x3099 && x <= 0x30FF || x >= 0x3105 && x <= 0x312F || x >= 0x3131 && x <= 0x318E || x >= 0x3190 && x <= 0x31E3 || x >= 0x31EF && x <= 0x321E || x >= 0x3220 && x <= 0x3247 || x >= 0x3250 && x <= 0x4DBF || x >= 0xFE10 && x <= 0xFE19 || x >= 0xFE30 && x <= 0xFE52 || x >= 0xFE54 && x <= 0xFE66 || x >= 0xFE68 && x <= 0xFE6B || x >= 0x1F200 && x <= 0x1F202 || x >= 0x1F210 && x <= 0x1F23B || x >= 0x1F240 && x <= 0x1F248 || x >= 0x20000 && x <= 0x2FFFD || x >= 0x30000 && x <= 0x3FFFD;
+};
+/* EXPORT */
+export { getCodePointsLength, isFullWidth, isWideNotCJKTNotEmoji };

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-present Fabio Spampinato
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/node_modules/toolcraft/node_modules/fast-string-truncated-width/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "fast-string-truncated-width",
+  "repository": "github:fabiospampinato/fast-string-truncated-width",
+  "description": "A fast function for calculating where a string should be truncated, given an optional width limit and an ellipsis string.",
+  "license": "MIT",
+  "version": "3.0.3",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "benchmark": "tsex benchmark",
+    "benchmark:watch": "tsex benchmark --watch",
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "tsex prepare"
+  },
+  "keywords": [
+    "fast",
+    "string",
+    "truncated",
+    "width",
+    "cli",
+    "terminal"
+  ],
+  "devDependencies": {
+    "benchloop": "^2.1.1",
+    "fava": "^0.3.4",
+    "tsex": "^4.0.2",
+    "typescript": "^5.7.3"
+  }
+}