@travisennis/acai 0.0.9 → 0.0.11

package/dist/tui/tui.js

@@ -1,7 +1,8 @@
 /**
  * Minimal TUI implementation with differential rendering
  */
-import { getTerminalSize, isCtrlC, isCtrlZ, isEscape, } from "../terminal/control.js";
+import { getTerminalSize, isCtrlC, isCtrlD, isCtrlM, isCtrlN, isCtrlO, isCtrlR, isCtrlZ, isEscape, } from "../terminal/control.js";
+import { isShiftTab } from "../terminal/keys.js";
 import style from "../terminal/style.js";
 import { visibleWidth } from "./utils.js";
 export { visibleWidth };
@@ -19,6 +20,15 @@ export class Container {
             this.children.splice(index, 1);
         }
     }
+    insertChildBefore(beforeComponent, newComponent) {
+        const index = this.children.indexOf(beforeComponent);
+        if (index !== -1) {
+            this.children.splice(index, 0, newComponent);
+        }
+        else {
+            this.children.push(newComponent);
+        }
+    }
     clear() {
         this.children = [];
     }
@@ -28,6 +38,14 @@ export class Container {
 }
 /**
  * TUI - Main class for managing terminal UI with differential rendering
+ *
+ * The TUI splits its children into two regions:
+ * - Scrollable content: children added before setFixedFooterStart()
+ * - Fixed footer: children added after setFixedFooterStart()
+ *
+ * The scrollable content region supports virtual scrolling via trackpad/mouse
+ * wheel. The fixed footer (editor, footer bar, notifications) is always
+ * pinned to the bottom of the terminal.
  */
 // biome-ignore lint/style/useNamingConvention: override
 export class TUI extends Container {
@@ -37,14 +55,41 @@ export class TUI extends Container {
     isRendering = false;
     renderAgain = false;
     activeModal = null;
+    scrollOffset = 0;
+    lastScrollableHeight = 0;
+    fixedFooterIndex = -1;
+    isUserScrolledUp = false;
     onCtrlC;
+    onCtrlD;
+    onReconstructSession;
+    onCtrlN;
+    onCtrlO;
+    /** Callback invoked when Ctrl+M is pressed - opens model selector. */
+    onCtrlM;
+    onCtrlR;
+    onShiftTab;
     constructor(terminal) {
         super();
         this.terminal = terminal;
     }
+    /**
+     * Mark the boundary between scrollable content and fixed footer.
+     * All children added after this call will be rendered as fixed
+     * footer content pinned to the bottom of the terminal.
+     */
+    setFixedFooterStart() {
+        this.fixedFooterIndex = this.children.length;
+    }
     setFocus(component) {
         this.focusedComponent = component;
     }
+    /**
+     * Get the underlying terminal instance for external mode operations.
+     * Used primarily for spawning external editors.
+     */
+    getTerminal() {
+        return this.terminal;
+    }
     start() {
         this.terminal.start((data) => this.handleInput(data), () => this.requestRender());
         this.terminal.onResume(() => this.requestRender());
@@ -69,7 +114,15 @@ export class TUI extends Container {
         });
     }
     inBracketedPaste = false;
+    focusedComponentWantsNavigation() {
+        return this.focusedComponent?.wantsNavigationKeys?.() ?? false;
+    }
     handleInput(data) {
+        // Handle mouse tracking events (SGR format: \x1b[<button;x;yM)
+        if (data.startsWith("\x1b[<")) {
+            this.handleMouseEvent(data);
+            return;
+        }
         if (data.includes("\x1b[200~")) {
             this.inBracketedPaste = true;
         }
@@ -94,6 +147,36 @@ export class TUI extends Container {
                 process.exit(0);
             }
         }
+        // Handle Ctrl+D - exit only if editor is empty (handled by Repl)
+        if (isCtrlD(data)) {
+            if (this.onCtrlD) {
+                this.onCtrlD();
+            }
+            return;
+        }
+        const keyBindings = [
+            { check: isCtrlO, handler: this.onCtrlO },
+            { check: isCtrlR, handler: this.onCtrlR },
+            { check: isCtrlN, handler: this.onCtrlN },
+            { check: isCtrlM, handler: this.onCtrlM },
+        ];
+        for (const binding of keyBindings) {
+            if (binding.check(data)) {
+                binding.handler?.();
+                return;
+            }
+        }
+        // Handle Shift+Tab - cycle mode only when no modal is active,
+        // the focused component won't handle navigation (e.g., model selector),
+        // and the editor isn't showing autocomplete
+        if (isShiftTab(data) && !this.inBracketedPaste) {
+            if (!this.activeModal && !this.focusedComponentWantsNavigation()) {
+                if (this.onShiftTab) {
+                    this.onShiftTab();
+                }
+                return;
+            }
+        }
         // Handle Escape key to close modal if one is active
         if (isEscape(data) && this.activeModal) {
             this.hideModal();
@@ -106,9 +189,69 @@ export class TUI extends Container {
         }
         else if (this.focusedComponent?.handleInput) {
             this.focusedComponent.handleInput(data);
+            this.scrollToBottom();
+            this.requestRender();
+        }
+    }
+    handleMouseEvent(data) {
+        // SGR mouse format: \x1b[<button;x;yM (press) or \x1b[<button;x;ym (release)
+        // Extract button code between "<" and first ";"
+        const start = data.indexOf("<");
+        const semi = data.indexOf(";", start);
+        if (start === -1 || semi === -1)
+            return;
+        const button = Number.parseInt(data.slice(start + 1, semi), 10);
+        const scrollLines = 3;
+        const { rows } = getTerminalSize();
+        const fixedHeight = this.getFixedFooterHeight(this.terminal.columns);
+        const scrollableViewport = rows - fixedHeight;
+        // Button 64 = scroll up, button 65 = scroll down
+        if (button === 64) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - scrollLines);
+            const maxOffset = Math.max(0, this.lastScrollableHeight - scrollableViewport);
+            this.isUserScrolledUp = this.scrollOffset < maxOffset;
+            this.requestRender();
+        }
+        else if (button === 65) {
+            const maxOffset = Math.max(0, this.lastScrollableHeight - scrollableViewport);
+            this.scrollOffset = Math.min(maxOffset, this.scrollOffset + scrollLines);
+            this.isUserScrolledUp = this.scrollOffset < maxOffset;
             this.requestRender();
         }
     }
+    scrollToBottom() {
+        const { rows } = getTerminalSize();
+        const fixedHeight = this.getFixedFooterHeight(this.terminal.columns);
+        const scrollableViewport = rows - fixedHeight;
+        this.scrollOffset = Math.max(0, this.lastScrollableHeight - scrollableViewport);
+        this.isUserScrolledUp = false;
+    }
+    getFixedFooterHeight(width) {
+        if (this.fixedFooterIndex < 0)
+            return 0;
+        let height = 0;
+        for (let i = this.fixedFooterIndex; i < this.children.length; i++) {
+            height += this.children[i].render(width).length;
+        }
+        return height;
+    }
+    renderScrollableContent(width) {
+        const end = this.fixedFooterIndex >= 0 ? this.fixedFooterIndex : this.children.length;
+        const lines = [];
+        for (let i = 0; i < end; i++) {
+            lines.push(...this.children[i].render(width));
+        }
+        return lines;
+    }
+    renderFixedFooter(width) {
+        if (this.fixedFooterIndex < 0)
+            return [];
+        const lines = [];
+        for (let i = this.fixedFooterIndex; i < this.children.length; i++) {
+            lines.push(...this.children[i].render(width));
+        }
+        return lines;
+    }
     doRender() {
         if (this.isRendering) {
             this.renderAgain = true;
@@ -117,13 +260,32 @@ export class TUI extends Container {
         this.isRendering = true;
         try {
             const width = this.terminal.columns;
-            // Render all components to get new lines
-            const newLines = this.render(width);
+            const { rows } = getTerminalSize();
+            // Render fixed footer and scrollable content separately
+            const fixedLines = this.renderFixedFooter(width);
+            const scrollableLines = this.renderScrollableContent(width);
+            this.lastScrollableHeight = scrollableLines.length;
+            const fixedHeight = fixedLines.length;
+            const scrollableViewport = rows - fixedHeight;
+            // Auto-scroll to bottom when new content arrives,
+            // unless the user has explicitly scrolled up
+            if (!this.isUserScrolledUp) {
+                this.scrollOffset = Math.max(0, scrollableLines.length - scrollableViewport);
+            }
+            // Clamp scroll offset
+            const maxOffset = Math.max(0, scrollableLines.length - scrollableViewport);
+            if (this.scrollOffset > maxOffset) {
+                this.scrollOffset = maxOffset;
+            }
+            // Apply scroll offset to get visible scrollable lines
+            const visibleScrollable = scrollableLines.slice(this.scrollOffset, this.scrollOffset + scrollableViewport);
+            // Combine visible scrollable content with fixed footer
+            const visibleLines = [...visibleScrollable, ...fixedLines];
             // Build output buffer using array join (more efficient than string concat)
             const bufferParts = [
                 "\x1b[?2026h", // Begin synchronized output
                 "\x1b[3J\x1b[2J\x1b[H", // Clear scrollback, screen, and home
-                newLines.join("\r\n"),
+                visibleLines.join("\r\n"),
             ];
             // Render modal on top if active
             if (this.activeModal) {
@@ -154,43 +316,6 @@ export class TUI extends Container {
             }
         }
     }
-    // private positionCursor(
-    //   componentCursorPos: [number, number] | null,
-    // ): void {
-    //   if (!componentCursorPos) {
-    //     // No cursor position from component, hide cursor
-    //     this.terminal.hideCursor();
-    //     return;
-    //   }
-    //   const [cursorRow, cursorCol] = componentCursorPos;
-    //
-    //   // Calculate absolute cursor position in the terminal
-    //   // We need to find which line in newLines corresponds to the component's cursor row
-    //   // and then position the cursor at that line and column
-    //
-    //   // Find the line offset for the focused component
-    //   let componentStartLine = 0;
-    //   if (this.focusedComponent) {
-    //     // Find the line where this component starts by summing heights of previous components
-    //     for (const child of this.children) {
-    //       if (child === this.focusedComponent) {
-    //         break;
-    //       }
-    //       // Use the already-rendered lines to calculate height, not re-render
-    //       const childLines = child.render(this.terminal.columns);
-    //       componentStartLine += childLines.length;
-    //     }
-    //   }
-    //
-    //   const absoluteRow = componentStartLine + cursorRow;
-    //   const absoluteCol = cursorCol;
-    //
-    //   // Position cursor using absolute positioning
-    //   // Move to home position first, then move down to row, then right to column
-    //   // Note: terminal rows/columns are 1-indexed, so we add 1
-    //   this.terminal.write(`\x1b[H\x1b[${absoluteRow + 1}B\x1b[${absoluteCol + 1}G`);
-    //   this.terminal.showCursor();
-    // }
     /**
      * Show a modal dialog
      */

package/dist/tui/utils.d.ts

@@ -7,11 +7,7 @@
  * - Tabs (replaced with 3 spaces for consistent width)
  */
 export declare function visibleWidth(str: string): number;
-/**
- * Truncate text to fit within a maximum visible width, preserving ANSI codes.
- * Adds ellipsis if truncation occurs.
- */
-export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string): string;
+export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string, pad?: boolean): string;
 /**
  * Apply background color to a line, padding to full width.
  *

package/dist/tui/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tui/utils.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AA4BD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAQ,GACf,MAAM,CA+DR;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,CASR"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tui/utils.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AAwOD,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAQ,EAChB,GAAG,UAAQ,GACV,MAAM,CAuER;AAwHD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAC7B,MAAM,CASR"}

package/dist/tui/utils.js

@@ -1,5 +1,17 @@
 import { getSegmenter } from "../terminal/segmenter.js";
 import stringWidth from "../terminal/string-width.js";
+/**
+ * Check if a string contains only printable ASCII characters (0x20-0x7e).
+ */
+function isPrintableAscii(str) {
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        if (code < 0x20 || code > 0x7e) {
+            return false;
+        }
+    }
+    return true;
+}
 /**
  * Calculate the visible width of a string in terminal columns.
  * This correctly handles:
@@ -13,6 +25,12 @@ export function visibleWidth(str) {
     const normalized = str.replace(/\t/g, "   ");
     return stringWidth(normalized);
 }
+/**
+ * Get the width of a single grapheme cluster.
+ */
+function graphemeWidth(grapheme) {
+    return stringWidth(grapheme);
+}
 /**
  * Extract ANSI escape sequences from a string at the given position.
  */
@@ -32,64 +50,273 @@ function extractAnsiCode(str, pos) {
     }
     return null;
 }
-/**
- * Truncate text to fit within a maximum visible width, preserving ANSI codes.
- * Adds ellipsis if truncation occurs.
- */
-export function truncateToWidth(text, maxWidth, ellipsis = "...") {
-    const textVisibleWidth = visibleWidth(text);
-    if (textVisibleWidth <= maxWidth) {
-        return text;
+function createInitialState() {
+    return {
+        result: "",
+        pendingAnsi: "",
+        visibleSoFar: 0,
+        keptWidth: 0,
+        keepContiguousPrefix: true,
+        overflowed: false,
+    };
+}
+function processAnsiCode(state, text, pos) {
+    const ansi = extractAnsiCode(text, pos);
+    if (ansi) {
+        state.pendingAnsi += ansi.code;
+        return ansi.length;
+    }
+    return 0;
+}
+function processTab(state, targetWidth, maxWidth) {
+    if (state.keepContiguousPrefix && state.keptWidth + 3 <= targetWidth) {
+        if (state.pendingAnsi) {
+            state.result += state.pendingAnsi;
+            state.pendingAnsi = "";
+        }
+        state.result += "\t";
+        state.keptWidth += 3;
+    }
+    else {
+        state.keepContiguousPrefix = false;
+        state.pendingAnsi = "";
+    }
+    state.visibleSoFar += 3;
+    if (state.visibleSoFar > maxWidth) {
+        state.overflowed = true;
+        return true;
+    }
+    return false;
+}
+function processGraphemeSegment(state, segment, targetWidth, maxWidth) {
+    const width = graphemeWidth(segment);
+    if (state.keepContiguousPrefix && state.keptWidth + width <= targetWidth) {
+        if (state.pendingAnsi) {
+            state.result += state.pendingAnsi;
+            state.pendingAnsi = "";
+        }
+        state.result += segment;
+        state.keptWidth += width;
+    }
+    else {
+        state.keepContiguousPrefix = false;
+        state.pendingAnsi = "";
+    }
+    state.visibleSoFar += width;
+    if (state.visibleSoFar > maxWidth) {
+        state.overflowed = true;
+        return true;
+    }
+    return false;
+}
+function truncateSimple(text, targetWidth, maxWidth) {
+    const state = createInitialState();
+    for (const { segment } of getSegmenter().segment(text)) {
+        if (processGraphemeSegment(state, segment, targetWidth, maxWidth)) {
+            break;
+        }
+    }
+    return {
+        result: state.result,
+        keptWidth: state.keptWidth,
+        overflowed: state.overflowed,
+        visibleSoFar: state.visibleSoFar,
+    };
+}
+function truncateComplex(text, targetWidth, maxWidth) {
+    const state = createInitialState();
+    let i = 0;
+    while (i < text.length && !state.overflowed) {
+        const ansiSkip = processAnsiCode(state, text, i);
+        if (ansiSkip > 0) {
+            i += ansiSkip;
+            continue;
+        }
+        if (text[i] === "\t") {
+            if (processTab(state, targetWidth, maxWidth)) {
+                break;
+            }
+            i++;
+            continue;
+        }
+        // Find end of current text segment (until tab or ANSI)
+        let end = i;
+        while (end < text.length && text[end] !== "\t") {
+            const nextAnsi = extractAnsiCode(text, end);
+            if (nextAnsi) {
+                break;
+            }
+            end++;
+        }
+        // Process graphemes in this segment
+        for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
+            if (processGraphemeSegment(state, segment, targetWidth, maxWidth)) {
+                break;
+            }
+        }
+        i = end;
+    }
+    return {
+        result: state.result,
+        keptWidth: state.keptWidth,
+        overflowed: state.overflowed,
+        exhaustedInput: i >= text.length,
+        visibleSoFar: state.visibleSoFar,
+    };
+}
+function handleOversizedEllipsis(text, maxWidth, ellipsis, pad) {
+    const textWidth = visibleWidth(text);
+    if (textWidth <= maxWidth) {
+        return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+    }
+    const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+    if (clippedEllipsis.width === 0) {
+        return pad ? " ".repeat(maxWidth) : "";
+    }
+    return finalizeTruncatedResult("", 0, clippedEllipsis.text, clippedEllipsis.width, maxWidth, pad);
+}
+export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
+    if (maxWidth <= 0) {
+        return "";
+    }
+    if (text.length === 0) {
+        return pad ? " ".repeat(maxWidth) : "";
     }
     const ellipsisWidth = visibleWidth(ellipsis);
+    // Handle case where ellipsis is wider than maxWidth
+    if (ellipsisWidth >= maxWidth) {
+        const result = handleOversizedEllipsis(text, maxWidth, ellipsis, pad);
+        if (result !== null) {
+            return result;
+        }
+    }
+    // Fast path: pure ASCII printable
+    if (isPrintableAscii(text)) {
+        if (text.length <= maxWidth) {
+            return pad ? text + " ".repeat(maxWidth - text.length) : text;
+        }
+        const targetWidth = maxWidth - ellipsisWidth;
+        return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+    }
     const targetWidth = maxWidth - ellipsisWidth;
-    if (targetWidth <= 0) {
-        return ellipsis.substring(0, maxWidth);
+    const hasAnsi = text.includes("\x1b");
+    const hasTabs = text.includes("\t");
+    let truncatedResult;
+    let exhaustedInput;
+    if (!hasAnsi && !hasTabs) {
+        truncatedResult = truncateSimple(text, targetWidth, maxWidth);
+        exhaustedInput = !truncatedResult.overflowed;
     }
-    // Separate ANSI codes from visible content using grapheme segmentation
+    else {
+        const complexResult = truncateComplex(text, targetWidth, maxWidth);
+        truncatedResult = complexResult;
+        exhaustedInput = complexResult.exhaustedInput;
+    }
+    // Text fits completely
+    if (!truncatedResult.overflowed && exhaustedInput) {
+        return pad
+            ? text + " ".repeat(Math.max(0, maxWidth - truncatedResult.visibleSoFar))
+            : text;
+    }
+    return finalizeTruncatedResult(truncatedResult.result, truncatedResult.keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+ * Truncate a single fragment to a maximum width.
+ */
+function truncateFragmentToWidth(text, maxWidth) {
+    if (maxWidth <= 0 || text.length === 0) {
+        return { text: "", width: 0 };
+    }
+    if (isPrintableAscii(text)) {
+        const clipped = text.slice(0, maxWidth);
+        return { text: clipped, width: clipped.length };
+    }
+    const hasAnsi = text.includes("\x1b");
+    const hasTabs = text.includes("\t");
+    if (!hasAnsi && !hasTabs) {
+        let result = "";
+        let width = 0;
+        for (const { segment } of getSegmenter().segment(text)) {
+            const w = graphemeWidth(segment);
+            if (width + w > maxWidth) {
+                break;
+            }
+            result += segment;
+            width += w;
+        }
+        return { text: result, width };
+    }
+    let result = "";
+    let width = 0;
     let i = 0;
-    const segments = [];
+    let pendingAnsi = "";
     while (i < text.length) {
-        const ansiResult = extractAnsiCode(text, i);
-        if (ansiResult) {
-            segments.push({ type: "ansi", value: ansiResult.code });
-            i += ansiResult.length;
+        const ansi = extractAnsiCode(text, i);
+        if (ansi) {
+            pendingAnsi += ansi.code;
+            i += ansi.length;
+            continue;
         }
-        else {
-            // Find the next ANSI code or end of string
-            let end = i;
-            while (end < text.length) {
-                const nextAnsi = extractAnsiCode(text, end);
-                if (nextAnsi)
-                    break;
-                end++;
+        if (text[i] === "\t") {
+            if (width + 3 > maxWidth) {
+                break;
+            }
+            if (pendingAnsi) {
+                result += pendingAnsi;
+                pendingAnsi = "";
+            }
+            result += "\t";
+            width += 3;
+            i++;
+            continue;
+        }
+        let end = i;
+        while (end < text.length && text[end] !== "\t") {
+            const nextAnsi = extractAnsiCode(text, end);
+            if (nextAnsi) {
+                break;
+            }
+            end++;
+        }
+        for (const { segment } of getSegmenter().segment(text.slice(i, end))) {
+            const w = graphemeWidth(segment);
+            if (width + w > maxWidth) {
+                return { text: result, width };
             }
-            // Segment this non-ANSI portion into graphemes
-            const textPortion = text.slice(i, end);
-            for (const seg of getSegmenter().segment(textPortion)) {
-                segments.push({ type: "grapheme", value: seg.segment });
+            if (pendingAnsi) {
+                result += pendingAnsi;
+                pendingAnsi = "";
             }
-            i = end;
+            result += segment;
+            width += w;
         }
+        i = end;
     }
-    // Build truncated string from segments
-    let result = "";
-    let currentWidth = 0;
-    for (const seg of segments) {
-        if (seg.type === "ansi") {
-            result += seg.value;
-            continue;
+    return { text: result, width };
+}
+/**
+ * Finalize a truncated result with proper ANSI reset codes.
+ * Only adds reset codes if the prefix contains ANSI sequences.
+ */
+function finalizeTruncatedResult(prefix, prefixWidth, ellipsis, ellipsisWidth, maxWidth, pad) {
+    const hasAnsi = prefix.includes("\x1b");
+    const visibleWidth = prefixWidth + ellipsisWidth;
+    let result;
+    if (hasAnsi) {
+        const reset = "\x1b[0m";
+        if (ellipsis.length > 0) {
+            result = `${prefix}${reset}${ellipsis}${reset}`;
         }
-        const grapheme = seg.value;
-        const graphemeWidth = visibleWidth(grapheme);
-        if (currentWidth + graphemeWidth > targetWidth) {
-            break;
+        else {
+            result = `${prefix}${reset}`;
         }
-        result += grapheme;
-        currentWidth += graphemeWidth;
     }
-    // Add reset code before ellipsis to prevent styling leaking into it
-    return `${result}\x1b[0m${ellipsis}`;
+    else {
+        result = ellipsis.length > 0 ? `${prefix}${ellipsis}` : prefix;
+    }
+    return pad
+        ? result + " ".repeat(Math.max(0, maxWidth - visibleWidth))
+        : result;
 }
 /**
  * Apply background color to a line, padding to full width.

package/dist/utils/bash/parse.d.ts

@@ -0,0 +1,19 @@
+interface ControlOperator {
+    op: "||" | "&&" | ";;" | "|&" | "<(" | "<<<" | ">>" | ">&" | "&" | ";" | "(" | ")" | "|" | "<" | ">";
+}
+interface GlobOperator {
+    op: "glob";
+    pattern: string;
+}
+interface CommentOperator {
+    comment: string;
+}
+type ParseEntry = string | ControlOperator | GlobOperator | CommentOperator;
+interface ParseOptions {
+    escape?: string;
+}
+type EnvFunction = (key: string) => unknown;
+export declare function parse(s: string, env?: Record<string, string | undefined> | EnvFunction, opts?: ParseOptions): ParseEntry[];
+export declare function parse<T extends object | string>(s: string, env: (key: string) => T | undefined, opts?: ParseOptions): (ParseEntry | T)[];
+export {};
+//# sourceMappingURL=parse.d.ts.map

package/dist/utils/bash/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../source/utils/bash/parse.ts"],"names":[],"mappings":"AA+BA,UAAU,eAAe;IACvB,EAAE,EACE,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAC;CACT;AAED,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,UAAU,GAAG,MAAM,GAAG,eAAe,GAAG,YAAY,GAAG,eAAe,CAAC;AAE5E,UAAU,YAAY;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AA8L5C,wBAAgB,KAAK,CACnB,CAAC,EAAE,MAAM,EACT,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,WAAW,EACtD,IAAI,CAAC,EAAE,YAAY,GAClB,UAAU,EAAE,CAAC;AAChB,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC7C,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,EACnC,IAAI,CAAC,EAAE,YAAY,GAClB,CAAC,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC"}