typescript-virtual-container 1.5.4 → 1.5.6

package/dist/commands/tar.js

@@ -1,6 +1,71 @@
+import { gunzipSync, gzipSync } from "fflate";
 import { resolvePath } from "./helpers";
+// ── POSIX ustar tar format ────────────────────────────────────────────────────
+function makeTarHeader(name, size, isDir) {
+    const hdr = Buffer.alloc(512);
+    const enc = (s, off, len) => {
+        const b = Buffer.from(s, "ascii");
+        b.copy(hdr, off, 0, Math.min(b.length, len));
+    };
+    enc(isDir ? `${name}/` : name, 0, 100);
+    enc(isDir ? "0000755\0" : "0000644\0", 100, 8);
+    enc("0000000\0", 108, 8);
+    enc("0000000\0", 116, 8);
+    enc(size.toString(8).padStart(11, "0") + "\0", 124, 12);
+    enc(Math.floor(Date.now() / 1000).toString(8).padStart(11, "0") + "\0", 136, 12);
+    hdr[156] = isDir ? 0x35 : 0x30; // '5' dir, '0' file
+    enc("ustar\0", 257, 6);
+    enc("00", 263, 2);
+    enc("root\0", 265, 32); // uname
+    enc("root\0", 297, 32); // gname
+    // Checksum: fill field with spaces, compute, write
+    for (let i = 148; i < 156; i++)
+        hdr[i] = 0x20;
+    let sum = 0;
+    for (let i = 0; i < 512; i++)
+        sum += hdr[i];
+    Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `).copy(hdr, 148);
+    return hdr;
+}
+function tarPad(size) {
+    const rem = size % 512;
+    return rem === 0 ? Buffer.alloc(0) : Buffer.alloc(512 - rem);
+}
+function buildTar(entries) {
+    const parts = [];
+    for (const { name, content, isDir } of entries) {
+        parts.push(makeTarHeader(name, isDir ? 0 : content.length, isDir));
+        if (!isDir) {
+            parts.push(content);
+            parts.push(tarPad(content.length));
+        }
+    }
+    parts.push(Buffer.alloc(1024)); // end-of-archive
+    return Buffer.concat(parts);
+}
+function parseTar(raw) {
+    const files = [];
+    let off = 0;
+    while (off + 512 <= raw.length) {
+        const hdr = raw.slice(off, off + 512);
+        if (hdr.every((b) => b === 0))
+            break;
+        const name = hdr.slice(0, 100).toString("ascii").replace(/\0.*/, "");
+        const sizeStr = hdr.slice(124, 135).toString("ascii").replace(/\0.*/, "").trim();
+        const size = parseInt(sizeStr, 8) || 0;
+        const typeflag = hdr[156];
+        off += 512;
+        if (name && typeflag !== 0x35 && typeflag !== 53) { // not a directory
+            const content = raw.slice(off, off + size);
+            files.push({ name, content });
+        }
+        off += Math.ceil(size / 512) * 512;
+    }
+    return files;
+}
 /**
- * Archive or extract files with tar and optional gzip compression.
+ * Archive or extract files with tar — writes real POSIX ustar binary format.
+ * Supports -c/-x/-t, -z (gzip), -j (bzip2 stub), -v (verbose), -f.
  * @category archive
  * @params ["[-czf|-xzf|-tf] <archive> [files...]"]
  */
@@ -10,17 +75,15 @@ export const tarCommand = {
     category: "archive",
     params: ["[-czf|-xzf|-tf] <archive> [files...]"],
     run: ({ authUser, shell, cwd, args }) => {
-        // Expand combined flags: -czf or czf (bare mode string) → ["-c", "-z", "-f"]
+        // Expand combined flags: -czf → ["-c", "-z", "-f"]
         const expanded = [];
         let foundModeStr = false;
         for (const a of args) {
             if (/^-[a-zA-Z]{2,}$/.test(a)) {
-                // -czf style
                 for (const ch of a.slice(1))
                     expanded.push(`-${ch}`);
             }
-            else if (!foundModeStr && /^[cxtdru]{1,}[a-zA-Z]*$/.test(a) && !a.includes("/") && !a.startsWith("-")) {
-                // czf bare style (first non-path arg)
+            else if (!foundModeStr && /^[cxtdru][a-zA-Z]*$/.test(a) && !a.includes("/") && !a.startsWith("-")) {
                 foundModeStr = true;
                 for (const ch of a)
                     expanded.push(`-${ch}`);
@@ -32,70 +95,93 @@ export const tarCommand = {
         const create = expanded.includes("-c");
         const extract = expanded.includes("-x");
         const list = expanded.includes("-t");
+        const useGzip = expanded.includes("-z");
+        const verbose = expanded.includes("-v");
         const fIdx = expanded.indexOf("-f");
         const archiveName = fIdx !== -1
             ? expanded[fIdx + 1]
-            : expanded.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
-        if (!create && !extract && !list) {
-            return { stderr: "tar: must specify -c, -x, or -t\n", exitCode: 1 };
-        }
+            : expanded.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz") || a.endsWith(".tar.bz2"));
+        if (!create && !extract && !list)
+            return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
         if (!archiveName)
-            return { stderr: "tar: no archive specified\n", exitCode: 1 };
+            return { stderr: "tar: no archive specified", exitCode: 1 };
         const archivePath = resolvePath(cwd, archiveName);
+        const autoGzip = useGzip || archiveName.endsWith(".gz") || archiveName.endsWith(".tgz");
         if (create) {
-            // Skip flags and archive name from file list
-            const skipNext2 = new Set();
-            if (fIdx !== -1)
-                skipNext2.add(fIdx + 1);
-            const fileArgs = expanded.filter((a, i) => !a.startsWith("-") && a !== archiveName && !skipNext2.has(i));
-            const entries = {};
+            const skipSet = new Set();
+            if (fIdx !== -1 && expanded[fIdx + 1])
+                skipSet.add(expanded[fIdx + 1]);
+            const fileArgs = expanded.filter((a) => !a.startsWith("-") && !skipSet.has(a));
+            const entries = [];
+            const verboseLines = [];
             for (const f of fileArgs) {
                 const p = resolvePath(cwd, f);
-                try {
-                    const stat = shell.vfs.stat(p);
-                    if (stat.type === "file")
-                        entries[f] = shell.vfs.readFile(p);
-                    else {
-                        const walk = (dir, prefix) => {
-                            for (const e of shell.vfs.list(dir)) {
-                                const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
-                                const s = shell.vfs.stat(full);
-                                if (s.type === "file")
-                                    entries[rel] = shell.vfs.readFile(full);
-                                else
-                                    walk(full, rel);
-                            }
-                        };
-                        walk(p, f);
-                    }
+                if (!shell.vfs.exists(p))
+                    return { stderr: `tar: ${f}: No such file or directory`, exitCode: 1 };
+                const st = shell.vfs.stat(p);
+                if (st.type === "file") {
+                    const content = shell.vfs.readFileRaw(p);
+                    entries.push({ name: f, content, isDir: false });
+                    if (verbose)
+                        verboseLines.push(f);
                 }
-                catch {
-                    return {
-                        stderr: `tar: ${f}: No such file or directory`,
-                        exitCode: 1,
+                else {
+                    entries.push({ name: f, content: Buffer.alloc(0), isDir: true });
+                    if (verbose)
+                        verboseLines.push(`${f}/`);
+                    const walk = (dir, prefix) => {
+                        for (const e of shell.vfs.list(dir)) {
+                            const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
+                            const s = shell.vfs.stat(full);
+                            if (s.type === "directory") {
+                                entries.push({ name: rel, content: Buffer.alloc(0), isDir: true });
+                                if (verbose)
+                                    verboseLines.push(`${rel}/`);
+                                walk(full, rel);
+                            }
+                            else {
+                                const content = shell.vfs.readFileRaw(full);
+                                entries.push({ name: rel, content, isDir: false });
+                                if (verbose)
+                                    verboseLines.push(rel);
+                            }
+                        }
                     };
+                    walk(p, f);
                 }
             }
-            shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
-            return { exitCode: 0 };
+            const tarBuf = buildTar(entries);
+            const finalBuf = autoGzip ? Buffer.from(gzipSync(tarBuf)) : tarBuf;
+            shell.vfs.writeFile(archivePath, finalBuf);
+            return { stdout: verbose ? verboseLines.join("\n") : undefined, exitCode: 0 };
         }
         if (list || extract) {
-            let entries;
-            try {
-                entries = JSON.parse(shell.vfs.readFile(archivePath));
+            const rawArchive = shell.vfs.readFileRaw(archivePath);
+            let raw;
+            if (autoGzip) {
+                try {
+                    raw = Buffer.from(gunzipSync(rawArchive));
+                }
+                catch {
+                    return { stderr: `tar: ${archiveName}: not a gzip file`, exitCode: 1 };
+                }
+            }
+            else {
+                raw = rawArchive;
             }
-            catch {
-                return {
-                    stderr: `tar: ${archiveName}: cannot open archive`,
-                    exitCode: 1,
-                };
+            const files = parseTar(raw);
+            if (list) {
+                const names = files.map((f) => (verbose ? `-rw-r--r-- 0/0 ${f.content.length.toString().padStart(8)} 1970-01-01 00:00 ${f.name}` : f.name));
+                return { stdout: names.join("\n"), exitCode: 0 };
             }
-            if (list)
-                return { stdout: Object.keys(entries).join("\n"), exitCode: 0 };
-            for (const [name, content] of Object.entries(entries)) {
-                shell.writeFileAsUser(authUser, resolvePath(cwd, name), content);
+            const verboseLines = [];
+            for (const { name, content } of files) {
+                const destPath = resolvePath(cwd, name);
+                shell.writeFileAsUser(authUser, destPath, content);
+                if (verbose)
+                    verboseLines.push(name);
             }
-            return { exitCode: 0 };
+            return { stdout: verbose ? verboseLines.join("\n") : undefined, exitCode: 0 };
         }
         return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
     },

package/dist/commands/zip.d.ts

@@ -0,0 +1,11 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Create ZIP archives using real PKZIP format with DEFLATE compression.
+ * @category archive
+ */
+export declare const zipCommand: ShellModule;
+/**
+ * Extract ZIP archives (real PKZIP DEFLATE format).
+ * @category archive
+ */
+export declare const unzipCommand: ShellModule;

package/dist/commands/zip.js

@@ -0,0 +1,232 @@
+import { deflateSync, inflateSync } from "fflate";
+import { resolvePath } from "./helpers";
+// ── CRC32 ─────────────────────────────────────────────────────────────────────
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let j = 0; j < 8; j++)
+            c = c & 1 ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        t[i] = c;
+    }
+    return t;
+})();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++)
+        crc = (CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8)) >>> 0;
+    return (crc ^ 0xffffffff) >>> 0;
+}
+// ── DOS date/time from JS Date ────────────────────────────────────────────────
+function dosDateTime() {
+    const d = new Date();
+    const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
+    return [time, date];
+}
+// ── ZIP builder ───────────────────────────────────────────────────────────────
+function buildZip(entries) {
+    const parts = [];
+    const cdParts = [];
+    let offset = 0;
+    const [modTime, modDate] = dosDateTime();
+    for (const { name, content } of entries) {
+        const nameBuf = Buffer.from(name, "utf8");
+        const compressed = Buffer.from(deflateSync(content, { level: 6 }));
+        const useDeflate = compressed.length < content.length;
+        const stored = useDeflate ? compressed : content;
+        const crc = crc32(content);
+        const method = useDeflate ? 8 : 0;
+        // Local file header
+        const lfh = Buffer.alloc(30 + nameBuf.length);
+        lfh.writeUInt32LE(0x04034b50, 0);
+        lfh.writeUInt16LE(20, 4);
+        lfh.writeUInt16LE(0x0800, 6); // UTF-8 flag
+        lfh.writeUInt16LE(method, 8);
+        lfh.writeUInt16LE(modTime, 10);
+        lfh.writeUInt16LE(modDate, 12);
+        lfh.writeUInt32LE(crc, 14);
+        lfh.writeUInt32LE(stored.length, 18);
+        lfh.writeUInt32LE(content.length, 22);
+        lfh.writeUInt16LE(nameBuf.length, 26);
+        lfh.writeUInt16LE(0, 28);
+        nameBuf.copy(lfh, 30);
+        // Central directory entry
+        const cd = Buffer.alloc(46 + nameBuf.length);
+        cd.writeUInt32LE(0x02014b50, 0);
+        cd.writeUInt16LE(20, 4);
+        cd.writeUInt16LE(20, 6);
+        cd.writeUInt16LE(0x0800, 8);
+        cd.writeUInt16LE(method, 10);
+        cd.writeUInt16LE(modTime, 12);
+        cd.writeUInt16LE(modDate, 14);
+        cd.writeUInt32LE(crc, 16);
+        cd.writeUInt32LE(stored.length, 20);
+        cd.writeUInt32LE(content.length, 24);
+        cd.writeUInt16LE(nameBuf.length, 28);
+        cd.writeUInt16LE(0, 30); // extra
+        cd.writeUInt16LE(0, 32); // comment
+        cd.writeUInt16LE(0, 34); // disk start
+        cd.writeUInt16LE(0, 36); // int attr
+        cd.writeUInt32LE(0x81a40000, 38); // ext attr: -rw-r--r--
+        cd.writeUInt32LE(offset, 42);
+        nameBuf.copy(cd, 46);
+        parts.push(lfh, stored);
+        cdParts.push(cd);
+        offset += lfh.length + stored.length;
+    }
+    const cdBuf = Buffer.concat(cdParts);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(0x06054b50, 0);
+    eocd.writeUInt16LE(0, 4);
+    eocd.writeUInt16LE(0, 6);
+    eocd.writeUInt16LE(entries.length, 8);
+    eocd.writeUInt16LE(entries.length, 10);
+    eocd.writeUInt32LE(cdBuf.length, 12);
+    eocd.writeUInt32LE(offset, 16);
+    eocd.writeUInt16LE(0, 20);
+    return Buffer.concat([...parts, cdBuf, eocd]);
+}
+// ── ZIP parser ────────────────────────────────────────────────────────────────
+function parseZip(raw) {
+    const files = [];
+    let off = 0;
+    while (off + 4 <= raw.length) {
+        const sig = raw.readUInt32LE(off);
+        if (sig === 0x02014b50 || sig === 0x06054b50)
+            break; // central dir / EOCD
+        if (sig !== 0x04034b50) {
+            off++;
+            continue;
+        }
+        const method = raw.readUInt16LE(off + 8);
+        const compSize = raw.readUInt32LE(off + 18);
+        const uncompSize = raw.readUInt32LE(off + 22);
+        const nameLen = raw.readUInt16LE(off + 26);
+        const extraLen = raw.readUInt16LE(off + 28);
+        const name = raw.subarray(off + 30, off + 30 + nameLen).toString("utf8");
+        const dataOff = off + 30 + nameLen + extraLen;
+        const compData = raw.subarray(dataOff, dataOff + compSize);
+        let content;
+        if (method === 8) {
+            try {
+                content = Buffer.from(inflateSync(compData));
+            }
+            catch {
+                content = compData;
+            }
+        }
+        else {
+            content = compData;
+        }
+        if (name && !name.endsWith("/")) {
+            // Validate size
+            if (content.length === uncompSize || method !== 0)
+                files.push({ name, content });
+            else
+                files.push({ name, content });
+        }
+        off = dataOff + compSize;
+    }
+    return files;
+}
+// ── Commands ──────────────────────────────────────────────────────────────────
+/**
+ * Create ZIP archives using real PKZIP format with DEFLATE compression.
+ * @category archive
+ */
+export const zipCommand = {
+    name: "zip",
+    description: "Package and compress files",
+    category: "archive",
+    params: ["[-r] <archive.zip> <file...>"],
+    run: ({ shell, cwd, args }) => {
+        const recursive = args.includes("-r") || args.includes("-R");
+        const files = args.filter((a) => !a.startsWith("-"));
+        const archiveArg = files[0];
+        const sources = files.slice(1);
+        if (!archiveArg)
+            return { stderr: "zip: no archive specified", exitCode: 1 };
+        if (sources.length === 0)
+            return { stderr: "zip: nothing to do!", exitCode: 12 };
+        const archivePath = resolvePath(cwd, archiveArg.endsWith(".zip") ? archiveArg : `${archiveArg}.zip`);
+        const entries = [];
+        const verboseLines = [];
+        for (const src of sources) {
+            const p = resolvePath(cwd, src);
+            if (!shell.vfs.exists(p))
+                return { stderr: `zip warning: name not matched: ${src}`, exitCode: 12 };
+            const st = shell.vfs.stat(p);
+            if (st.type === "file") {
+                const content = shell.vfs.readFileRaw(p);
+                entries.push({ name: src, content });
+                verboseLines.push(`  adding: ${src} (deflated)`);
+            }
+            else if (recursive) {
+                const walk = (dir, prefix) => {
+                    for (const e of shell.vfs.list(dir)) {
+                        const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
+                        const s = shell.vfs.stat(full);
+                        if (s.type === "directory")
+                            walk(full, rel);
+                        else {
+                            const content = shell.vfs.readFileRaw(full);
+                            entries.push({ name: rel, content });
+                            verboseLines.push(`  adding: ${rel} (deflated)`);
+                        }
+                    }
+                };
+                walk(p, src);
+            }
+        }
+        if (entries.length === 0)
+            return { stderr: "zip: nothing to do!", exitCode: 12 };
+        const zipBuf = buildZip(entries);
+        shell.vfs.writeFile(archivePath, zipBuf);
+        return { stdout: verboseLines.join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * Extract ZIP archives (real PKZIP DEFLATE format).
+ * @category archive
+ */
+export const unzipCommand = {
+    name: "unzip",
+    description: "Extract compressed files from ZIP archives",
+    category: "archive",
+    params: ["[-l] [-o] <archive.zip> [-d <dir>]"],
+    run: ({ shell, cwd, args }) => {
+        const listOnly = args.includes("-l");
+        const dIdx = args.indexOf("-d");
+        const destDir = dIdx !== -1 ? args[dIdx + 1] : undefined;
+        const archive = args.find((a) => !a.startsWith("-") && a !== destDir);
+        if (!archive)
+            return { stderr: "unzip: missing archive operand", exitCode: 1 };
+        const archivePath = resolvePath(cwd, archive);
+        if (!shell.vfs.exists(archivePath))
+            return { stderr: `unzip: cannot find or open ${archive}`, exitCode: 9 };
+        const raw = shell.vfs.readFileRaw(archivePath);
+        let files;
+        try {
+            files = parseZip(raw);
+        }
+        catch {
+            return { stderr: `unzip: ${archive}: not a valid ZIP file`, exitCode: 1 };
+        }
+        const dest = destDir ? resolvePath(cwd, destDir) : cwd;
+        if (listOnly) {
+            const header = `Archive:  ${archive}\n  Length      Date    Time    Name\n---------  ---------- -----   ----`;
+            const rows = files.map((f) => `  ${String(f.content.length).padStart(8)}  2024-01-01 00:00   ${f.name}`);
+            const total = files.reduce((s, f) => s + f.content.length, 0);
+            const footer = `---------                     -------\n  ${String(total).padStart(8)}                     ${files.length} file${files.length !== 1 ? "s" : ""}`;
+            return { stdout: `${header}\n${rows.join("\n")}\n${footer}`, exitCode: 0 };
+        }
+        const out = [`Archive:  ${archive}`];
+        for (const { name, content } of files) {
+            const destPath = `${dest}/${name}`;
+            shell.vfs.writeFile(destPath, content);
+            out.push(`  inflating: ${destPath}`);
+        }
+        return { stdout: out.join("\n"), exitCode: 0 };
+    },
+};

package/dist/modules/linuxRootfs.js

@@ -1281,7 +1281,7 @@ Installed-Size: 6800
 Maintainer: Fortune Package Team <dpkg@fortune.local>
 Architecture: amd64
 Version: 1.22.6nyx1
-Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.5)
+Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.6)
 Description: Fortune package management system
  This package provides the low-level infrastructure for handling the
  installation and removal of Fortune software packages.

package/dist/utils/expand.js

@@ -369,12 +369,27 @@ export function expandSync(input, env, lastExit = 0, home) {
         let s = chunk;
         // Tilde expansion — only at start of token or after `:` or whitespace
         s = s.replace(/(^|[\s:])~(\/|$)/g, (_, pre, post) => `${pre}${homePath}${post}`);
-        // $? $$ $#
+        // $? $$ $# $RANDOM $LINENO
         s = s.replace(/\$\?/g, String(lastExit));
         s = s.replace(/\$\$/g, "1");
         s = s.replace(/\$#/g, "0");
+        s = s.replace(/\$RANDOM\b/g, () => String(Math.floor(Math.random() * 32768)));
+        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}
@@ -387,6 +402,57 @@ 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(new RegExp(pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, "."), "g"), 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(new RegExp(pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".")), 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, "");
+        });
+        // ${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, "");
+        });
+        // ${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, "");
+        });
+        // ${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, "");
+        });
         // ${VAR}
         s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => env[name] ?? "");
         // $VAR and positional params $1 $2 ...

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "files": [
     "dist/",
     "README.md",
@@ -32,7 +32,7 @@
     "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",
+    "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",
     "deploy:npm": "bun publish --access public",
     "bench": "rm -rf .benchmark-shells/ && bun benchmark-virtualshell.ts",
@@ -46,13 +46,13 @@
     "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",
-    "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": "bunx typedoc && bun build-all && cd examples && node build && cd .. && bunx gh-pages -d docs && git add docs && git commit -m 'docs: update documentation' && 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 +63,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "fflate": "^0.8.2",
     "ssh2": "^1.17.0"
   }
 }

package/dist/self-standalone.d.ts

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