@solaqua/gji 0.7.2 → 0.8.0

package/dist/worktree-picker.js

@@ -1,4 +1,5 @@
-import { groupMultiselect, isCancel, select } from "@clack/prompts";
+import { env, platform, stdin, stdout } from "node:process";
+import { isCancel, Prompt } from "@clack/core";
 import { loadHistory } from "./history.js";
 import { readWorktreeInfos, } from "./worktree-info.js";
 export async function buildWorktreePromptEntries(sources) {
@@ -38,25 +39,25 @@ function isAmbiguousRepoOnlyQuery(matches, query) {
     return (matches.filter((match) => match.source.repoName.toLowerCase() === query)
         .length > 1);
 }
-export async function promptForSingleWorktree(message, worktrees) {
-    const choice = await select({
+export async function promptForSingleWorktree(message, worktrees, io = {}) {
+    const choice = await runSearchablePrompt({
+        entries: worktrees.map(buildSearchableWorktreeEntry),
+        input: io.input,
         message,
-        options: worktrees.map((worktree) => ({
-            label: worktree.label,
-            value: worktree.path,
-        })),
-        maxItems: 12,
+        multiple: false,
+        output: io.output,
     });
-    return isCancel(choice) ? null : choice;
+    return typeof choice === "string" ? choice : null;
 }
-export async function promptForMultipleWorktrees(message, worktrees) {
-    const choice = await groupMultiselect({
+export async function promptForMultipleWorktrees(message, worktrees, io = {}) {
+    const choice = await runSearchablePrompt({
+        entries: buildGroupedSearchableEntries(worktrees),
+        input: io.input,
         message,
-        options: groupPromptEntries(worktrees),
-        required: true,
-        selectableGroups: false,
+        multiple: true,
+        output: io.output,
     });
-    return isCancel(choice) ? null : choice;
+    return Array.isArray(choice) ? choice : null;
 }
 function compareQueryMatches(a, b) {
     if (a.matchScore !== b.matchScore) {
@@ -71,16 +72,652 @@ function compareQueryMatches(a, b) {
         a.source.worktree.path.localeCompare(b.source.worktree.path));
 }
 function groupPromptEntries(worktrees) {
-    const groups = {};
+    const groups = new Map();
     for (const worktree of worktrees) {
         const group = worktree.group === "recent" ? "Recent worktrees" : "Other worktrees";
-        groups[group] ??= [];
-        groups[group].push({
-            label: worktree.label,
-            value: worktree.path,
+        const groupWorktrees = groups.get(group);
+        if (groupWorktrees === undefined) {
+            groups.set(group, [worktree]);
+        }
+        else {
+            groupWorktrees.push(worktree);
+        }
+    }
+    return [...groups.entries()];
+}
+function buildGroupedSearchableEntries(worktrees) {
+    const entries = [];
+    for (const [group, groupWorktrees] of groupPromptEntries(worktrees)) {
+        entries.push({
+            label: group,
+            searchText: group.toLowerCase(),
+            selectable: false,
         });
+        for (const worktree of groupWorktrees) {
+            entries.push(buildSearchableWorktreeEntry(worktree));
+        }
+    }
+    return entries;
+}
+function buildSearchableWorktreeEntry(worktree) {
+    const metadata = worktree.metadata ?? null;
+    const branch = worktree.branch ?? "(detached)";
+    return {
+        detail: [worktree.repoName, branch, metadata, worktree.path]
+            .filter((part) => part !== null && part.length > 0)
+            .join(" · "),
+        label: worktree.label,
+        searchText: buildPromptSearchText(worktree),
+        value: worktree.path,
+        worktree: {
+            branch,
+            metadata,
+            path: worktree.path,
+            repoName: worktree.repoName,
+        },
+    };
+}
+async function runSearchablePrompt(options) {
+    const input = options.input ?? stdin;
+    const output = options.output ?? stdout;
+    if (!input.isTTY) {
+        return null;
+    }
+    const prompt = new SearchablePrompt(options, input, output);
+    const value = await prompt.run();
+    return isCancel(value) ? null : value;
+}
+class SearchablePrompt {
+    options;
+    output;
+    cursor = 0;
+    query = "";
+    searchActive = false;
+    selected = new Set();
+    prompt;
+    constructor(options, input, output) {
+        this.options = options;
+        this.output = output;
+        this.cursor = this.firstSelectableIndex();
+        const owner = this;
+        this.prompt = new WorktreeCorePrompt(this, {
+            input,
+            output,
+            render: function renderWorktreePrompt() {
+                return owner.render(this.state, this.error);
+            },
+        });
+        this.syncValue();
+    }
+    run() {
+        return this.prompt.prompt();
+    }
+    handleKeypress(prompt, character, key) {
+        if (prompt.state === "error") {
+            prompt.state = "active";
+            prompt.error = "";
+        }
+        const action = resolvePromptAction(character, key);
+        if (action === "cancel") {
+            this.cancel(prompt);
+            return;
+        }
+        if (action === "escape") {
+            this.handleEscapeKey(prompt);
+            return;
+        }
+        if (action === "enter") {
+            this.submit(prompt);
+            return;
+        }
+        if (this.searchActive && this.handleSearchKey(character, key?.name)) {
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        if (character === "/" && !this.searchActive) {
+            this.searchActive = true;
+            this.query = "";
+            this.cursor = this.firstSelectableIndex();
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        this.handleNavigationKey(character, action);
+        this.syncValue();
+        renderPrompt(prompt);
+    }
+    handleEscapeKey(prompt) {
+        if (this.searchActive) {
+            this.searchActive = false;
+            this.query = "";
+            this.cursor = this.firstSelectableIndex();
+            this.syncValue();
+            renderPrompt(prompt);
+            return;
+        }
+        this.cancel(prompt);
+    }
+    cancel(prompt) {
+        prompt.state = "cancel";
+        renderPrompt(prompt);
+        closePrompt(prompt);
+    }
+    handleSearchKey(character, keyName) {
+        if (keyName === "space" || character === " ") {
+            return false;
+        }
+        if (keyName === "backspace" || keyName === "delete") {
+            this.query = this.query.slice(0, -1);
+            this.cursor = this.firstSelectableIndex();
+            return true;
+        }
+        if (isPrintableSearchCharacter(character)) {
+            this.query += character;
+            this.cursor = this.firstSelectableIndex();
+            return true;
+        }
+        return false;
+    }
+    handleNavigationKey(character, action) {
+        switch (action) {
+            case "up":
+                this.moveCursor(-1);
+                return;
+            case "down":
+                this.moveCursor(1);
+                return;
+            case "space":
+                this.toggleSelection();
+                return;
+        }
+        switch (character) {
+            case "k":
+                this.moveCursor(-1);
+                return;
+            case "j":
+                this.moveCursor(1);
+                return;
+            case " ":
+                this.toggleSelection();
+                return;
+        }
+    }
+    moveCursor(direction) {
+        const entries = this.visibleEntries();
+        if (entries.length === 0)
+            return;
+        let nextCursor = this.cursor;
+        for (let index = 0; index < entries.length; index += 1) {
+            nextCursor = wrapIndex(nextCursor + direction, entries.length);
+            if (isSelectableEntry(entries[nextCursor])) {
+                this.cursor = nextCursor;
+                return;
+            }
+        }
+    }
+    submit(prompt) {
+        const entry = this.visibleEntries()[this.cursor];
+        if (!this.options.multiple) {
+            prompt.value = isSelectableEntry(entry) ? entry.value : null;
+            prompt.state = "submit";
+            renderPrompt(prompt);
+            closePrompt(prompt);
+            return;
+        }
+        if (this.selected.size === 0) {
+            prompt.error = "Please select at least one option.";
+            prompt.state = "error";
+            renderPrompt(prompt);
+            return;
+        }
+        prompt.value = [...this.selected];
+        prompt.state = "submit";
+        renderPrompt(prompt);
+        closePrompt(prompt);
+    }
+    toggleSelection() {
+        if (!this.options.multiple)
+            return;
+        const entry = this.visibleEntries()[this.cursor];
+        if (!isSelectableEntry(entry))
+            return;
+        if (this.selected.has(entry.value)) {
+            this.selected.delete(entry.value);
+            return;
+        }
+        this.selected.add(entry.value);
+    }
+    render(state, error) {
+        const entries = this.visibleEntries();
+        const visibleEntries = windowPromptEntries(entries, this.cursor, this.maxItems());
+        const glyphs = promptGlyphs();
+        const colors = promptColors();
+        const frame = promptFrameColor(state, colors);
+        const lines = [
+            colors.bar(glyphs.bar),
+            this.renderTitle(state, glyphs, colors),
+            `${frame(glyphs.bar)}  ${this.renderSearchHint(colors)}`,
+            frame(glyphs.bar),
+        ];
+        if (state === "error" && error.length > 0) {
+            lines.push(`${colors.errorBar(glyphs.bar)}  ${colors.error(error)}`);
+            lines.push(frame(glyphs.bar));
+        }
+        lines.push(...this.renderEntries(entries, visibleEntries, glyphs, colors, frame));
+        lines.push(frame(glyphs.bar));
+        const preview = this.activePreview(entries, colors);
+        if (preview !== null) {
+            lines.push(`${frame(glyphs.bar)}  ${preview}`);
+            lines.push(frame(glyphs.bar));
+        }
+        const visibleWorktreeCount = entries.filter(isSelectableEntry).length;
+        const footer = this.footerText(visibleWorktreeCount, colors);
+        if (footer.length > 0) {
+            lines.push(`${frame(glyphs.corner)}  ${footer}`);
+        }
+        return `${lines.join("\n")}\n`;
+    }
+    renderTitle(state, glyphs, colors) {
+        const symbol = colors.symbol(promptSymbol(state, glyphs), state);
+        const maxTitleLength = Math.max(8, this.columns() - 3);
+        if (!this.searchActive) {
+            return `${symbol}  ${middleEllipsize(this.options.message, maxTitleLength)}`;
+        }
+        const search = ` /${this.query}`;
+        const maxSearchLength = Math.min(terminalWidth(search), Math.floor(maxTitleLength / 2));
+        const message = middleEllipsize(this.options.message, Math.max(1, maxTitleLength - maxSearchLength));
+        const visibleSearch = middleEllipsize(search, Math.max(1, maxTitleLength - terminalWidth(message)));
+        return `${symbol}  ${message}${colors.search(visibleSearch)}`;
+    }
+    renderSearchHint(colors) {
+        if (this.searchActive) {
+            return `${colors.hint("type to filter")} ${colors.hint("·")} ${colors.key("esc")} ${colors.hint("clears")}`;
+        }
+        return `${colors.hint("press ")}${colors.key("/")}${colors.hint(" to search")}`;
+    }
+    renderEntries(entries, visibleEntries, glyphs, colors, frame) {
+        if (entries.length === 0) {
+            return [`${frame(glyphs.bar)}  ${colors.hint("No matching worktrees")}`];
+        }
+        return visibleEntries.map((entry) => entry === "ellipsis"
+            ? `${frame(glyphs.bar)}  ${colors.hint("...")}`
+            : this.renderEntry(entries, entry, glyphs, colors, frame));
+    }
+    renderEntry(entries, entry, glyphs, colors, frame) {
+        const active = entries[this.cursor] === entry;
+        const selected = isSelectableEntry(entry) && this.selected.has(entry.value);
+        const prefix = this.entryPrefix(entry, active, selected, glyphs);
+        const label = this.entryLabel(entry, prefix);
+        const line = isSelectableEntry(entry)
+            ? active
+                ? label
+                : colors.hint(label)
+            : colors.hint(label);
+        const marker = selected
+            ? colors.selected(prefix)
+            : active
+                ? this.options.multiple
+                    ? colors.option(prefix)
+                    : colors.selected(prefix)
+                : colors.hint(prefix);
+        return `${frame(glyphs.bar)}  ${marker} ${line}`;
+    }
+    activePreview(entries, colors) {
+        const entry = entries[this.cursor];
+        if (!isSelectableEntry(entry) || entry.detail === undefined)
+            return null;
+        const label = "current";
+        const separator = " ";
+        const width = this.previewWidth();
+        const prefixWidth = terminalWidth(label) + terminalWidth(separator);
+        if (width <= prefixWidth)
+            return colors.key(middleEllipsize(label, width));
+        const detail = middleEllipsize(entry.detail, width - prefixWidth);
+        return `${colors.key(label)}${colors.hint(separator)}${colors.hint(detail)}`;
+    }
+    entryLabel(entry, prefix) {
+        const width = this.labelWidth(prefix);
+        if (entry.worktree === undefined) {
+            return middleEllipsize(entry.label, width);
+        }
+        return fitPromptPieces([
+            {
+                ellipsize: middleEllipsize,
+                max: 18,
+                min: 6,
+                value: entry.worktree.repoName,
+            },
+            {
+                ellipsize: middleEllipsize,
+                max: 32,
+                min: 8,
+                value: entry.worktree.branch,
+            },
+            ...(entry.worktree.metadata === null
+                ? []
+                : [
+                    {
+                        ellipsize: middleEllipsize,
+                        max: 30,
+                        min: 10,
+                        value: entry.worktree.metadata,
+                    },
+                ]),
+            {
+                ellipsize: startEllipsize,
+                max: 36,
+                min: 12,
+                value: entry.worktree.path,
+            },
+        ], width);
+    }
+    labelWidth(prefix) {
+        return Math.max(8, this.columns() - terminalWidth(prefix) - 4);
+    }
+    previewWidth() {
+        return Math.max(8, this.columns() - 3);
+    }
+    entryPrefix(entry, active, selected, glyphs) {
+        if (!isSelectableEntry(entry)) {
+            return active ? glyphs.active : " ";
+        }
+        if (!this.options.multiple) {
+            return active ? glyphs.active : glyphs.inactive;
+        }
+        if (active && selected)
+            return glyphs.checked;
+        if (active)
+            return glyphs.uncheckedActive;
+        return selected ? glyphs.checked : glyphs.unchecked;
+    }
+    footerText(visibleCount, colors) {
+        if (!this.options.multiple)
+            return "";
+        return [
+            `${colors.key("space")} ${colors.hint("select")}`,
+            `${colors.selected(String(this.selected.size))} ${colors.hint("selected")}`,
+            colors.hint(`${visibleCount} shown`),
+        ].join(colors.hint(" · "));
+    }
+    firstSelectableIndex() {
+        const index = this.visibleEntries().findIndex(isSelectableEntry);
+        return index === -1 ? 0 : index;
+    }
+    visibleEntries() {
+        const query = normalizeQuery(this.query);
+        if (query === null) {
+            return this.options.entries;
+        }
+        return filterSearchablePromptEntries(this.options.entries, query);
+    }
+    maxItems() {
+        const rows = this.output.rows ?? 16;
+        return Math.max(5, Math.min(12, rows - 8));
+    }
+    columns() {
+        return Math.max(20, this.output.columns ?? 80);
+    }
+    syncValue() {
+        if (this.options.multiple) {
+            this.prompt.value = [...this.selected];
+            return;
+        }
+        const entry = this.visibleEntries()[this.cursor];
+        this.prompt.value = isSelectableEntry(entry) ? entry.value : null;
+    }
+}
+class WorktreeCorePrompt extends Prompt {
+    worktreePrompt;
+    constructor(worktreePrompt, options) {
+        super(options, false);
+        this.worktreePrompt = worktreePrompt;
+    }
+}
+/*
+ * @clack/core owns raw mode, frame clearing, and cursor restoration, but it
+ * does not expose a public pre-cancel keypress hook. Keep this private adapter
+ * small so slash-search can clear on Esc before Clack maps Esc to cancel.
+ */
+Object.defineProperty(WorktreeCorePrompt.prototype, "onKeypress", {
+    value: onWorktreeKeypress,
+    writable: true,
+});
+function renderPrompt(prompt) {
+    prompt.render();
+}
+function closePrompt(prompt) {
+    prompt.close();
+}
+function onWorktreeKeypress(character, key) {
+    this.worktreePrompt.handleKeypress(this, character, key);
+}
+function resolvePromptAction(character, key) {
+    if ((key?.ctrl && key.name === "c") || character === "\u0003") {
+        return "cancel";
+    }
+    switch (key?.name) {
+        case "escape":
+            return "escape";
+        case "return":
+            return "enter";
+        case "space":
+            return "space";
+        case "up":
+        case "left":
+            return "up";
+        case "down":
+        case "right":
+            return "down";
+    }
+    switch (character) {
+        case " ":
+            return "space";
+        case "k":
+        case "h":
+            return "up";
+        case "j":
+        case "l":
+            return "down";
+    }
+    return undefined;
+}
+function promptGlyphs() {
+    return supportsUnicode()
+        ? {
+            active: "●",
+            bar: "│",
+            checked: "◼",
+            corner: "└",
+            inactive: "○",
+            pending: "◆",
+            submitted: "◇",
+            unchecked: "◻",
+            uncheckedActive: "◻",
+        }
+        : {
+            active: ">",
+            bar: "|",
+            checked: "[x]",
+            corner: "-",
+            inactive: " ",
+            pending: "*",
+            submitted: "o",
+            unchecked: "[ ]",
+            uncheckedActive: "[ ]",
+        };
+}
+function promptColors() {
+    return {
+        activeBar: cyan,
+        bar: gray,
+        error: yellow,
+        errorBar: yellow,
+        hint: dim,
+        key: cyan,
+        option: cyan,
+        search: cyan,
+        selected: green,
+        symbol: (value, state) => {
+            if (state === "submit")
+                return green(value);
+            if (state === "error")
+                return yellow(value);
+            if (state === "cancel")
+                return red(value);
+            return cyan(value);
+        },
+    };
+}
+function promptFrameColor(state, colors) {
+    if (state === "error")
+        return colors.errorBar;
+    if (state === "active" || state === "initial")
+        return colors.activeBar;
+    return colors.bar;
+}
+function promptSymbol(state, glyphs) {
+    return state === "submit" ? glyphs.submitted : glyphs.pending;
+}
+function cyan(value) {
+    return color("\u001b[36m", "\u001b[39m", value);
+}
+function dim(value) {
+    return color("\u001b[2m", "\u001b[22m", value);
+}
+function gray(value) {
+    return color("\u001b[90m", "\u001b[39m", value);
+}
+function green(value) {
+    return color("\u001b[32m", "\u001b[39m", value);
+}
+function red(value) {
+    return color("\u001b[31m", "\u001b[39m", value);
+}
+function yellow(value) {
+    return color("\u001b[33m", "\u001b[39m", value);
+}
+function color(open, close, value) {
+    if (env.NO_COLOR !== undefined)
+        return value;
+    return `${open}${value}${close}`;
+}
+function supportsUnicode() {
+    if (platform !== "win32") {
+        return env.TERM !== "linux";
+    }
+    return Boolean(env.CI ||
+        env.WT_SESSION ||
+        env.TERMINUS_SUBLIME ||
+        env.ConEmuTask === "{cmd::Cmder}" ||
+        env.TERM_PROGRAM === "Terminus-Sublime" ||
+        env.TERM_PROGRAM === "vscode" ||
+        env.TERM === "xterm-256color" ||
+        env.TERM === "alacritty" ||
+        env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+function isPrintableSearchCharacter(character) {
+    return (typeof character === "string" &&
+        character.length === 1 &&
+        character >= " " &&
+        character !== "\u007f");
+}
+function wrapIndex(index, length) {
+    return (index + length) % length;
+}
+function windowPromptEntries(entries, cursor, maxItems) {
+    if (entries.length <= maxItems) {
+        return entries;
+    }
+    const activeIndex = Math.min(Math.max(cursor, 0), entries.length - 1);
+    const start = Math.max(0, Math.min(activeIndex - 2, entries.length - maxItems));
+    const window = entries.slice(start, start + maxItems);
+    if (start > 0) {
+        window[0] = "ellipsis";
+    }
+    if (start + maxItems < entries.length) {
+        window[window.length - 1] = "ellipsis";
+    }
+    return window;
+}
+function fitPromptPieces(pieces, width) {
+    const separator = " · ";
+    let visiblePieces = pieces.filter((piece) => piece.value.length > 0);
+    let available = width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+    while (visiblePieces.length > 1 &&
+        available < minimumPieceLength(visiblePieces)) {
+        const removableIndex = visiblePieces.length === 4 ? 2 : visiblePieces.length - 2;
+        visiblePieces = visiblePieces.filter((_, index) => index !== removableIndex);
+        available =
+            width - terminalWidth(separator) * Math.max(0, visiblePieces.length - 1);
+    }
+    if (available <= 0 || available < minimumPieceLength(visiblePieces)) {
+        return middleEllipsize(visiblePieces.map((piece) => piece.value).join(separator), width);
+    }
+    const lengths = visiblePieces.map((piece) => Math.min(terminalWidth(piece.value), piece.max));
+    while (sum(lengths) > available) {
+        const index = largestShrinkablePieceIndex(visiblePieces, lengths);
+        if (index === -1)
+            break;
+        lengths[index] -= 1;
+    }
+    return visiblePieces
+        .map((piece, index) => piece.ellipsize(piece.value, lengths[index]))
+        .join(separator);
+}
+function minimumPieceLength(pieces) {
+    return sum(pieces.map((piece) => Math.min(terminalWidth(piece.value), piece.min)));
+}
+function largestShrinkablePieceIndex(pieces, lengths) {
+    let candidate = -1;
+    for (let index = 0; index < pieces.length; index += 1) {
+        if (lengths[index] <=
+            Math.min(terminalWidth(pieces[index].value), pieces[index].min)) {
+            continue;
+        }
+        if (candidate === -1 || lengths[index] > lengths[candidate]) {
+            candidate = index;
+        }
     }
-    return groups;
+    return candidate;
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}
+function filterSearchablePromptEntries(entries, query) {
+    const filtered = [];
+    let pendingGroup = null;
+    for (const entry of entries) {
+        if (!isSelectableEntry(entry)) {
+            pendingGroup = entry;
+            continue;
+        }
+        if (!entry.searchText.includes(query)) {
+            continue;
+        }
+        if (pendingGroup !== null) {
+            filtered.push(pendingGroup);
+            pendingGroup = null;
+        }
+        filtered.push(entry);
+    }
+    return filtered;
+}
+function isSelectableEntry(entry) {
+    return (entry !== undefined &&
+        entry.selectable !== false &&
+        typeof entry.value === "string");
+}
+function buildPromptSearchText(worktree) {
+    return [
+        worktree.repoName,
+        worktree.branch ?? "detached",
+        worktree.path,
+        worktree.label,
+        `${worktree.repoName}/${worktree.branch ?? "detached"}`,
+    ]
+        .join(" ")
+        .toLowerCase();
 }
 function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
     const lastWorkedTimestamp = info.lastCommitTimestamp === null ? null : info.lastCommitTimestamp * 1000;
@@ -94,12 +731,13 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
     const badges = buildStatusBadges(info);
     const recency = formatPromptRecency(lastActivityTimestamp, lastActivityType, now);
     const status = badges.length > 0 ? badges.map((badge) => `[${badge}]`).join(" ") : null;
+    const metadataParts = [status, recency].filter((part) => part !== null && part.length > 0);
+    const metadata = metadataParts.length === 0 ? null : metadataParts.join(" · ");
     const path = middleEllipsize(source.worktree.path, 76);
     const label = [
         middleEllipsize(source.repoName, 22),
         middleEllipsize(branch, 34),
-        status,
-        recency,
+        metadata,
         path,
     ]
         .filter((part) => part !== null && part.length > 0)
@@ -109,6 +747,7 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
         group: lastUsedTimestamp !== null ? "recent" : "other",
         label,
         lastActivityTimestamp,
+        metadata,
         repoName: source.repoName,
     };
 }
@@ -215,14 +854,71 @@ function scoreWorktreeMatch(entry, query) {
     return buildSearchText(entry.repoName, entry).includes(query) ? 1 : null;
 }
 function middleEllipsize(value, maxLength) {
-    if (value.length <= maxLength) {
+    if (terminalWidth(value) <= maxLength) {
         return value;
     }
     if (maxLength <= 1) {
         return "…";
     }
     const keep = maxLength - 1;
-    const start = Math.ceil(keep / 2);
-    const end = Math.floor(keep / 2);
-    return `${value.slice(0, start)}…${value.slice(value.length - end)}`;
+    const start = takeTerminalColumns(value, Math.ceil(keep / 2), "start");
+    const end = takeTerminalColumns(value, Math.floor(keep / 2), "end");
+    return `${start}…${end}`;
+}
+function startEllipsize(value, maxLength) {
+    if (terminalWidth(value) <= maxLength) {
+        return value;
+    }
+    if (maxLength <= 1) {
+        return "…";
+    }
+    return `…${takeTerminalColumns(value, maxLength - 1, "end")}`;
+}
+function takeTerminalColumns(value, maxWidth, direction) {
+    const characters = direction === "start" ? Array.from(value) : Array.from(value).reverse();
+    const kept = [];
+    let width = 0;
+    for (const character of characters) {
+        const characterWidth = terminalWidth(character);
+        if (width + characterWidth > maxWidth)
+            break;
+        kept.push(character);
+        width += characterWidth;
+    }
+    return direction === "start" ? kept.join("") : kept.reverse().join("");
+}
+function terminalWidth(value) {
+    let width = 0;
+    for (const character of Array.from(value)) {
+        width += characterTerminalWidth(character);
+    }
+    return width;
+}
+function characterTerminalWidth(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === undefined)
+        return 0;
+    if (isZeroWidthCodePoint(codePoint) || /\p{Mark}/u.test(character)) {
+        return 0;
+    }
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0 ||
+        codePoint === 0x200d ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
 }