@travisennis/acai 0.0.4 → 0.0.6

package/dist/terminal/search-prompt.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+/**
+ * Standalone search prompt (inquirer-like)
+ * - TypeScript version
+ */
+// ANSI helpers
+const ESC = "\x1b[";
+const hideCursor = () => process.stdout.write(`${ESC}?25l`);
+const showCursor = () => process.stdout.write(`${ESC}?25h`);
+function normalizeChoice(choice) {
+    if (typeof choice === "string") {
+        return { name: choice, value: choice, disabled: false };
+    }
+    const { name, value, disabled = false } = choice;
+    return { name, value, disabled };
+}
+function render(choices, pointerIndex, pageStart, pageSize, prompt, searchInput) {
+    const visible = choices.slice(pageStart, pageStart + pageSize);
+    const lines = [];
+    lines.push(`${prompt}${searchInput ? ` (search: ${searchInput})` : ""}`);
+    for (let i = 0; i < visible.length; i++) {
+        const actualIndex = pageStart + i;
+        const ch = visible[i];
+        const prefix = actualIndex === pointerIndex ? "›" : " ";
+        if (ch.disabled) {
+            lines.push(` ${prefix} ${ch.name} (disabled)`);
+        }
+        else if (actualIndex === pointerIndex) {
+            lines.push(`\x1b[36m ${prefix} ${ch.name}\x1b[0m`);
+        }
+        else {
+            lines.push(` ${prefix} ${ch.name}`);
+        }
+    }
+    if (choices.length > pageSize) {
+        const pageCount = Math.ceil(choices.length / pageSize);
+        const currentPage = Math.ceil(pageStart / pageSize) + 1;
+        lines.push(`\x1b[2mPage ${currentPage}/${pageCount}\x1b[0m`);
+    }
+    return lines.join("\n");
+}
+export async function search({ message = "Search", source, pageSize = 7, signal, }) {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    if (!stdin.isTTY)
+        throw new Error("TTY required");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let searchInput = "";
+    let choices = [];
+    let pointer = 0;
+    let pageStart = 0;
+    let lastSourceCall = null;
+    let previousOutputLines = 0;
+    function clearPreviousOutput(lineCount) {
+        for (let i = 0; i < lineCount; i++) {
+            stdout.write("\x1b[1A\x1b[2K"); // Move up and clear line
+        }
+    }
+    function renderToScreen() {
+        stdout.write("\x1b[2K"); // Clear current line
+        stdout.write("\x1b[0G"); // Move to start of line
+        stdout.write("\x1b[0J"); // Clear from cursor to end of screen
+        clearPreviousOutput(previousOutputLines);
+        const out = render(choices, pointer, pageStart, pageSize, message, searchInput);
+        // Count lines in current output
+        previousOutputLines = out.split("\n").length;
+        stdout.write(`${out}\n`);
+    }
+    function move(delta) {
+        const len = choices.length;
+        if (len === 0)
+            return;
+        let newIndex = pointer;
+        do {
+            newIndex = (newIndex + delta + len) % len;
+        } while (choices[newIndex]?.disabled && newIndex !== pointer);
+        pointer = newIndex;
+        // Update pageStart to snap to page boundaries
+        const currentPage = Math.floor(pointer / pageSize);
+        pageStart = currentPage * pageSize;
+        // Ensure pageStart is within bounds
+        pageStart = Math.max(0, Math.min(pageStart, choices.length - pageSize));
+        renderToScreen();
+    }
+    async function updateChoices(input) {
+        // Cancel previous source call if still in progress
+        if (lastSourceCall) {
+            // We can't actually cancel the promise, but we can ignore its result
+            lastSourceCall.catch(() => { });
+        }
+        const sourcePromise = source(input);
+        lastSourceCall = sourcePromise.then(() => { });
+        try {
+            const newChoices = await sourcePromise;
+            choices = newChoices.map(normalizeChoice);
+            // Reset pointer to first selectable choice
+            pointer = 0;
+            if (choices.length > 0) {
+                for (let i = 0; i < choices.length; i++) {
+                    if (!choices[i].disabled) {
+                        pointer = i;
+                        break;
+                    }
+                }
+            }
+            pageStart = 0;
+            renderToScreen();
+        }
+        catch (_error) {
+            // Handle source errors gracefully
+            choices = [];
+            pointer = 0;
+            pageStart = 0;
+            renderToScreen();
+        }
+    }
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        function cleanup() {
+            if (resolved)
+                return;
+            resolved = true;
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+            showCursor();
+        }
+        // Handle abort signal
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                cleanup();
+                const err = new Error("AbortError");
+                err.name = "AbortError";
+                reject(err);
+            });
+        }
+        function onData(key) {
+            if (key === "\u0003") {
+                cleanup();
+                stdout.write("\n");
+                const err = new Error("Cancelled");
+                err.isCanceled = true;
+                reject(err);
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                if (choices.length === 0) {
+                    // No choices available, just return
+                    cleanup();
+                    stdout.write("\n");
+                    const err = new Error("No choices available");
+                    err.isCanceled = true;
+                    reject(err);
+                    return;
+                }
+                const chosen = choices[pointer];
+                if (chosen && !chosen.disabled) {
+                    cleanup();
+                    stdout.write("\n");
+                    resolve(chosen.value);
+                    return;
+                }
+                return;
+            }
+            if (key === "\x1b[A") {
+                move(-1);
+                return;
+            }
+            if (key === "\x1b[B") {
+                move(1);
+                return;
+            }
+            if (key === "\x1b[H" || key === "\x1b[1~") {
+                if (choices.length > 0) {
+                    for (let i = 0; i < choices.length; i++) {
+                        if (!choices[i].disabled) {
+                            pointer = i;
+                            break;
+                        }
+                    }
+                    // Update pageStart to snap to page boundaries
+                    const currentPage = Math.floor(pointer / pageSize);
+                    pageStart = currentPage * pageSize;
+                    pageStart = Math.max(0, Math.min(pageStart, choices.length - pageSize));
+                    renderToScreen();
+                }
+                return;
+            }
+            if (key === "\x1b[F" || key === "\x1b[4~") {
+                if (choices.length > 0) {
+                    for (let i = choices.length - 1; i >= 0; i--) {
+                        if (!choices[i].disabled) {
+                            pointer = i;
+                            break;
+                        }
+                    }
+                    // Update pageStart to snap to page boundaries
+                    const currentPage = Math.floor(pointer / pageSize);
+                    pageStart = currentPage * pageSize;
+                    pageStart = Math.max(0, Math.min(pageStart, choices.length - pageSize));
+                    renderToScreen();
+                }
+                return;
+            }
+            if (key === "\x7f" || key === "\b") {
+                if (searchInput.length > 0) {
+                    searchInput = searchInput.slice(0, -1);
+                    updateChoices(searchInput);
+                }
+                return;
+            }
+            if (key && key >= " " && key <= "~") {
+                searchInput += key;
+                updateChoices(searchInput);
+                return;
+            }
+        }
+        hideCursor();
+        // Reset previous output lines counter to ensure clean start
+        previousOutputLines = 0;
+        // Initial render with empty search
+        updateChoices("");
+        stdin.on("data", onData);
+        process.on("exit", () => {
+            if (!resolved) {
+                cleanup();
+                stdout.write("\n");
+            }
+        });
+    });
+}
+// Quick test when run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    (async () => {
+        try {
+            const res = await search({
+                message: "Search for fruit",
+                source: async (input) => {
+                    // Simulate async search
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    const fruits = [
+                        "Apple",
+                        "Banana",
+                        "Cherry",
+                        "Date",
+                        "Elderberry",
+                        "Fig",
+                        "Grapes",
+                        "Honeydew",
+                        "Orange",
+                    ];
+                    if (!input) {
+                        return fruits.slice(0, 5);
+                    }
+                    return fruits
+                        .filter((fruit) => fruit.toLowerCase().includes(input.toLowerCase()))
+                        .slice(0, 10);
+                },
+                pageSize: 5,
+            });
+            console.log("You selected:", res);
+            process.exit(0);
+        }
+        catch (err) {
+            if (err &&
+                typeof err === "object" &&
+                "isCanceled" in err &&
+                err.isCanceled) {
+                console.error("Canceled");
+                process.exit(2);
+            }
+            else {
+                console.error(err);
+                process.exit(1);
+            }
+        }
+    })();
+}

package/dist/terminal/select-prompt.d.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * Standalone select prompt (inquirer-like)
+ * - TypeScript version
+ */
+interface ChoiceObject<T = unknown> {
+    name: string;
+    value: T;
+    disabled?: boolean;
+}
+type Choice<T = unknown> = string | ChoiceObject<T>;
+interface TerminalIo {
+    stdin: NodeJS.ReadStream;
+    stdout: NodeJS.WriteStream;
+}
+interface SelectOptions<T = unknown> {
+    message?: string;
+    choices: Choice<T>[];
+    initial?: number;
+    pageSize?: number;
+    signal?: AbortSignal;
+    terminal?: TerminalIo;
+}
+export declare function select<T = unknown>({ message, choices, initial, pageSize, signal, terminal, }: SelectOptions<T>): Promise<T>;
+export {};
+//# sourceMappingURL=select-prompt.d.ts.map

package/dist/terminal/select-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-prompt.d.ts","sourceRoot":"","sources":["../../source/terminal/select-prompt.ts"],"names":[],"mappings":";AACA;;;GAGG;AA6BH,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AACD,KAAK,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAQpD,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC;CAC5B;AAED,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAgGD,wBAAsB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,EACxC,OAAkB,EAClB,OAAO,EACP,OAAW,EACX,QAAY,EACZ,MAAM,EACN,QAA2D,GAC5D,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgN/B"}

package/dist/terminal/select-prompt.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+/**
+ * Standalone select prompt (inquirer-like)
+ * - TypeScript version
+ */
+const Keys = {
+    up: "\x1b[A",
+    down: "\x1b[B",
+    home: "\x1b[H",
+    homeAlt: "\x1b[1~",
+    end: "\x1b[F",
+    endAlt: "\x1b[4~",
+    ctrlC: "\u0003",
+    enter: "\r",
+    newline: "\n",
+    backspace: "\x7f",
+    backspaceAlt: "\b",
+};
+const ANSI = {
+    hideCursor: "\x1b[?25l",
+    showCursor: "\x1b[?25h",
+    clearLine: "\x1b[2K",
+    carriageReturn: "\r",
+    moveToStart: "\x1b[0G",
+    clearFromCursor: "\x1b[0J",
+    moveUp: "\x1b[1A",
+    cyan: "\x1b[36m",
+    dim: "\x1b[2m",
+    reset: "\x1b[0m",
+};
+function normalizeChoice(choice) {
+    if (typeof choice === "string") {
+        return { name: choice, value: choice, disabled: false };
+    }
+    const { name, value, disabled = false } = choice;
+    return { name, value, disabled };
+}
+function updatePageStart(pointerIndex, pageSize, totalItems) {
+    const currentPage = Math.floor(pointerIndex / pageSize);
+    const pageStart = currentPage * pageSize;
+    return Math.max(0, Math.min(pageStart, Math.max(0, totalItems - pageSize)));
+}
+function findNextEnabledIndex(choices, startIndex, direction) {
+    const len = choices.length;
+    let index = startIndex;
+    for (let i = 0; i < len; i++) {
+        index = (index + direction + len) % len;
+        if (!choices[index].disabled) {
+            return index;
+        }
+    }
+    return startIndex;
+}
+function findFirstEnabledIndex(choices) {
+    for (let i = 0; i < choices.length; i++) {
+        if (!choices[i].disabled) {
+            return i;
+        }
+    }
+    return 0;
+}
+function findLastEnabledIndex(choices) {
+    for (let i = choices.length - 1; i >= 0; i--) {
+        if (!choices[i].disabled) {
+            return i;
+        }
+    }
+    return choices.length - 1;
+}
+function render(choices, pointerIndex, pageStart, pageSize, prompt, typed, totalChoices) {
+    const visible = choices.slice(pageStart, pageStart + pageSize);
+    const lines = [];
+    const searchInfo = typed ? ` (search: ${typed})` : "";
+    const filterInfo = typed && choices.length !== totalChoices
+        ? ` [${choices.length}/${totalChoices}]`
+        : "";
+    lines.push(`${prompt}${searchInfo}${filterInfo}`);
+    for (let i = 0; i < visible.length; i++) {
+        const actualIndex = pageStart + i;
+        const ch = visible[i];
+        const prefix = actualIndex === pointerIndex ? "›" : " ";
+        if (ch.disabled) {
+            lines.push(` ${prefix} ${ch.name} (disabled)`);
+        }
+        else if (actualIndex === pointerIndex) {
+            lines.push(`${ANSI.cyan} ${prefix} ${ch.name}${ANSI.reset}`);
+        }
+        else {
+            lines.push(` ${prefix} ${ch.name}`);
+        }
+    }
+    if (choices.length > pageSize) {
+        const pageCount = Math.ceil(choices.length / pageSize);
+        const currentPage = Math.ceil(pageStart / pageSize) + 1;
+        lines.push(`${ANSI.dim}Page ${currentPage}/${pageCount}${ANSI.reset}`);
+    }
+    return lines.join("\n");
+}
+export async function select({ message = "Select", choices, initial = 0, pageSize = 7, signal, terminal = { stdin: process.stdin, stdout: process.stdout }, }) {
+    if (!Array.isArray(choices) || choices.length === 0) {
+        throw new Error("choices must be a non-empty array");
+    }
+    const normalized = choices.map(normalizeChoice);
+    const hasEnabledChoice = normalized.some((ch) => !ch.disabled);
+    if (!hasEnabledChoice) {
+        throw new Error("At least one choice must be enabled");
+    }
+    let pointer = Math.max(0, Math.min(Math.floor(initial ?? 0), normalized.length - 1));
+    if (normalized[pointer].disabled) {
+        pointer = findNextEnabledIndex(normalized, pointer, 1);
+    }
+    let pageStart = updatePageStart(pointer, pageSize, normalized.length);
+    const { stdin, stdout } = terminal;
+    if (!stdin.isTTY)
+        throw new Error("TTY required");
+    let searchBuffer = "";
+    const searchTimer = null;
+    let filteredChoices = [...normalized];
+    const clearSearchBuffer = () => {
+        searchBuffer = "";
+        filteredChoices = [...normalized];
+        // Reset pointer to first enabled choice when clearing search
+        pointer = findFirstEnabledIndex(filteredChoices);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+        renderToScreen();
+    };
+    const resetSearchTimer = () => {
+        if (searchTimer)
+            clearTimeout(searchTimer);
+        // Don't auto-clear the search buffer - let user clear it explicitly
+    };
+    let previousOutputLines = 0;
+    function clearPreviousOutput(lineCount) {
+        for (let i = 0; i < lineCount; i++) {
+            stdout.write(`${ANSI.moveUp}${ANSI.clearLine}`);
+        }
+    }
+    function renderToScreen() {
+        stdout.write(ANSI.clearLine);
+        stdout.write(ANSI.moveToStart);
+        stdout.write(ANSI.clearFromCursor);
+        clearPreviousOutput(previousOutputLines);
+        const out = render(filteredChoices, pointer, pageStart, pageSize, message, searchBuffer, normalized.length);
+        previousOutputLines = out.split("\n").length;
+        stdout.write(`${out}\n`);
+    }
+    function move(delta) {
+        pointer = findNextEnabledIndex(filteredChoices, pointer, delta);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+        renderToScreen();
+    }
+    function filterChoices(search) {
+        if (!search) {
+            filteredChoices = [...normalized];
+        }
+        else {
+            const lowerSearch = search.toLowerCase();
+            filteredChoices = normalized.filter((choice) => choice.name.toLowerCase().includes(lowerSearch));
+        }
+        // Reset pointer to first enabled choice
+        pointer = findFirstEnabledIndex(filteredChoices);
+        pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+    }
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        function cleanup() {
+            if (resolved)
+                return;
+            resolved = true;
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+            if (searchTimer)
+                clearTimeout(searchTimer);
+            if (signal && abortHandler) {
+                signal.removeEventListener("abort", abortHandler);
+            }
+            stdout.write(ANSI.showCursor);
+        }
+        const abortHandler = signal
+            ? () => {
+                cleanup();
+                const err = new Error("AbortError");
+                err.name = "AbortError";
+                reject(err);
+            }
+            : null;
+        if (signal && abortHandler) {
+            signal.addEventListener("abort", abortHandler);
+        }
+        function onData(key) {
+            if (key === Keys.ctrlC) {
+                cleanup();
+                stdout.write("\n");
+                const err = new Error("Cancelled");
+                err.isCanceled = true;
+                reject(err);
+                return;
+            }
+            if (key === Keys.enter || key === Keys.newline) {
+                cleanup();
+                const chosen = filteredChoices[pointer];
+                stdout.write("\n");
+                resolve(chosen.value);
+                return;
+            }
+            if (key === Keys.up) {
+                move(-1);
+                return;
+            }
+            if (key === Keys.down) {
+                move(1);
+                return;
+            }
+            if (key === Keys.home || key === Keys.homeAlt) {
+                pointer = findFirstEnabledIndex(filteredChoices);
+                pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+                renderToScreen();
+                return;
+            }
+            if (key === Keys.end || key === Keys.endAlt) {
+                pointer = findLastEnabledIndex(filteredChoices);
+                pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
+                renderToScreen();
+                return;
+            }
+            if (key === Keys.backspace || key === Keys.backspaceAlt) {
+                if (searchBuffer.length > 0) {
+                    searchBuffer = searchBuffer.slice(0, -1);
+                    if (searchBuffer.length === 0) {
+                        clearSearchBuffer();
+                    }
+                    else {
+                        filterChoices(searchBuffer);
+                        renderToScreen();
+                    }
+                }
+                return;
+            }
+            if (key && key >= " " && key <= "~") {
+                searchBuffer += key;
+                resetSearchTimer();
+                filterChoices(searchBuffer);
+                renderToScreen();
+                return;
+            }
+        }
+        try {
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding("utf8");
+            stdout.write(ANSI.hideCursor);
+            // Reset previous output lines counter to ensure clean start
+            previousOutputLines = 0;
+            renderToScreen();
+            stdin.on("data", onData);
+            const exitHandler = () => {
+                if (!resolved) {
+                    cleanup();
+                    stdout.write("\n");
+                }
+            };
+            process.on("exit", exitHandler);
+        }
+        catch (error) {
+            cleanup();
+            throw error;
+        }
+    });
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    (async () => {
+        try {
+            const res = await select({
+                message: "Pick a fruit",
+                choices: [
+                    "Apple",
+                    "Banana",
+                    "Date",
+                    "Elderberry",
+                    "Fig",
+                    "Grapes",
+                    "Honeydew",
+                    "Orange",
+                ],
+                pageSize: 3,
+                initial: 0,
+            });
+            console.info("You picked:", res);
+            process.exit(0);
+        }
+        catch (err) {
+            if (err &&
+                typeof err === "object" &&
+                "isCanceled" in err &&
+                err.isCanceled) {
+                console.error("Canceled");
+                process.exit(2);
+            }
+            else {
+                console.error(err);
+                process.exit(1);
+            }
+        }
+    })();
+}

package/dist/terminal/string-width.d.ts

@@ -0,0 +1,7 @@
+interface StringWidthOptions {
+    ambiguousIsNarrow?: boolean;
+    countAnsiEscapeCodes?: boolean;
+}
+export default function stringWidth(input: string, options?: StringWidthOptions): number;
+export {};
+//# sourceMappingURL=string-width.d.ts.map

package/dist/terminal/string-width.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-width.d.ts","sourceRoot":"","sources":["../../source/terminal/string-width.ts"],"names":[],"mappings":"AAGA,UAAU,kBAAkB;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAwCD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CA0CR"}

package/dist/terminal/string-width.js

@@ -0,0 +1,61 @@
+import { eastAsianWidth } from "./east-asian-width.js";
+import stripAnsi from "./strip-ansi.js";
+const segmenter = new Intl.Segmenter();
+// Whole-cluster zero-width
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+// Pick the base scalar if the cluster starts with Prepend/Format/Marks
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+// RGI emoji sequences
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+function baseVisible(segment) {
+    return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+    return zeroWidthClusterRegex.test(segment);
+}
+function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+    let extra = 0;
+    if (segment.length > 1) {
+        for (const char of segment.slice(1)) {
+            const codePoint = char.codePointAt(0);
+            if (codePoint !== undefined && char >= "\\uFF00" && char <= "\\uFFEF") {
+                extra += eastAsianWidth(codePoint, eastAsianWidthOptions);
+            }
+        }
+    }
+    return extra;
+}
+export default function stringWidth(input, options = {}) {
+    if (typeof input !== "string" || input.length === 0) {
+        return 0;
+    }
+    const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+    let string = input;
+    if (!countAnsiEscapeCodes) {
+        string = stripAnsi(string);
+    }
+    if (string.length === 0) {
+        return 0;
+    }
+    let width = 0;
+    const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+    for (const { segment } of segmenter.segment(string)) {
+        // Zero-width / non-printing clusters
+        if (isZeroWidthCluster(segment)) {
+            continue;
+        }
+        // Emoji width logic
+        if (rgiEmojiRegex.test(segment)) {
+            width += 2;
+            continue;
+        }
+        // Everything else: EAW of the cluster’s first visible scalar
+        const codePoint = baseVisible(segment).codePointAt(0);
+        if (codePoint !== undefined) {
+            width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+            // Add width for trailing Halfwidth and Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
+            width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+        }
+    }
+    return width;
+}

package/dist/terminal/strip-ansi.d.ts

@@ -0,0 +1,2 @@
+export default function stripAnsi(string: string): string;
+//# sourceMappingURL=strip-ansi.d.ts.map

package/dist/terminal/strip-ansi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-ansi.d.ts","sourceRoot":"","sources":["../../source/terminal/strip-ansi.ts"],"names":[],"mappings":"AAkBA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASxD"}