typescript-virtual-container 1.5.6 → 1.5.8

package/dist/modules/neofetch.js

@@ -208,10 +208,10 @@ function resolveDefaults(info) {
             os: info.osName ?? `${readOsPrettyName() ?? os.type()} ${os.arch()}`,
             arch: os.arch(),
         },
-        resolution: info.resolution ?? "n/a (ssh)",
+        resolution: info.resolution ?? shellProps?.resolution ?? "n/a (ssh)",
         terminal: info.terminal ?? "unknown",
         cpu: info.cpu ?? resolveCpuLabel(),
-        gpu: info.gpu ?? "n/a",
+        gpu: info.gpu ?? shellProps?.gpu ?? "n/a",
         memoryUsedMiB: info.memoryUsedMiB ?? toMiB(usedMem),
         memoryTotalMiB: info.memoryTotalMiB ?? toMiB(totalMem),
     };

package/dist/modules/webTermRenderer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Minimal VT100 screen buffer for browser-side rendering.
+ * Handles the subset of escape sequences emitted by NanoEditor:
+ *   - CSI H / CSI row;colH  (cursor position)
+ *   - CSI K                  (erase to end of line)
+ *   - CSI 2J                 (erase display)
+ *   - CSI ?25l / ?25h        (cursor hide/show)
+ *   - CSI <n> m              (SGR — bold, reverse, fg, bg, reset)
+ */
+export interface Cell {
+    ch: string;
+    bold: boolean;
+    reverse: boolean;
+    fg: string | null;
+    bg: string | null;
+}
+export declare class WebTermRenderer {
+    private rows;
+    private cols;
+    private screen;
+    private curRow;
+    private curCol;
+    private cursorVisible;
+    private bold;
+    private reverse;
+    private fg;
+    private bg;
+    private buf;
+    constructor(rows: number, cols: number);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    private flush;
+    private handleCsi;
+    private handleSgr;
+    private putChar;
+    private makeScreen;
+    /** Render current screen state to an HTML string for a <pre> element. */
+    renderHtml(): string;
+    get cursorRow(): number;
+    get cursorCol(): number;
+    get isCursorVisible(): boolean;
+}

package/dist/modules/webTermRenderer.js

@@ -0,0 +1,291 @@
+/**
+ * Minimal VT100 screen buffer for browser-side rendering.
+ * Handles the subset of escape sequences emitted by NanoEditor:
+ *   - CSI H / CSI row;colH  (cursor position)
+ *   - CSI K                  (erase to end of line)
+ *   - CSI 2J                 (erase display)
+ *   - CSI ?25l / ?25h        (cursor hide/show)
+ *   - CSI <n> m              (SGR — bold, reverse, fg, bg, reset)
+ */
+const DEFAULT_CELL = { ch: " ", bold: false, reverse: false, fg: null, bg: null };
+function makeCell(partial) {
+    return { ...DEFAULT_CELL, ...partial };
+}
+export class WebTermRenderer {
+    rows;
+    cols;
+    screen;
+    curRow = 0;
+    curCol = 0;
+    cursorVisible = true;
+    // Current SGR state
+    bold = false;
+    reverse = false;
+    fg = null;
+    bg = null;
+    buf = "";
+    constructor(rows, cols) {
+        this.rows = rows;
+        this.cols = cols;
+        this.screen = this.makeScreen();
+    }
+    resize(rows, cols) {
+        const newScreen = this.makeScreen(rows, cols);
+        for (let r = 0; r < Math.min(rows, this.rows); r++) {
+            for (let c = 0; c < Math.min(cols, this.cols); c++) {
+                newScreen[r][c] = this.screen[r]?.[c] ?? makeCell();
+            }
+        }
+        this.rows = rows;
+        this.cols = cols;
+        this.screen = newScreen;
+        this.curRow = Math.min(this.curRow, rows - 1);
+        this.curCol = Math.min(this.curCol, cols - 1);
+    }
+    write(data) {
+        this.buf += data;
+        this.flush();
+    }
+    flush() {
+        let i = 0;
+        while (i < this.buf.length) {
+            const ch = this.buf[i];
+            if (ch === "\x1b") {
+                if (i + 1 >= this.buf.length)
+                    break; // wait for more data
+                const next = this.buf[i + 1];
+                if (next === "[") {
+                    // CSI — find terminator
+                    let j = i + 2;
+                    while (j < this.buf.length && (this.buf[j] < "@" || this.buf[j] > "~"))
+                        j++;
+                    if (j >= this.buf.length)
+                        break; // incomplete
+                    const seq = this.buf.slice(i + 2, j);
+                    const cmd = this.buf[j];
+                    this.handleCsi(seq, cmd);
+                    i = j + 1;
+                }
+                else {
+                    i += 2; // skip unknown ESC sequence
+                }
+            }
+            else if (ch === "\r") {
+                this.curCol = 0;
+                i++;
+            }
+            else if (ch === "\n") {
+                this.curRow = Math.min(this.curRow + 1, this.rows - 1);
+                i++;
+            }
+            else if (ch.charCodeAt(0) >= 32) {
+                this.putChar(ch);
+                i++;
+            }
+            else {
+                i++; // skip other control chars
+            }
+        }
+        this.buf = this.buf.slice(i);
+    }
+    handleCsi(seq, cmd) {
+        if (cmd === "H" || cmd === "f") {
+            // Cursor position: row;col (1-based)
+            const parts = seq.split(";").map((n) => Number.parseInt(n || "1", 10));
+            this.curRow = Math.max(0, Math.min((parts[0] ?? 1) - 1, this.rows - 1));
+            this.curCol = Math.max(0, Math.min((parts[1] ?? 1) - 1, this.cols - 1));
+            return;
+        }
+        if (cmd === "K") {
+            // Erase line from cursor to end
+            const mode = seq === "" ? 0 : Number.parseInt(seq, 10);
+            if (mode === 0) {
+                for (let c = this.curCol; c < this.cols; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            else if (mode === 1) {
+                for (let c = 0; c <= this.curCol; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            else if (mode === 2) {
+                for (let c = 0; c < this.cols; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            return;
+        }
+        if (cmd === "J") {
+            const mode = seq === "" ? 0 : Number.parseInt(seq, 10);
+            if (mode === 2) {
+                this.screen = this.makeScreen();
+                this.curRow = 0;
+                this.curCol = 0;
+            }
+            return;
+        }
+        if (cmd === "m") {
+            this.handleSgr(seq);
+            return;
+        }
+        if (cmd === "l" && seq === "?25") {
+            this.cursorVisible = false;
+            return;
+        }
+        if (cmd === "h" && seq === "?25") {
+            this.cursorVisible = true;
+            return;
+        }
+    }
+    handleSgr(seq) {
+        const codes = seq === "" ? [0] : seq.split(";").map((n) => Number.parseInt(n || "0", 10));
+        let i = 0;
+        while (i < codes.length) {
+            const code = codes[i];
+            if (code === 0) {
+                this.bold = false;
+                this.reverse = false;
+                this.fg = null;
+                this.bg = null;
+            }
+            else if (code === 1) {
+                this.bold = true;
+            }
+            else if (code === 7) {
+                this.reverse = true;
+            }
+            else if (code === 22) {
+                this.bold = false;
+            }
+            else if (code === 27) {
+                this.reverse = false;
+            }
+            else if (code >= 30 && code <= 37) {
+                this.fg = ANSI_COLORS[code - 30];
+            }
+            else if (code === 38) {
+                if (codes[i + 1] === 5 && codes[i + 2] !== undefined) {
+                    this.fg = xterm256(codes[i + 2]);
+                    i += 2;
+                }
+                else if (codes[i + 1] === 2 && codes[i + 4] !== undefined) {
+                    this.fg = `rgb(${codes[i + 2]},${codes[i + 3]},${codes[i + 4]})`;
+                    i += 4;
+                }
+            }
+            else if (code === 39) {
+                this.fg = null;
+            }
+            else if (code >= 40 && code <= 47) {
+                this.bg = ANSI_COLORS[code - 40];
+            }
+            else if (code === 48) {
+                if (codes[i + 1] === 5 && codes[i + 2] !== undefined) {
+                    this.bg = xterm256(codes[i + 2]);
+                    i += 2;
+                }
+                else if (codes[i + 1] === 2 && codes[i + 4] !== undefined) {
+                    this.bg = `rgb(${codes[i + 2]},${codes[i + 3]},${codes[i + 4]})`;
+                    i += 4;
+                }
+            }
+            else if (code === 49) {
+                this.bg = null;
+            }
+            else if (code >= 90 && code <= 97) {
+                this.fg = ANSI_COLORS_BRIGHT[code - 90];
+            }
+            else if (code >= 100 && code <= 107) {
+                this.bg = ANSI_COLORS_BRIGHT[code - 100];
+            }
+            i++;
+        }
+    }
+    putChar(ch) {
+        if (this.curRow >= this.rows || this.curCol >= this.cols)
+            return;
+        this.screen[this.curRow][this.curCol] = makeCell({
+            ch,
+            bold: this.bold,
+            reverse: this.reverse,
+            fg: this.fg,
+            bg: this.bg,
+        });
+        this.curCol++;
+        if (this.curCol >= this.cols) {
+            this.curCol = 0;
+            if (this.curRow < this.rows - 1)
+                this.curRow++;
+        }
+    }
+    makeScreen(rows = this.rows, cols = this.cols) {
+        return Array.from({ length: rows }, () => Array.from({ length: cols }, () => makeCell()));
+    }
+    /** Render current screen state to an HTML string for a <pre> element. */
+    renderHtml() {
+        let html = "";
+        for (let r = 0; r < this.rows; r++) {
+            const row = this.screen[r];
+            let spanOpen = false;
+            let lastStyle = "";
+            for (let c = 0; c < this.cols; c++) {
+                const cell = row[c];
+                const isCursor = this.cursorVisible && r === this.curRow && c === this.curCol;
+                let fg = cell.fg ?? "#ccc";
+                let bg = cell.bg ?? "transparent";
+                if (cell.reverse) {
+                    [fg, bg] = [bg === "transparent" ? "#000" : bg, fg];
+                }
+                if (cell.bold && !cell.fg)
+                    fg = "#fff";
+                if (isCursor) {
+                    [fg, bg] = [bg === "transparent" ? "#000" : bg, fg === "#ccc" ? "#ccc" : fg];
+                    bg = "#ccc";
+                    fg = "#000";
+                }
+                const style = `color:${fg};background:${bg};${cell.bold ? "font-weight:bold;" : ""}`;
+                if (style !== lastStyle) {
+                    if (spanOpen)
+                        html += "</span>";
+                    html += `<span style="${style}">`;
+                    spanOpen = true;
+                    lastStyle = style;
+                }
+                html += escHtml(cell.ch);
+            }
+            if (spanOpen)
+                html += "</span>";
+            if (r < this.rows - 1)
+                html += "\n";
+        }
+        return html;
+    }
+    get cursorRow() { return this.curRow; }
+    get cursorCol() { return this.curCol; }
+    get isCursorVisible() { return this.cursorVisible; }
+}
+function escHtml(ch) {
+    if (ch === "&")
+        return "&amp;";
+    if (ch === "<")
+        return "&lt;";
+    if (ch === ">")
+        return "&gt;";
+    return ch;
+}
+const ANSI_COLORS = ["#000", "#c00", "#0c0", "#cc0", "#00c", "#c0c", "#0cc", "#ccc"];
+const ANSI_COLORS_BRIGHT = ["#555", "#f55", "#5f5", "#ff5", "#55f", "#f5f", "#5ff", "#fff"];
+function xterm256(n) {
+    if (n < 16)
+        return (n < 8 ? ANSI_COLORS : ANSI_COLORS_BRIGHT)[n < 8 ? n : n - 8];
+    if (n < 232) {
+        const i = n - 16;
+        const r = Math.floor(i / 36) * 51;
+        const g = Math.floor((i % 36) / 6) * 51;
+        const b = (i % 6) * 51;
+        return `rgb(${r},${g},${b})`;
+    }
+    const v = (n - 232) * 10 + 8;
+    return `rgb(${v},${v},${v})`;
+}

package/dist/types/commands.d.ts

@@ -94,6 +94,10 @@ export interface ShellEnv {
     vars: Record<string, string>;
     /** Exit status of the last executed command. */
     lastExitCode: number;
+    /** @internal Cached split of vars.PATH — invalidated when _pathRaw !== vars.PATH. */
+    _pathRaw?: string;
+    /** @internal Pre-split PATH directories for resolveVfsBinary hot-path. */
+    _pathDirs?: string[];
 }
 /** Runtime context object passed to each command module. */
 export interface CommandContext {

package/dist/utils/argv.d.ts

@@ -0,0 +1,6 @@
+/** Returns true if `name` appears in `argv`. */
+export declare function getFlag(argv: string[], name: string): boolean;
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionString(argv: string[], name: string, fallback: string): string;
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionInt(argv: string[], name: string, fallback: number): number;

package/dist/utils/argv.js

@@ -0,0 +1,32 @@
+/** Returns true if `name` appears in `argv`. */
+export function getFlag(argv, name) {
+    return argv.includes(name);
+}
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionString(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return a.slice(prefix.length);
+        if (a === name) {
+            const next = argv[i + 1];
+            return (next && !next.startsWith("--")) ? next : fallback;
+        }
+    }
+    return fallback;
+}
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionInt(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return parseInt(a.slice(prefix.length), 10);
+        if (a === name) {
+            const next = argv[i + 1];
+            return next ? parseInt(next, 10) : fallback;
+        }
+    }
+    return fallback;
+}

package/dist/utils/expand.d.ts

@@ -61,10 +61,13 @@ export declare function expandAsync(input: string, env: Record<string, string>,
  * Supports * (any chars in segment) and ** (any path).
  * Returns the original pattern if no matches found (bash behavior).
  */
-export declare function expandGlob(pattern: string, cwd: string, vfs: {
+type GlobVfs = {
     list: (p: string) => string[];
     exists: (p: string) => boolean;
     stat: (p: string) => {
         type: string;
     };
-}): string[];
+    statType?: (p: string) => string | null;
+};
+export declare function expandGlob(pattern: string, cwd: string, vfs: GlobVfs): string[];
+export {};

package/dist/utils/expand.js

@@ -17,6 +17,24 @@
  *   $VAR          simple reference
  *   $((expr))     arithmetic (integer)
  */
+import { globToRegex } from "./glob";
+// Memoized shell-pattern → RegExp for ${VAR//pat/rep} etc. forms.
+// Key encodes anchor/greedy options to keep separate caches per form.
+const _shellPatCache = new Map();
+function shellPatToRegex(pat, anchor, greedy, global = false) {
+    const key = `${anchor}:${greedy ? "g" : "s"}:${global ? "G" : ""}:${pat}`;
+    let re = _shellPatCache.get(key);
+    if (re)
+        return re;
+    const esc = pat.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    const body = greedy
+        ? esc.replace(/\*/g, ".*").replace(/\?/g, ".")
+        : esc.replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+    const src = anchor === "prefix" ? `^${body}` : anchor === "suffix" ? `${body}$` : body;
+    re = new RegExp(src, global ? "g" : "");
+    _shellPatCache.set(key, re);
+    return re;
+}
 function tokenizeArith(expr, env) {
     const tokens = [];
     let i = 0;
@@ -193,25 +211,24 @@ export function evalArith(expr, env) {
  * Single-quoted content is passed through verbatim (POSIX sh behaviour).
  */
 function outsideSingleQuotes(input, replacer) {
+    // Fast path: no single quotes → apply replacer to whole string, no allocation
+    if (!input.includes("'"))
+        return replacer(input);
     const parts = [];
     let i = 0;
     while (i < input.length) {
         const sqIdx = input.indexOf("'", i);
         if (sqIdx === -1) {
-            // No more single quotes — expand the rest
             parts.push(replacer(input.slice(i)));
             break;
         }
-        // Expand the part before the single quote
         parts.push(replacer(input.slice(i, sqIdx)));
-        // Find closing single quote — everything inside is literal
         const closeIdx = input.indexOf("'", sqIdx + 1);
         if (closeIdx === -1) {
-            // Unclosed quote — treat rest as literal
             parts.push(input.slice(sqIdx));
             break;
         }
-        parts.push(input.slice(sqIdx, closeIdx + 1)); // include quotes
+        parts.push(input.slice(sqIdx, closeIdx + 1));
         i = closeIdx + 1;
     }
     return parts.join("");
@@ -327,10 +344,14 @@ export function expandBraces(token) {
     return expandBracesInternal(token, 0);
 }
 function expandArithmeticChunks(input, env) {
+    if (!input.includes("$(("))
+        return input;
     let result = "";
     let index = 0;
+    let flush = 0;
     while (index < input.length) {
         if (input[index] === "$" && input[index + 1] === "(" && input[index + 2] === "(") {
+            result += input.slice(flush, index);
             let scan = index + 3;
             let depth = 0;
             while (scan < input.length) {
@@ -347,6 +368,7 @@ function expandArithmeticChunks(input, env) {
                         const value = evalArith(expr, env);
                         result += Number.isNaN(value) ? "0" : String(value);
                         index = scan + 2;
+                        flush = index;
                         break;
                     }
                 }
@@ -354,16 +376,18 @@ function expandArithmeticChunks(input, env) {
             }
             if (scan >= input.length) {
                 result += input.slice(index);
-                break;
+                return result;
             }
             continue;
         }
-        result += input[index];
         index++;
     }
-    return result;
+    return result + input.slice(flush);
 }
 export function expandSync(input, env, lastExit = 0, home) {
+    // Fast path: nothing to expand (no $ and no ~ and no single quotes)
+    if (!input.includes("$") && !input.includes("~") && !input.includes("'"))
+        return input;
     const homePath = home ?? env.HOME ?? "/home/user";
     return outsideSingleQuotes(input, (chunk) => {
         let s = chunk;
@@ -413,7 +437,7 @@ export function expandSync(input, env, lastExit = 0, home) {
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\/\/([^/}]*)\/([^}]*)\}/g, (_, name, pat, rep) => {
             const val = env[name] ?? "";
             try {
-                return val.replace(new RegExp(pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, "."), "g"), rep);
+                return val.replace(shellPatToRegex(pat, "none", true, true), rep);
             }
             catch {
                 return val;
@@ -423,36 +447,20 @@ export function expandSync(input, env, lastExit = 0, home) {
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\/([^/}]*)\/([^}]*)\}/g, (_, name, pat, rep) => {
             const val = env[name] ?? "";
             try {
-                return val.replace(new RegExp(pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")), rep);
+                return val.replace(shellPatToRegex(pat, "none", true, false), rep);
             }
             catch {
                 return val;
             }
         });
         // ${VAR##pattern} — strip longest prefix
-        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)##([^}]+)\}/g, (_, name, pat) => {
-            const val = env[name] ?? "";
-            const re = new RegExp(`^${pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}`);
-            return val.replace(re, "");
-        });
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)##([^}]+)\}/g, (_, name, pat) => (env[name] ?? "").replace(shellPatToRegex(pat, "prefix", true), ""));
         // ${VAR#pattern} — strip shortest prefix
-        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)#([^}]+)\}/g, (_, name, pat) => {
-            const val = env[name] ?? "";
-            const re = new RegExp(`^${pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, ".")}`);
-            return val.replace(re, "");
-        });
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)#([^}]+)\}/g, (_, name, pat) => (env[name] ?? "").replace(shellPatToRegex(pat, "prefix", false), ""));
         // ${VAR%%pattern} — strip longest suffix
-        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)%%([^}]+)\}/g, (_, name, pat) => {
-            const val = env[name] ?? "";
-            const re = new RegExp(`${pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
-            return val.replace(re, "");
-        });
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)%%([^}]+)\}/g, (_, name, pat) => (env[name] ?? "").replace(shellPatToRegex(pat, "suffix", true), ""));
         // ${VAR%pattern} — strip shortest suffix
-        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)%([^}]+)\}/g, (_, name, pat) => {
-            const val = env[name] ?? "";
-            const re = new RegExp(`${pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, ".")}$`);
-            return val.replace(re, "");
-        });
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)%([^}]+)\}/g, (_, name, pat) => (env[name] ?? "").replace(shellPatToRegex(pat, "suffix", false), ""));
         // ${VAR}
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => env[name] ?? "");
         // $VAR and positional params $1 $2 ...
@@ -540,12 +548,16 @@ export async function expandAsync(input, env, lastExit, runCmd) {
             env[depthKey] = String(currentDepth);
     }
 }
-// ─── Glob expansion ──────────────────────────────────────────────────────────
-/**
- * Expand a glob pattern against a VirtualShell VFS.
- * Supports * (any chars in segment) and ** (any path).
- * Returns the original pattern if no matches found (bash behavior).
- */
+function nodeType(vfs, p) {
+    if (vfs.statType)
+        return vfs.statType(p);
+    try {
+        return vfs.stat(p).type;
+    }
+    catch {
+        return null;
+    }
+}
 export function expandGlob(pattern, cwd, vfs) {
     // No glob chars → return as-is
     if (!pattern.includes('*') && !pattern.includes('?'))
@@ -567,14 +579,14 @@ function matchGlob(dir, segments, vfs) {
     // ** matches zero or more path segments
     if (seg === '**') {
         const all = walkAll(dir, vfs);
-        return rest.length === 0 ? all : all.flatMap(d => {
-            try {
-                if (vfs.stat(d).type === 'directory')
-                    return matchGlob(d, rest, vfs);
-            }
-            catch { }
-            return [];
-        });
+        if (rest.length === 0)
+            return all;
+        const out = [];
+        for (const d of all) {
+            if (nodeType(vfs, d) === 'directory')
+                out.push(...matchGlob(d, rest, vfs));
+        }
+        return out;
     }
     let entries = [];
     try {
@@ -584,20 +596,20 @@ function matchGlob(dir, segments, vfs) {
         return [];
     }
     const re = globToRegex(seg);
-    return entries
-        .filter(e => !e.startsWith('.') || seg.startsWith('.'))
-        .filter(e => re.test(e))
-        .flatMap(e => {
+    const showHidden = seg.startsWith('.');
+    const matched = [];
+    for (const e of entries) {
+        if ((!showHidden && e.startsWith('.')) || !re.test(e))
+            continue;
         const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
-        if (rest.length === 0)
-            return [full];
-        try {
-            if (vfs.stat(full).type === 'directory')
-                return matchGlob(full, rest, vfs);
+        if (rest.length === 0) {
+            matched.push(full);
+            continue;
         }
-        catch { }
-        return [];
-    });
+        if (nodeType(vfs, full) === 'directory')
+            matched.push(...matchGlob(full, rest, vfs));
+    }
+    return matched;
 }
 function walkAll(dir, vfs) {
     const results = [dir];
@@ -610,17 +622,8 @@ function walkAll(dir, vfs) {
     }
     for (const e of entries) {
         const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
-        try {
-            if (vfs.stat(full).type === 'directory')
-                results.push(...walkAll(full, vfs));
-        }
-        catch { }
+        if (nodeType(vfs, full) === 'directory')
+            results.push(...walkAll(full, vfs));
     }
     return results;
 }
-function globToRegex(pattern) {
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*')
-        .replace(/\?/g, '.');
-    return new RegExp(`^${escaped}$`);
-}

package/dist/utils/glob.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert a shell glob pattern to a RegExp.
+ * Supports: * (any chars), ? (one char), [...] (char class), flags (e.g. "i").
+ * Results are memoized — same pattern+flags returns the cached instance.
+ */
+export declare function globToRegex(pattern: string, flags?: string): RegExp;