typescript-virtual-container 1.2.8 → 1.3.0

package/dist/commands/man.js

@@ -0,0 +1,155 @@
+const MAN_PAGES = {
+    ls: `LS(1)                    User Commands                    LS(1)
+
+NAME
+       ls - list directory contents
+
+SYNOPSIS
+       ls [OPTION]... [FILE]...
+
+DESCRIPTION
+       List information about the FILEs (the current directory by default).
+
+OPTIONS
+       -l     use a long listing format
+       -a     do not ignore entries starting with .
+       -h     with -l, print human readable sizes
+       -r     reverse order while sorting
+       -t     sort by modification time
+
+AUTHOR
+       Written by Richard M. Stallman and David MacKenzie.`,
+    cat: `CAT(1)                   User Commands                    CAT(1)
+
+NAME
+       cat - concatenate files and print on the standard output
+
+SYNOPSIS
+       cat [OPTION]... [FILE]...
+
+DESCRIPTION
+       Concatenate FILE(s) to standard output.
+
+OPTIONS
+       -n, --number          number all output lines
+       -b, --number-nonblank number nonempty output lines`,
+    grep: `GREP(1)                  User Commands                    GREP(1)
+
+NAME
+       grep, egrep, fgrep - print lines that match patterns
+
+SYNOPSIS
+       grep [OPTION]... PATTERNS [FILE]...
+
+OPTIONS
+       -i, --ignore-case     ignore case distinctions in patterns and data
+       -v, --invert-match    select non-matching lines
+       -n, --line-number     print line number with output lines
+       -r, --recursive       read all files under each directory, recursively`,
+    apt: `APT(8)                   APT                             APT(8)
+
+NAME
+       apt - command-line interface
+
+SYNOPSIS
+       apt [options] command
+
+DESCRIPTION
+       apt provides a high-level commandline interface for the package
+       management system.
+
+COMMANDS
+       install pkg...   Install packages
+       remove pkg...    Remove packages
+       update           Download package information
+       upgrade          Upgrade installed packages
+       search term      Search in package descriptions
+       show pkg         Show package information
+       list             List packages`,
+    ssh: `SSH(1)                   OpenSSH                          SSH(1)
+
+NAME
+       ssh - OpenSSH remote login client
+
+SYNOPSIS
+       ssh [-p port] [user@]hostname [command]
+
+DESCRIPTION
+       ssh (SSH client) is a program for logging into a remote machine and
+       for executing commands on a remote machine.`,
+    curl: `CURL(1)                  User Commands                    CURL(1)
+
+NAME
+       curl - transfer a URL
+
+SYNOPSIS
+       curl [options / URLs]
+
+DESCRIPTION
+       curl is a tool for transferring data with URL syntax.
+
+OPTIONS
+       -o, --output <file>     Write output to <file>
+       -X, --request <method>  Specify request method
+       -d, --data <data>       HTTP POST data
+       -H, --header <header>   Pass custom header
+       -s, --silent            Silent mode
+       -I, --head              Show document info only
+       -L, --location          Follow redirects
+       -v, --verbose           Make the operation more talkative`,
+    chmod: `CHMOD(1)                 User Commands                    CHMOD(1)
+
+NAME
+       chmod - change file mode bits
+
+SYNOPSIS
+       chmod [OPTION]... MODE[,MODE]... FILE...
+       chmod [OPTION]... OCTAL-MODE FILE...
+
+DESCRIPTION
+       Change the file mode bits of each given file according to MODE.
+
+EXAMPLES
+       chmod 755 script.sh      rwxr-xr-x
+       chmod 644 file.txt       rw-r--r--
+       chmod +x script.sh       add execute permission`,
+    tar: `TAR(1)                   GNU tar Manual                   TAR(1)
+
+NAME
+       tar - an archiving utility
+
+SYNOPSIS
+       tar [OPTION...] [FILE]...
+
+DESCRIPTION
+       tar saves many files together into a single tape or disk archive,
+       and can restore individual files from the archive.
+
+OPTIONS
+       -c, --create           create a new archive
+       -x, --extract          extract files from an archive
+       -z, --gzip             filter the archive through gzip
+       -f, --file=ARCHIVE     use archive file or device ARCHIVE
+       -v, --verbose          verbosely list files processed
+       -t, --list             list the contents of an archive`,
+};
+export const manCommand = {
+    name: "man",
+    description: "Interface to the system reference manuals",
+    category: "shell",
+    params: ["<command>"],
+    run: ({ args, shell }) => {
+        const name = args[0];
+        if (!name)
+            return { stderr: "What manual page do you want?", exitCode: 1 };
+        // VFS-installed man pages take priority
+        const manPath = `/usr/share/man/man1/${name}.1`;
+        if (shell.vfs.exists(manPath)) {
+            return { stdout: shell.vfs.readFile(manPath), exitCode: 0 };
+        }
+        const page = MAN_PAGES[name.toLowerCase()];
+        if (page)
+            return { stdout: page, exitCode: 0 };
+        return { stderr: `No manual entry for ${name}`, exitCode: 16 };
+    },
+};

package/dist/commands/nano.js

@@ -3,7 +3,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const nanoCommand = {
     name: "nano",
     description: "Text editor",
-    category: "shell",
+    category: "files",
     params: ["<file>"],
     run: ({ authUser, shell, cwd, args }) => {
         const fileArg = args[0];

package/dist/commands/neofetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"neofetch.d.ts","sourceRoot":"","sources":["../../src/commands/neofetch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,eAAe,EAAE,WAiC7B,CAAC"}
+{"version":3,"file":"neofetch.d.ts","sourceRoot":"","sources":["../../src/commands/neofetch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,eAAe,EAAE,WAsC7B,CAAC"}

package/dist/commands/neofetch.js

@@ -4,7 +4,7 @@ import { getAllEnvVars } from "./set";
 export const neofetchCommand = {
     name: "neofetch",
     description: "System info display",
-    category: "misc",
+    category: "system",
     params: ["[--off]"],
     run: ({ args, authUser, hostname, shell }) => {
         const env = getAllEnvVars(authUser);
@@ -27,6 +27,11 @@ export const neofetchCommand = {
                 shell: env.SHELL,
                 shellProps: shell.properties,
                 terminal: env.TERM,
+                uptimeSeconds: Math.floor((Date.now() - shell.startTime) / 1000),
+                packages: (() => {
+                    const count = shell.packageManager?.installedCount() ?? 0;
+                    return `${count} (dpkg)`;
+                })(),
             }),
             exitCode: 0,
         };

package/dist/commands/node.d.ts

@@ -0,0 +1,9 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * `node` virtual runtime command. Executes JS in a safe sandbox with
+ * limited globals and no host FS/child process access.
+ * @category system
+ * @params []
+ */
+export declare const nodeCommand: ShellModule;
+//# sourceMappingURL=node.d.ts.map

package/dist/commands/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/commands/node.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAmPrD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,WAkFzB,CAAC"}

package/dist/commands/node.js

@@ -0,0 +1,316 @@
+/** biome-ignore-all lint/style/useNamingConvention: node globals and ENV VAR KEYS */
+/**
+ * node.ts — Virtual Node.js runtime.
+ *
+ * Uses `node:vm` for sandboxed evaluation with a controlled context that
+ * intercepts `process`, `require`, `console`, and all standard globals.
+ * No host filesystem access, no network, no child processes.
+ */
+import vm from "node:vm";
+import { ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+const VIRTUAL_VERSION = "v18.19.0";
+const VIRTUAL_VERSIONS = {
+    node: VIRTUAL_VERSION,
+    npm: "9.2.0",
+    v8: "10.2.154.26-node.22",
+};
+// ─── sandbox context ──────────────────────────────────────────────────────────
+function makeContext(outputLines, stderrLines) {
+    const fakeProcess = {
+        version: VIRTUAL_VERSION,
+        versions: VIRTUAL_VERSIONS,
+        platform: "linux",
+        arch: "x64",
+        env: {
+            NODE_ENV: "production",
+            HOME: "/root",
+            PATH: "/usr/local/bin:/usr/bin:/bin",
+        },
+        argv: ["node"],
+        stdout: {
+            write: (s) => {
+                outputLines.push(s);
+                return true;
+            },
+        },
+        stderr: {
+            write: (s) => {
+                stderrLines.push(s);
+                return true;
+            },
+        },
+        exit: (code = 0) => {
+            throw new ExitSignal(code);
+        },
+        cwd: () => "/root",
+        hrtime: () => [0, 0],
+    };
+    const fakeConsole = {
+        log: (...a) => outputLines.push(a.map(formatValue).join(" ")),
+        error: (...a) => stderrLines.push(a.map(formatValue).join(" ")),
+        warn: (...a) => stderrLines.push(a.map(formatValue).join(" ")),
+        info: (...a) => outputLines.push(a.map(formatValue).join(" ")),
+        dir: (v) => outputLines.push(formatValue(v)),
+    };
+    const fakeRequire = (mod) => {
+        // Provide stubs for common modules
+        switch (mod) {
+            case "path":
+                return {
+                    join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+                    resolve: (...parts) => `/${parts.join("/").replace(/^\/+/, "")}`,
+                    dirname: (p) => p.split("/").slice(0, -1).join("/") || "/",
+                    basename: (p) => p.split("/").pop() ?? "",
+                    extname: (p) => {
+                        const b = p.split("/").pop() ?? "";
+                        const d = b.lastIndexOf(".");
+                        return d > 0 ? b.slice(d) : "";
+                    },
+                    sep: "/",
+                    delimiter: ":",
+                };
+            case "os":
+                return {
+                    platform: () => "linux",
+                    arch: () => "x64",
+                    type: () => "Linux",
+                    hostname: () => "fortune-vm",
+                    homedir: () => "/root",
+                    tmpdir: () => "/tmp",
+                    EOL: "\n",
+                };
+            case "util":
+                return {
+                    format: (...a) => a.map(formatValue).join(" "),
+                    inspect: (v) => formatValue(v),
+                };
+            case "fs":
+            case "fs/promises":
+                throw new Error(`Cannot require '${mod}': filesystem access not available in virtual runtime`);
+            case "child_process":
+            case "net":
+            case "http":
+            case "https":
+                throw new Error(`Cannot require '${mod}': not available in virtual runtime`);
+            default:
+                throw new Error(`Cannot find module '${mod}'`);
+        }
+    };
+    fakeRequire.resolve = (id) => {
+        throw new Error(`Cannot resolve '${id}'`);
+    };
+    fakeRequire.cache = {};
+    fakeRequire.extensions = {};
+    return vm.createContext({
+        // Core globals
+        console: fakeConsole,
+        process: fakeProcess,
+        require: fakeRequire,
+        // JS built-ins
+        Math,
+        JSON,
+        Object,
+        Array,
+        String,
+        Number,
+        Boolean,
+        Symbol,
+        Date,
+        RegExp,
+        Error,
+        TypeError,
+        RangeError,
+        SyntaxError,
+        Promise,
+        Map,
+        Set,
+        WeakMap,
+        WeakSet,
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        encodeURIComponent,
+        decodeURIComponent,
+        encodeURI,
+        decodeURI,
+        setTimeout: () => { },
+        clearTimeout: () => { },
+        setInterval: () => { },
+        clearInterval: () => { },
+        queueMicrotask: () => { },
+        globalThis: undefined, // set below
+        undefined,
+        Infinity,
+        NaN,
+    });
+}
+class ExitSignal {
+    code;
+    constructor(code) {
+        this.code = code;
+    }
+}
+function formatValue(v) {
+    if (v === null)
+        return "null";
+    if (v === undefined)
+        return "undefined";
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "function")
+        return `[Function: ${v.name || "(anonymous)"}]`;
+    if (Array.isArray(v))
+        return `[ ${v.map(formatValue).join(", ")} ]`;
+    if (v instanceof Error)
+        return `${v.name}: ${v.message}`;
+    if (typeof v === "object") {
+        try {
+            const entries = Object.entries(v)
+                .map(([k, val]) => `${k}: ${formatValue(val)}`)
+                .join(", ");
+            return `{ ${entries} }`;
+        }
+        catch {
+            return "[Object]";
+        }
+    }
+    return String(v);
+}
+// ─── execution ────────────────────────────────────────────────────────────────
+function runJs(code) {
+    const outputLines = [];
+    const stderrLines = [];
+    const ctx = makeContext(outputLines, stderrLines);
+    let exitCode = 0;
+    try {
+        const result = vm.runInContext(code, ctx, { timeout: 5000 });
+        // If the expression returned a value and nothing was console.log'd, print it
+        if (result !== undefined && outputLines.length === 0) {
+            outputLines.push(formatValue(result));
+        }
+    }
+    catch (err) {
+        if (err instanceof ExitSignal) {
+            exitCode = err.code;
+        }
+        else if (err instanceof Error) {
+            stderrLines.push(`${err.name}: ${err.message}`);
+            exitCode = 1;
+        }
+        else {
+            stderrLines.push(String(err));
+            exitCode = 1;
+        }
+    }
+    return {
+        stdout: outputLines.length ? `${outputLines.join("\n")}\n` : "",
+        stderr: stderrLines.length ? `${stderrLines.join("\n")}\n` : "",
+        exitCode,
+    };
+}
+function runJsFile(code) {
+    // If the code is a single expression (no semicolons, no newlines, no statements),
+    // wrap it to capture the return value like a REPL would
+    const trimmed = code.trim();
+    const isExpression = !trimmed.includes("\n") &&
+        !trimmed.startsWith("const ") &&
+        !trimmed.startsWith("let ") &&
+        !trimmed.startsWith("var ") &&
+        !trimmed.startsWith("function ") &&
+        !trimmed.startsWith("class ") &&
+        !trimmed.startsWith("if ") &&
+        !trimmed.startsWith("for ") &&
+        !trimmed.startsWith("while ") &&
+        !trimmed.startsWith("import ") &&
+        !trimmed.startsWith("//");
+    if (isExpression)
+        return runJs(trimmed);
+    // Multi-line: wrap in IIFE
+    return runJs(`(async () => { ${code} })()`);
+}
+// ─── command ──────────────────────────────────────────────────────────────────
+/**
+ * `node` virtual runtime command. Executes JS in a safe sandbox with
+ * limited globals and no host FS/child process access.
+ * @category system
+ * @params []
+ */
+export const nodeCommand = {
+    name: "node",
+    description: "JavaScript runtime (virtual)",
+    category: "system",
+    params: ["[--version] [-e <expr>] [-p <expr>] [file]"],
+    run: ({ args, shell, cwd }) => {
+        // Require explicit installation via `apt install nodejs`
+        if (!shell.packageManager.isInstalled("nodejs")) {
+            return {
+                stderr: "bash: node: command not found\nHint: install it with: apt install nodejs\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version", "-v"])) {
+            return { stdout: `${VIRTUAL_VERSION}\n`, exitCode: 0 };
+        }
+        if (ifFlag(args, ["--versions"])) {
+            return {
+                stdout: `${JSON.stringify(VIRTUAL_VERSIONS, null, 2)}\n`,
+                exitCode: 0,
+            };
+        }
+        // -e 'expr'
+        const eIdx = args.findIndex((a) => a === "-e" || a === "--eval");
+        if (eIdx !== -1) {
+            const expr = args[eIdx + 1];
+            if (!expr)
+                return { stderr: "node: -e requires an argument\n", exitCode: 1 };
+            const { stdout, stderr, exitCode } = runJs(expr);
+            return {
+                stdout: stdout || undefined,
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // -p 'expr' — print mode
+        const pIdx = args.findIndex((a) => a === "-p" || a === "--print");
+        if (pIdx !== -1) {
+            const expr = args[pIdx + 1];
+            if (!expr)
+                return { stderr: "node: -p requires an argument\n", exitCode: 1 };
+            const { stdout, stderr, exitCode } = runJs(expr);
+            return {
+                stdout: stdout || (exitCode === 0 ? "\n" : undefined),
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // node <file>
+        const file = args.find((a) => !a.startsWith("-"));
+        if (file) {
+            const filePath = resolvePath(cwd, file);
+            if (!shell.vfs.exists(filePath)) {
+                return {
+                    stderr: `node: cannot open file '${file}': No such file or directory\n`,
+                    exitCode: 1,
+                };
+            }
+            const code = shell.vfs.readFile(filePath);
+            const { stdout, stderr, exitCode } = runJsFile(code);
+            return {
+                stdout: stdout || undefined,
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // No args — REPL hint
+        return {
+            stdout: [
+                `Welcome to Node.js ${VIRTUAL_VERSION}.`,
+                `Type ".exit" to exit the REPL.`,
+                `> `,
+            ].join("\n"),
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/npm.d.ts

@@ -0,0 +1,19 @@
+/**
+ * npm.ts — Virtual npm command.
+ * Gated behind `apt install npm`. Provides version info and informative
+ * stubs for common subcommands.
+ */
+import type { ShellModule } from "../types/commands";
+/**
+ * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<command> [args]"]
+ */
+export declare const npmCommand: ShellModule;
+/**
+ * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<package> [args]"]
+ */
+export declare const npxCommand: ShellModule;
+//# sourceMappingURL=npm.d.ts.map

package/dist/commands/npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["../../src/commands/npm.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,WAqFxB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,WAuBxB,CAAC"}

package/dist/commands/npm.js

@@ -0,0 +1,109 @@
+import { ifFlag } from "./command-helpers";
+const NPM_VERSION = "9.2.0";
+const NODE_VERSION = "18.19.0";
+/**
+ * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<command> [args]"]
+ */
+export const npmCommand = {
+    name: "npm",
+    description: "Node.js package manager (virtual)",
+    category: "system",
+    params: ["<command> [args]"],
+    run: ({ args, shell }) => {
+        // Require explicit installation
+        if (!shell.packageManager.isInstalled("npm")) {
+            return {
+                stderr: "bash: npm: command not found\nHint: install it with: apt install npm\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version", "-v"])) {
+            return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+        }
+        const sub = args[0]?.toLowerCase();
+        switch (sub) {
+            case "version":
+            case "-version":
+                return {
+                    stdout: `{ npm: '${NPM_VERSION}', node: '${NODE_VERSION}', v8: '10.2.154.26' }\n`,
+                    exitCode: 0,
+                };
+            case "install":
+            case "i":
+            case "add":
+                return {
+                    stderr: "npm warn: package installation is not available in the virtual runtime.\nnpm warn: This environment simulates npm CLI behaviour only.\n",
+                    exitCode: 1,
+                };
+            case "run":
+            case "exec":
+            case "x":
+                return {
+                    stderr: `npm error: script execution is not available in the virtual runtime.\n`,
+                    exitCode: 1,
+                };
+            case "init":
+                return {
+                    stdout: "Wrote to /home/user/package.json\n",
+                    exitCode: 0,
+                };
+            case "list":
+            case "ls":
+                return {
+                    stdout: `${sub === "ls" || sub === "list" ? "virtual-env@1.0.0" : ""}\n└── (empty)\n`,
+                    exitCode: 0,
+                };
+            case "help":
+            case undefined:
+                return {
+                    stdout: `${[
+                        `npm ${NPM_VERSION}`,
+                        "",
+                        "Usage: npm <command>",
+                        "",
+                        "Commands:",
+                        "  install       (not available in virtual runtime)",
+                        "  run           (not available in virtual runtime)",
+                        "  exec          (not available in virtual runtime)",
+                        "  list          List installed packages",
+                        "  version       Print versions",
+                        "  --version     Print npm version",
+                    ].join("\n")}\n`,
+                    exitCode: 0,
+                };
+            default:
+                return {
+                    stderr: `npm error: unknown command: ${sub}\n`,
+                    exitCode: 1,
+                };
+        }
+    },
+};
+/**
+ * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<package> [args]"]
+ */
+export const npxCommand = {
+    name: "npx",
+    description: "Node.js package runner (virtual)",
+    category: "system",
+    params: ["<package> [args]"],
+    run: ({ args, shell }) => {
+        if (!shell.packageManager.isInstalled("npm")) {
+            return {
+                stderr: "bash: npx: command not found\nHint: install it with: apt install npm\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version"])) {
+            return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+        }
+        return {
+            stderr: `npx: package execution is not available in the virtual runtime.\n`,
+            exitCode: 1,
+        };
+    },
+};

package/dist/commands/ping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../src/commands/ping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,WAAW,EAAE,WAiBzB,CAAC"}
+{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../src/commands/ping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAuBzB,CAAC"}

package/dist/commands/ping.js

@@ -1,11 +1,16 @@
+import { parseArgs } from "./command-helpers";
 export const pingCommand = {
     name: "ping",
     description: "Send ICMP ECHO_REQUEST (mock)",
     category: "network",
     params: ["[-c <count>] <host>"],
     run: ({ args }) => {
-        const host = args.find((a) => !a.startsWith("-")) ?? "localhost";
-        const count = 4;
+        const { flagsWithValues, positionals } = parseArgs(args, {
+            flagsWithValue: ["-c", "-i", "-W"],
+        });
+        const host = positionals[0] ?? "localhost";
+        const countArg = flagsWithValues.get("-c");
+        const count = countArg ? Math.max(1, parseInt(countArg, 10) || 4) : 4;
         const lines = [`PING ${host}: 56 data bytes`];
         for (let i = 0; i < count; i++) {
             const ms = (Math.random() * 10 + 1).toFixed(3);

package/dist/commands/printf.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const printfCommand: ShellModule;
+//# sourceMappingURL=printf.d.ts.map

package/dist/commands/printf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printf.d.ts","sourceRoot":"","sources":["../../src/commands/printf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAoGrD,eAAO,MAAM,aAAa,EAAE,WAW3B,CAAC"}