typescript-virtual-container 1.5.5 → 1.5.7

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;
@@ -377,6 +401,19 @@ export function expandSync(input, env, lastExit = 0, home) {
         s = s.replace(/\$LINENO\b/g, "1");
         // $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
         s = expandArithmeticChunks(s, env);
+        // ${arr[@]} and ${arr[*]} — all array elements
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)[@*]\}/g, (_, name) => env[name] ?? "");
+        // ${arr[N]} — single array element
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\[(\d+)\]\}/g, (_, name, idx) => env[`${name}[${idx}]`] ?? "");
+        // ${#arr[@]} — array length
+        s = s.replace(/\$\{#([A-Za-z_][A-Za-z0-9_]*)[@*]\}/g, (_, name) => {
+            let count = 0;
+            for (const k of Object.keys(env)) {
+                if (k.startsWith(`${name}[`))
+                    count++;
+            }
+            return String(count);
+        });
         // ${#VAR} — string length
         s = s.replace(/\$\{#([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => String((env[name] ?? "").length));
         // ${VAR:-default}
@@ -389,6 +426,41 @@ export function expandSync(input, env, lastExit = 0, home) {
         });
         // ${VAR:+alternate}
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):\+([^}]*)\}/g, (_, name, alt) => env[name] !== undefined && env[name] !== "" ? alt : "");
+        // ${VAR:offset:len} and ${VAR:offset}
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):(-?\d+)(?::(\d+))?\}/g, (_, name, offset, len) => {
+            const val = env[name] ?? "";
+            const off = parseInt(offset, 10);
+            const start = off < 0 ? Math.max(0, val.length + off) : Math.min(off, val.length);
+            return len !== undefined ? val.slice(start, start + parseInt(len, 10)) : val.slice(start);
+        });
+        // ${VAR//pattern/replace} — replace all
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\/\/([^/}]*)\/([^}]*)\}/g, (_, name, pat, rep) => {
+            const val = env[name] ?? "";
+            try {
+                return val.replace(shellPatToRegex(pat, "none", true, true), rep);
+            }
+            catch {
+                return val;
+            }
+        });
+        // ${VAR/pattern/replace} — replace first
+        s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\/([^/}]*)\/([^}]*)\}/g, (_, name, pat, rep) => {
+            const val = env[name] ?? "";
+            try {
+                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) => (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) => (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) => (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) => (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 ...
@@ -476,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('?'))
@@ -503,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 {
@@ -520,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];
@@ -546,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;

package/dist/utils/glob.js

@@ -0,0 +1,34 @@
+const _globCache = new Map();
+/**
+ * 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 function globToRegex(pattern, flags = "") {
+    const key = `${flags}:${pattern}`;
+    const cached = _globCache.get(key);
+    if (cached)
+        return cached;
+    let re = "^";
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "*")
+            re += ".*";
+        else if (c === "?")
+            re += ".";
+        else if (c === "[") {
+            const close = pattern.indexOf("]", i + 1);
+            if (close === -1)
+                re += "\\[";
+            else {
+                re += `[${pattern.slice(i + 1, close)}]`;
+                i = close;
+            }
+        }
+        else
+            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    const result = new RegExp(`${re}$`, flags);
+    _globCache.set(key, result);
+    return result;
+}

package/dist/utils/tokenize.js

@@ -51,9 +51,11 @@ export function tokenizeCommand(input) {
             continue;
         }
         // Handle 2>&1, 2>>, 2>, >&, >>
-        if (!inQ && ch === "2" && (next === ">")) {
-            const rest = input.slice(i + 1);
-            if (rest.startsWith(">>&1") || rest.startsWith(">> &1")) {
+        if (!inQ && ch === "2" && next === ">") {
+            const c2 = input[i + 2];
+            const c3 = input[i + 3];
+            const c4 = input[i + 4];
+            if (c2 === ">" && c3 === "&" && c4 === "1") {
                 if (current) {
                     tokens.push(current);
                     current = "";
@@ -62,7 +64,7 @@ export function tokenizeCommand(input) {
                 i += 5;
                 continue;
             }
-            if (rest.startsWith(">&1")) {
+            if (c2 === "&" && c3 === "1") {
                 if (current) {
                     tokens.push(current);
                     current = "";
@@ -71,7 +73,7 @@ export function tokenizeCommand(input) {
                 i += 4;
                 continue;
             }
-            if (rest.startsWith(">>")) {
+            if (c2 === ">") {
                 if (current) {
                     tokens.push(current);
                     current = "";
@@ -80,15 +82,13 @@ export function tokenizeCommand(input) {
                 i += 3;
                 continue;
             }
-            if (rest.startsWith(">")) {
-                if (current) {
-                    tokens.push(current);
-                    current = "";
-                }
-                tokens.push("2>");
-                i += 2;
-                continue;
+            if (current) {
+                tokens.push(current);
+                current = "";
             }
+            tokens.push("2>");
+            i += 2;
+            continue;
         }
         if ((ch === ">" || ch === "<") && !inQ) {
             if (current) {

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "files": [
     "dist/",
     "README.md",
@@ -32,12 +32,12 @@
     "lint:write": "bunx --bun @biomejs/biome lint --write ./src",
     "test": "bun run test-salve",
     "test-battery": "bun test tests/",
-    "test-salve": "for f in tests/*.test.ts; do echo \"\\n\ud83e\uddea Testing $f...\"; bun test \"$f\" --timeout 10000; sleep 0.25; done",
-    "build": "tsc --project tsconfig.json",
+    "test-salve": "for f in tests/*.test.ts; do echo \"\\n🧪 Testing $f...\"; bun test \"$f\" --timeout 10000; sleep 0.25; done",
+    "build": "tsc --project tsconfig.json && rm -f dist/*standalone*",
     "deploy:npm": "bun publish --access public",
     "bench": "rm -rf .benchmark-shells/ && bun benchmark-virtualshell.ts",
-    "standalone-build:wo-sftp": "bunx esbuild src/standalone-wo-sftp.ts --bundle --platform=node --target=node18 --outfile=builds/standalone-wo-sftp.js --tree-shaking=true --minify  --banner:js='#!/usr/bin/env node'",
-    "web-build": "bunx esbuild src/web.ts --bundle --platform=browser --format=esm --target=es2020 --outfile=builds/web.min.js --tree-shaking=true --minify",
+    "benchmark": "bun benchmark-virtualshell.ts > benchmark-results.txt",
+"web-build": "bunx esbuild src/web.ts --bundle --platform=browser --format=esm --target=es2020 --outfile=builds/web.min.js --tree-shaking=true --minify",
     "web-build-iife": "bunx esbuild src/web.ts --bundle --platform=browser --format=iife --target=es2020 --outfile=builds/web-iife.min.js --tree-shaking=true --minify --global-name=WebShellLib",
     "example-build": "bun run web-build && cp builds/web.min.js examples/web.min.js",
     "example-serve": "cd examples && bun server.js",
@@ -45,14 +45,15 @@
     "publish-package": "bash ./scripts/publish-package.sh",
     "self-standalone-build": "node scripts/build-all.mjs",
     "standalone-build": "bunx esbuild src/standalone.ts --bundle --platform=node --target=node18 --outfile=builds/standalone.cjs --tree-shaking=true --minify  --banner:js='#!/usr/bin/env node'",
-    "build-all": "node scripts/build-all.mjs",
+    "build-all": "bun run build && node scripts/build-all.mjs && cd examples && node build && cd .. && cp examples/app.js docs/app.js",
     "publish-doc": "bunx typedoc && bun build-all && bunx gh-pages -d docs && git add docs && git commit -m 'docs: update documentation' && git push",
+    "publish-doc-app": "bun build-all && bunx gh-pages -d docs && git add docs/app.js && git commit -m 'docs: update web terminal app' && git push",
     "generate-manuals": "node scripts/generate-manuals-bundle.mjs"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.15",
     "@types/bun": "^1.3.14",
-    "@types/node": "^25.7.0",
+    "@types/node": "^25.8.0",
     "@types/ssh2": "^1.15.5",
     "esbuild": "^0.28.0",
     "gh-pages": "^6.3.0",
@@ -63,6 +64,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "fflate": "^0.8.2",
     "ssh2": "^1.17.0"
   }
 }

package/dist/self-standalone.d.ts

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