typescript-virtual-container 1.4.4 → 1.4.6

package/dist/VirtualFileSystem/index.js

@@ -0,0 +1,690 @@
+import { EventEmitter } from "node:events";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { decodeVfs, encodeVfs, isBinarySnapshot } from "./binaryPack";
+import { getNode, getParentDirectory, normalizePath } from "./path";
+// ── VirtualFileSystem ─────────────────────────────────────────────────────────
+/**
+ * In-memory virtual filesystem with optional JSON-snapshot persistence.
+ *
+ * **Memory mode** (default) — all state lives in a fast recursive tree.
+ * Use `toSnapshot()` / `fromSnapshot()` / `importSnapshot()` for serialisation.
+ *
+ * **FS mode** — same in-memory tree, but `restoreMirror()` loads a binary
+ * snapshot from disk and `flushMirror()` writes it back.  This gives you
+ * persistent VFS state across process restarts without any real POSIX filesystem
+ * semantics leaking through.
+ *
+ * @example
+ * ```ts
+ * // Pure in-memory (default)
+ * const vfs = new VirtualFileSystem();
+ *
+ * // With disk persistence
+ * const vfs = new VirtualFileSystem({ mode: "fs", snapshotPath: "./data" });
+ * await vfs.restoreMirror(); // load from disk (no-op if no snapshot yet)
+ * // ... use vfs ...
+ * await vfs.flushMirror();  // persist to disk
+ * ```
+ */
+class VirtualFileSystem extends EventEmitter {
+    root;
+    mode;
+    snapshotFile;
+    /** Active host-directory mounts: vPath → { hostPath, readOnly } */
+    mounts = new Map();
+    /** True when running in a browser environment (no host FS access). */
+    static isBrowser = typeof process === "undefined" || typeof process.versions?.node === "undefined";
+    constructor(options = {}) {
+        super();
+        this.mode = options.mode ?? "memory";
+        if (this.mode === "fs") {
+            if (!options.snapshotPath) {
+                throw new Error('VirtualFileSystem: "snapshotPath" is required when mode is "fs".');
+            }
+            this.snapshotFile = path.resolve(options.snapshotPath, "vfs-snapshot.vfsb");
+        }
+        else {
+            this.snapshotFile = null;
+        }
+        this.root = this.makeDir("", 0o755);
+    }
+    // ── Internal helpers ──────────────────────────────────────────────────────
+    makeDir(name, mode) {
+        const now = new Date();
+        return {
+            type: "directory",
+            name,
+            mode,
+            createdAt: now,
+            updatedAt: now,
+            children: new Map(),
+        };
+    }
+    makeFile(name, content, mode, compressed) {
+        const now = new Date();
+        return {
+            type: "file",
+            name,
+            content,
+            mode,
+            compressed,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    mkdirRecursive(targetPath, mode) {
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/")
+            return;
+        const parts = normalized.split("/").filter(Boolean);
+        let current = this.root;
+        let builtPath = "";
+        for (const part of parts) {
+            builtPath += `/${part}`;
+            let child = current.children.get(part);
+            if (!child) {
+                child = this.makeDir(part, mode);
+                current.children.set(part, child);
+                this.emit("dir:create", { path: builtPath, mode });
+            }
+            else if (child.type !== "directory") {
+                throw new Error(`Cannot create directory '${builtPath}': path is a file.`);
+            }
+            current = child;
+        }
+    }
+    // ── Persistence ───────────────────────────────────────────────────────────
+    /**
+     * In `"fs"` mode: reads the binary snapshot (`vfs-snapshot.vfsb`) from disk.
+     * Automatically falls back to legacy JSON format for backward compatibility.
+     * Silently succeeds when the snapshot file does not exist yet.
+     *
+     * In `"memory"` mode: no-op (kept for API compatibility).
+     */
+    async restoreMirror() {
+        if (this.mode !== "fs" || !this.snapshotFile)
+            return;
+        if (!fsSync.existsSync(this.snapshotFile))
+            return;
+        try {
+            const raw = fsSync.readFileSync(this.snapshotFile);
+            if (isBinarySnapshot(raw)) {
+                // Fast binary format (current)
+                this.root = decodeVfs(raw);
+            }
+            else {
+                // Legacy JSON fallback — auto-migrates on next flushMirror()
+                const snapshot = JSON.parse(raw.toString("utf8"));
+                this.root = this.deserializeDir(snapshot.root, "");
+                console.info("[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.");
+            }
+            this.emit("snapshot:restore", { path: this.snapshotFile });
+        }
+        catch (err) {
+            // Corrupt or unreadable snapshot — start fresh and warn
+            console.warn(`[VirtualFileSystem] Could not restore snapshot from ${this.snapshotFile}:`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    /**
+     * In `"fs"` mode: serialises the in-memory tree to a binary snapshot on disk
+     * (`vfs-snapshot.vfsb`). ~27% smaller and significantly faster than JSON+base64.
+     * The directory is created if it does not exist.
+     *
+     * In `"memory"` mode: emits `"mirror:flush"` and returns (no disk write).
+     */
+    async flushMirror() {
+        if (this.mode !== "fs" || !this.snapshotFile) {
+            this.emit("mirror:flush");
+            return;
+        }
+        const dir = path.dirname(this.snapshotFile);
+        fsSync.mkdirSync(dir, { recursive: true });
+        const binary = encodeVfs(this.root);
+        fsSync.writeFileSync(this.snapshotFile, binary);
+        this.emit("mirror:flush", { path: this.snapshotFile });
+    }
+    /** Returns the current persistence mode. */
+    getMode() {
+        return this.mode;
+    }
+    /** Returns the snapshot file path used in `"fs"` mode, or `null`. */
+    getSnapshotPath() {
+        return this.snapshotFile;
+    }
+    // ── Public filesystem API ─────────────────────────────────────────────────
+    /** Creates a directory (and any missing parents). */
+    // ── Mount API ─────────────────────────────────────────────────────────────
+    /**
+     * Mount a host directory into the VFS at `vPath`.
+     *
+     * Files inside `vPath` are read directly from the host filesystem via
+     * `node:fs`. All standard VFS operations (`readFile`, `writeFile`,
+     * `exists`, `stat`, `list`) are transparently delegated.
+     *
+     * In browser environments the mount is silently ignored — `vPath` remains
+     * an empty in-memory directory.
+     *
+     * @param vPath     Absolute path inside the VM (e.g. `"/app"`).
+     * @param hostPath  Path on the host filesystem — relative paths are
+     *                  resolved from `process.cwd()`.
+     * @param readOnly  When `true` (default), write operations inside the
+     *                  mount throw `EROFS: read-only file system`.
+     *
+     * @example
+     * ```ts
+     * shell.vfs.mount("/app", "./src", { readOnly: true });
+     * // cat /app/index.ts  — reads ./src/index.ts from host
+     * ```
+     */
+    mount(vPath, hostPath, { readOnly = true } = {}) {
+        if (VirtualFileSystem.isBrowser)
+            return; // silently degrade in browser
+        const normalized = normalizePath(vPath);
+        const resolved = path.resolve(hostPath);
+        if (!fsSync.existsSync(resolved)) {
+            throw new Error(`VirtualFileSystem.mount: host path does not exist: "${resolved}"`);
+        }
+        if (!fsSync.statSync(resolved).isDirectory()) {
+            throw new Error(`VirtualFileSystem.mount: host path is not a directory: "${resolved}"`);
+        }
+        // Ensure the mount point exists in the VFS tree
+        this.mkdir(normalized);
+        this.mounts.set(normalized, { hostPath: resolved, readOnly });
+        this.emit("mount", { vPath: normalized, hostPath: resolved, readOnly });
+    }
+    /**
+     * Unmount a previously mounted host directory.
+     * The in-memory VFS directory at `vPath` is preserved but the host
+     * delegation is removed.
+     */
+    unmount(vPath) {
+        const normalized = normalizePath(vPath);
+        if (this.mounts.delete(normalized)) {
+            this.emit("unmount", { vPath: normalized });
+        }
+    }
+    /** List all active mounts. */
+    getMounts() {
+        return [...this.mounts.entries()].map(([vPath, opts]) => ({
+            vPath, ...opts,
+        }));
+    }
+    /**
+     * If `targetPath` is inside a mount, return `{ hostPath, readOnly, relPath }`.
+     * `relPath` is the path relative to the mount's host directory.
+     * Returns `null` if the path is not under any mount.
+     */
+    resolveMount(targetPath) {
+        const normalized = normalizePath(targetPath);
+        // Iterate mounts from most specific to least specific
+        const sorted = [...this.mounts.entries()].sort(([a], [b]) => b.length - a.length);
+        for (const [vBase, opts] of sorted) {
+            if (normalized === vBase || normalized.startsWith(`${vBase}/`)) {
+                const relPath = normalized.slice(vBase.length).replace(/^\//, "");
+                const fullHostPath = relPath ? path.join(opts.hostPath, relPath) : opts.hostPath;
+                return { hostPath: opts.hostPath, readOnly: opts.readOnly, relPath, fullHostPath };
+            }
+        }
+        return null;
+    }
+    mkdir(targetPath, mode = 0o755) {
+        const normalized = normalizePath(targetPath);
+        const existing = (() => {
+            try {
+                return getNode(this.root, normalized);
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (existing && existing.type !== "directory") {
+            throw new Error(`Cannot create directory '${normalized}': path is a file.`);
+        }
+        this.mkdirRecursive(normalized, mode);
+    }
+    /**
+     * Writes UTF-8 text or binary content into a file.
+     * Parent directories are created when missing.
+     */
+    writeFile(targetPath, content, options = {}) {
+        // Delegate to host FS if inside a mount
+        const m = this.resolveMount(targetPath);
+        if (m) {
+            if (m.readOnly)
+                throw new Error(`EROFS: read-only file system, open '${m.fullHostPath}'`);
+            const dir = path.dirname(m.fullHostPath);
+            if (!fsSync.existsSync(dir))
+                fsSync.mkdirSync(dir, { recursive: true });
+            fsSync.writeFileSync(m.fullHostPath, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+            return;
+        }
+        const normalized = normalizePath(targetPath);
+        const { parent, name } = getParentDirectory(this.root, normalized, true, (p) => this.mkdirRecursive(p, 0o755));
+        const existing = parent.children.get(name);
+        if (existing?.type === "directory") {
+            throw new Error(`Cannot write file '${normalized}': path is a directory.`);
+        }
+        const rawContent = Buffer.isBuffer(content)
+            ? content
+            : Buffer.from(content, "utf8");
+        const shouldCompress = options.compress ?? false;
+        const storedContent = shouldCompress ? gzipSync(rawContent) : rawContent;
+        const mode = options.mode ?? 0o644;
+        if (existing) {
+            const f = existing;
+            f.content = storedContent;
+            f.compressed = shouldCompress;
+            f.mode = mode;
+            f.updatedAt = new Date();
+        }
+        else {
+            parent.children.set(name, this.makeFile(name, storedContent, mode, shouldCompress));
+        }
+        this.emit("file:write", { path: normalized, size: storedContent.length });
+    }
+    /**
+     * Reads file content as a UTF-8 string.
+     * Gzip-compressed files are transparently decompressed.
+     */
+    readFile(targetPath) {
+        const m = this.resolveMount(targetPath);
+        if (m) {
+            if (!fsSync.existsSync(m.fullHostPath))
+                throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+            return fsSync.readFileSync(m.fullHostPath, "utf8");
+        }
+        const normalized = normalizePath(targetPath);
+        const node = getNode(this.root, normalized);
+        if (node.type !== "file") {
+            throw new Error(`Cannot read '${targetPath}': not a file.`);
+        }
+        const f = node;
+        const raw = f.compressed ? gunzipSync(f.content) : f.content;
+        this.emit("file:read", { path: normalized, size: raw.length });
+        return raw.toString("utf8");
+    }
+    /** Reads file content as a Buffer (decompresses if needed). */
+    readFileRaw(targetPath) {
+        const m = this.resolveMount(targetPath);
+        if (m) {
+            if (!fsSync.existsSync(m.fullHostPath))
+                throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+            return fsSync.readFileSync(m.fullHostPath);
+        }
+        const normalized = normalizePath(targetPath);
+        const node = getNode(this.root, normalized);
+        if (node.type !== "file") {
+            throw new Error(`Cannot read '${targetPath}': not a file.`);
+        }
+        const f = node;
+        const raw = f.compressed ? gunzipSync(f.content) : f.content;
+        this.emit("file:read", { path: normalized, size: raw.length });
+        return raw;
+    }
+    /** Returns true when a file or directory exists at path. */
+    exists(targetPath) {
+        const m = this.resolveMount(targetPath);
+        if (m)
+            return fsSync.existsSync(m.fullHostPath);
+        try {
+            getNode(this.root, normalizePath(targetPath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Updates mode bits on a node. */
+    chmod(targetPath, mode) {
+        getNode(this.root, normalizePath(targetPath)).mode = mode;
+    }
+    /** Returns metadata for a file or directory. */
+    stat(targetPath) {
+        const m = this.resolveMount(targetPath);
+        if (m) {
+            if (!fsSync.existsSync(m.fullHostPath))
+                throw new Error(`ENOENT: stat '${m.fullHostPath}'`);
+            const hst = fsSync.statSync(m.fullHostPath);
+            const name = m.relPath.split("/").pop() ?? m.fullHostPath.split("/").pop() ?? "";
+            const now = hst.mtime;
+            if (hst.isDirectory()) {
+                return {
+                    type: "directory",
+                    name,
+                    path: normalizePath(targetPath),
+                    mode: 0o755,
+                    createdAt: hst.birthtime,
+                    updatedAt: now,
+                    childrenCount: fsSync.readdirSync(m.fullHostPath).length,
+                };
+            }
+            return {
+                type: "file",
+                name,
+                path: normalizePath(targetPath),
+                mode: m.readOnly ? 0o444 : 0o644,
+                createdAt: hst.birthtime,
+                updatedAt: now,
+                compressed: false,
+                size: hst.size,
+            };
+        }
+        const normalized = normalizePath(targetPath);
+        const node = getNode(this.root, normalized);
+        const name = normalized === "/" ? "" : path.posix.basename(normalized);
+        if (node.type === "file") {
+            const f = node;
+            return {
+                type: "file",
+                name,
+                path: normalized,
+                mode: f.mode,
+                createdAt: f.createdAt,
+                updatedAt: f.updatedAt,
+                compressed: f.compressed,
+                size: f.content.length,
+            };
+        }
+        const d = node;
+        return {
+            type: "directory",
+            name,
+            path: normalized,
+            mode: d.mode,
+            createdAt: d.createdAt,
+            updatedAt: d.updatedAt,
+            childrenCount: d.children.size,
+        };
+    }
+    /** Lists direct children names of a directory (sorted). */
+    list(dirPath = "/") {
+        const m = this.resolveMount(dirPath);
+        if (m) {
+            if (!fsSync.existsSync(m.fullHostPath))
+                return [];
+            try {
+                return fsSync.readdirSync(m.fullHostPath).sort();
+            }
+            catch {
+                return [];
+            }
+        }
+        const normalized = normalizePath(dirPath);
+        const node = getNode(this.root, normalized);
+        if (node.type !== "directory") {
+            throw new Error(`Cannot list '${dirPath}': not a directory.`);
+        }
+        return Array.from(node.children.keys()).sort();
+    }
+    /** Renders ASCII tree view of a directory hierarchy. */
+    tree(dirPath = "/") {
+        const normalized = normalizePath(dirPath);
+        const node = getNode(this.root, normalized);
+        if (node.type !== "directory") {
+            throw new Error(`Cannot render tree for '${dirPath}': not a directory.`);
+        }
+        const label = dirPath === "/" ? "/" : path.posix.basename(normalized);
+        return this.renderTreeLines(node, label);
+    }
+    renderTreeLines(dir, label) {
+        const lines = [label];
+        const entries = Array.from(dir.children.keys()).sort();
+        for (let i = 0; i < entries.length; i++) {
+            const name = entries[i];
+            const child = dir.children.get(name);
+            const isLast = i === entries.length - 1;
+            const connector = isLast ? "└── " : "├── ";
+            const nextPrefix = isLast ? "    " : "│   ";
+            lines.push(`${connector}${name}`);
+            if (child.type === "directory") {
+                const sub = this.renderTreeLines(child, "")
+                    .split("\n")
+                    .slice(1)
+                    .map((l) => `${nextPrefix}${l}`);
+                lines.push(...sub);
+            }
+        }
+        return lines.join("\n");
+    }
+    /** Computes total stored bytes under a path. */
+    getUsageBytes(targetPath = "/") {
+        return this.computeUsage(getNode(this.root, normalizePath(targetPath)));
+    }
+    computeUsage(node) {
+        if (node.type === "file")
+            return node.content.length;
+        let total = 0;
+        for (const child of node.children.values()) {
+            total += this.computeUsage(child);
+        }
+        return total;
+    }
+    /** Compresses a file's content with gzip in place. */
+    compressFile(targetPath) {
+        const node = getNode(this.root, normalizePath(targetPath));
+        if (node.type !== "file")
+            throw new Error(`Cannot compress '${targetPath}': not a file.`);
+        const f = node;
+        if (!f.compressed) {
+            f.content = gzipSync(f.content);
+            f.compressed = true;
+            f.updatedAt = new Date();
+        }
+    }
+    /** Decompresses a gzip-compressed file in place. */
+    decompressFile(targetPath) {
+        const node = getNode(this.root, normalizePath(targetPath));
+        if (node.type !== "file")
+            throw new Error(`Cannot decompress '${targetPath}': not a file.`);
+        const f = node;
+        if (f.compressed) {
+            f.content = gunzipSync(f.content);
+            f.compressed = false;
+            f.updatedAt = new Date();
+        }
+    }
+    /**
+     * Creates a symbolic link.
+     * The link node is stored with mode `0o120777` (POSIX symlink convention).
+     */
+    symlink(targetPath, linkPath) {
+        const normalizedLink = normalizePath(linkPath);
+        const normalizedTarget = targetPath.startsWith("/")
+            ? normalizePath(targetPath)
+            : targetPath;
+        const { parent, name } = getParentDirectory(this.root, normalizedLink, true, (p) => this.mkdirRecursive(p, 0o755));
+        const symNode = {
+            type: "file",
+            name,
+            content: Buffer.from(normalizedTarget, "utf8"),
+            mode: 0o120777,
+            compressed: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        parent.children.set(name, symNode);
+        this.emit("symlink:create", {
+            link: normalizedLink,
+            target: normalizedTarget,
+        });
+    }
+    /** Returns true when the path is a symbolic link node. */
+    isSymlink(targetPath) {
+        try {
+            const node = getNode(this.root, normalizePath(targetPath));
+            return node.type === "file" && node.mode === 0o120777;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Resolves a symlink chain up to `maxDepth` hops.
+     * Throws when the chain is too long (circular links).
+     */
+    resolveSymlink(linkPath, maxDepth = 8) {
+        let current = normalizePath(linkPath);
+        for (let depth = 0; depth < maxDepth; depth++) {
+            try {
+                const node = getNode(this.root, current);
+                if (node.type === "file" && node.mode === 0o120777) {
+                    const target = node.content.toString("utf8");
+                    current = target.startsWith("/")
+                        ? target
+                        : normalizePath(path.posix.join(path.posix.dirname(current), target));
+                    continue;
+                }
+            }
+            catch {
+                break;
+            }
+            return current;
+        }
+        throw new Error(`Too many levels of symbolic links: ${linkPath}`);
+    }
+    /** Removes a file or directory node. */
+    remove(targetPath, options = {}) {
+        const m = this.resolveMount(targetPath);
+        if (m) {
+            if (m.readOnly)
+                throw new Error(`EROFS: read-only file system, unlink '${m.fullHostPath}'`);
+            if (!fsSync.existsSync(m.fullHostPath))
+                throw new Error(`ENOENT: no such file or directory, unlink '${m.fullHostPath}'`);
+            const hst = fsSync.statSync(m.fullHostPath);
+            if (hst.isDirectory()) {
+                fsSync.rmSync(m.fullHostPath, { recursive: options.recursive ?? false });
+            }
+            else {
+                fsSync.unlinkSync(m.fullHostPath);
+            }
+            return;
+        }
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/")
+            throw new Error("Cannot remove root directory.");
+        const node = getNode(this.root, normalized);
+        if (node.type === "directory") {
+            const dir = node;
+            if (!options.recursive && dir.children.size > 0) {
+                throw new Error(`Directory '${normalized}' is not empty. Use recursive option.`);
+            }
+        }
+        const { parent, name } = getParentDirectory(this.root, normalized, false, () => { });
+        parent.children.delete(name);
+        this.emit("node:remove", { path: normalized });
+    }
+    /** Moves or renames a node. */
+    move(fromPath, toPath) {
+        const fromNormalized = normalizePath(fromPath);
+        const toNormalized = normalizePath(toPath);
+        if (fromNormalized === "/" || toNormalized === "/") {
+            throw new Error("Cannot move root directory.");
+        }
+        const node = getNode(this.root, fromNormalized);
+        if (this.exists(toNormalized)) {
+            throw new Error(`Destination '${toNormalized}' already exists.`);
+        }
+        this.mkdirRecursive(path.posix.dirname(toNormalized), 0o755);
+        const { parent: destParent, name: destName } = getParentDirectory(this.root, toNormalized, false, () => { });
+        const { parent: srcParent, name: srcName } = getParentDirectory(this.root, fromNormalized, false, () => { });
+        srcParent.children.delete(srcName);
+        node.name = destName;
+        destParent.children.set(destName, node);
+    }
+    // ── Snapshot serialisation ─────────────────────────────────────────────────
+    /**
+     * Exports the entire filesystem as a JSON-serialisable snapshot.
+     *
+     * Works regardless of the persistence mode. Useful for test fixtures,
+     * manual backups, or passing VFS state between processes.
+     */
+    toSnapshot() {
+        return { root: this.serializeDir(this.root) };
+    }
+    serializeDir(dir) {
+        const children = [];
+        for (const child of dir.children.values()) {
+            children.push(child.type === "file"
+                ? this.serializeFile(child)
+                : this.serializeDir(child));
+        }
+        return {
+            type: "directory",
+            name: dir.name,
+            mode: dir.mode,
+            createdAt: dir.createdAt.toISOString(),
+            updatedAt: dir.updatedAt.toISOString(),
+            children,
+        };
+    }
+    serializeFile(file) {
+        return {
+            type: "file",
+            name: file.name,
+            mode: file.mode,
+            createdAt: file.createdAt.toISOString(),
+            updatedAt: file.updatedAt.toISOString(),
+            compressed: file.compressed,
+            contentBase64: file.content.toString("base64"),
+        };
+    }
+    /**
+     * Creates a new `VirtualFileSystem` instance (memory mode) from a snapshot.
+     *
+     * @example
+     * ```ts
+     * const vfs = VirtualFileSystem.fromSnapshot(savedSnapshot);
+     * ```
+     */
+    static fromSnapshot(snapshot) {
+        const vfs = new VirtualFileSystem();
+        vfs.root = vfs.deserializeDir(snapshot.root, "");
+        return vfs;
+    }
+    /**
+     * Replaces the current filesystem state with the content of a snapshot.
+     * The persistence mode is preserved.
+     *
+     * @example
+     * ```ts
+     * vfs.importSnapshot(savedSnapshot);
+     * ```
+     */
+    importSnapshot(snapshot) {
+        this.root = this.deserializeDir(snapshot.root, "");
+        this.emit("snapshot:import");
+    }
+    deserializeDir(snap, name) {
+        const dir = {
+            type: "directory",
+            name,
+            mode: snap.mode,
+            createdAt: new Date(snap.createdAt),
+            updatedAt: new Date(snap.updatedAt),
+            children: new Map(),
+        };
+        for (const child of snap.children) {
+            if (child.type === "file") {
+                const f = child;
+                dir.children.set(f.name, {
+                    type: "file",
+                    name: f.name,
+                    mode: f.mode,
+                    createdAt: new Date(f.createdAt),
+                    updatedAt: new Date(f.updatedAt),
+                    compressed: f.compressed,
+                    content: Buffer.from(f.contentBase64, "base64"),
+                });
+            }
+            else {
+                const sub = this.deserializeDir(child, child.name);
+                dir.children.set(child.name, sub);
+            }
+        }
+        return dir;
+    }
+}
+export default VirtualFileSystem;
+//# sourceMappingURL=index.js.map