@fgv/ts-json-base 5.0.1-9 → 5.0.1

package/dist/packlets/file-tree/fsTree.js

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import path from 'path';
+import fs from 'fs';
+import { captureResult, succeed } from '@fgv/ts-utils';
+import { DirectoryItem } from './directoryItem';
+import { FileItem } from './fileItem';
+/**
+ * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
+ * file system to access files and directories.
+ * @public
+ */
+export class FsFileTreeAccessors {
+    /**
+     * Construct a new instance of the {@link FileTree.FsFileTreeAccessors | FsFileTreeAccessors} class.
+     * @param params - Optional {@link FileTree.IFileTreeInitParams | initialization parameters}.
+     * @public
+     */
+    constructor(params) {
+        var _a;
+        this.prefix = params === null || params === void 0 ? void 0 : params.prefix;
+        this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : FileItem.defaultInferContentType;
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     */
+    resolveAbsolutePath(...paths) {
+        if (this.prefix && !path.isAbsolute(paths[0])) {
+            return path.resolve(this.prefix, ...paths);
+        }
+        return path.resolve(...paths);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     */
+    getExtension(itemPath) {
+        return path.extname(itemPath);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     */
+    getBaseName(itemPath, suffix) {
+        return path.basename(itemPath, suffix);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     */
+    joinPaths(...paths) {
+        return path.join(...paths);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     */
+    getItem(itemPath) {
+        return captureResult(() => {
+            const stat = fs.statSync(this.resolveAbsolutePath(itemPath));
+            if (stat.isDirectory()) {
+                return DirectoryItem.create(itemPath, this).orThrow();
+            }
+            else if (stat.isFile()) {
+                return FileItem.create(itemPath, this).orThrow();
+            }
+            /* c8 ignore next 1 - defensive coding: filesystem items should be file or directory */
+            throw new Error(`${itemPath}: not a file or directory`);
+        });
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     */
+    getFileContents(filePath) {
+        return captureResult(() => fs.readFileSync(this.resolveAbsolutePath(filePath), 'utf8'));
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     */
+    getFileContentType(filePath, provided) {
+        if (provided !== undefined) {
+            return succeed(provided);
+        }
+        /* c8 ignore next 2 - coverage has intermittent issues in the build - local tests show coverage of this line */
+        return this._inferContentType(filePath);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     */
+    getChildren(dirPath) {
+        return captureResult(() => {
+            const children = [];
+            const files = fs.readdirSync(this.resolveAbsolutePath(dirPath), { withFileTypes: true });
+            files.forEach((file) => {
+                const fullPath = this.resolveAbsolutePath(dirPath, file.name);
+                if (file.isDirectory()) {
+                    children.push(DirectoryItem.create(fullPath, this).orThrow());
+                }
+                else if (file.isFile()) {
+                    children.push(FileItem.create(fullPath, this).orThrow());
+                }
+            });
+            return children;
+        });
+    }
+}
+//# sourceMappingURL=fsTree.js.map

package/dist/packlets/file-tree/in-memory/inMemoryTree.js

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult, fail, succeed } from '@fgv/ts-utils';
+import { DirectoryItem } from '../directoryItem';
+import { FileItem } from '../fileItem';
+import { InMemoryDirectory, InMemoryFile, TreeBuilder } from './treeBuilder';
+/**
+ * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
+ * tree to access files and directories.
+ * @public
+ */
+export class InMemoryTreeAccessors {
+    /**
+     * Protected constructor for derived classes.
+     * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+     * @param params - Optional params for the tree.
+     * @public
+     */
+    constructor(files, params) {
+        var _a, _b;
+        this._tree = TreeBuilder.create(params === null || params === void 0 ? void 0 : params.prefix).orThrow();
+        this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : FileItem.defaultInferContentType;
+        for (const file of files) {
+            const contentType = (_b = file.contentType) !== null && _b !== void 0 ? _b : this._inferContentType(file.path).orDefault();
+            this._tree.addFile(file.path, file.contents, contentType).orThrow();
+        }
+    }
+    /**
+     * Creates a new {@link FileTree.InMemoryTreeAccessors | InMemoryTreeAccessors} instance with the supplied
+     * in-memory files.
+     * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+     * @param params - Optional params for the tree.
+     */
+    static create(files, params) {
+        /* c8 ignore next 2 - tested but code coverage has intermittent issues */
+        params = typeof params === 'string' ? { prefix: params } : params;
+        return captureResult(() => new InMemoryTreeAccessors(files, params));
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     */
+    resolveAbsolutePath(...paths) {
+        const parts = paths[0].startsWith('/') ? paths : [this._tree.prefix, ...paths];
+        const joined = parts.flatMap((p) => p.split('/').filter((s) => s.length > 0)).join('/');
+        return `/${joined}`;
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     */
+    getExtension(path) {
+        const parts = path.split('.');
+        if (parts.length === 1) {
+            return '';
+        }
+        return `.${parts.pop()}`;
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     */
+    getBaseName(path, suffix) {
+        var _a;
+        /* c8 ignore next 1 - ?? is defense in depth should never happen */
+        const base = (_a = path.split('/').pop()) !== null && _a !== void 0 ? _a : '';
+        if (suffix && base.endsWith(suffix)) {
+            return base.slice(0, base.length - suffix.length);
+        }
+        return base;
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     */
+    joinPaths(...paths) {
+        return paths.join('/');
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     */
+    getItem(itemPath) {
+        const existing = this._tree.byAbsolutePath.get(itemPath);
+        if (existing) {
+            if (existing instanceof InMemoryFile) {
+                return FileItem.create(existing.absolutePath, this);
+            }
+            else if (existing instanceof InMemoryDirectory) {
+                return DirectoryItem.create(existing.absolutePath, this);
+            }
+        }
+        return fail(`${itemPath}: not found`);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     */
+    getFileContents(path) {
+        const item = this._tree.byAbsolutePath.get(path);
+        if (item === undefined) {
+            return fail(`${path}: not found`);
+        }
+        /* c8 ignore next 3 - local coverage is 100% but build coverage has intermittent issues */
+        if (!(item instanceof InMemoryFile)) {
+            return fail(`${path}: not a file`);
+        }
+        // if the body is a string we don't want to add quotes
+        if (typeof item.contents === 'string') {
+            return succeed(item.contents);
+        }
+        /* c8 ignore next 2 - local coverage is 100% but build coverage has intermittent issues */
+        return captureResult(() => JSON.stringify(item.contents));
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     */
+    getFileContentType(path, provided) {
+        // If provided contentType is given, use it directly (highest priority)
+        if (provided !== undefined) {
+            return succeed(provided);
+        }
+        const item = this._tree.byAbsolutePath.get(path);
+        if (item === undefined) {
+            // If file doesn't exist, still try to infer content type from path
+            return this._inferContentType(path);
+        }
+        if (!(item instanceof InMemoryFile)) {
+            // For directories, return undefined
+            return succeed(undefined);
+        }
+        // Return stored contentType if it exists, otherwise infer
+        if (item.contentType !== undefined) {
+            return succeed(item.contentType);
+        }
+        return this._inferContentType(path);
+    }
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     */
+    getChildren(path) {
+        const item = this._tree.byAbsolutePath.get(path);
+        if (item === undefined) {
+            return fail(`${path}: not found`);
+        }
+        /* c8 ignore next 3 - local coverage is 100% but build coverage has intermittent issues */
+        if (!(item instanceof InMemoryDirectory)) {
+            return fail(`${path}: not a directory`);
+        }
+        return captureResult(() => {
+            const children = [];
+            for (const child of item.children.values()) {
+                if (child instanceof InMemoryFile) {
+                    children.push(FileItem.create(child.absolutePath, this).orThrow());
+                }
+                else if (child instanceof InMemoryDirectory) {
+                    children.push(DirectoryItem.create(child.absolutePath, this).orThrow());
+                }
+            }
+            return children;
+        });
+    }
+}
+//# sourceMappingURL=inMemoryTree.js.map

package/dist/packlets/file-tree/in-memory/index.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from './inMemoryTree';
+//# sourceMappingURL=index.js.map

package/dist/packlets/file-tree/in-memory/treeBuilder.js

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { captureResult, fail, succeed } from '@fgv/ts-utils';
+/**
+ * Represents a file in an in-memory file tree.
+ * @public
+ */
+export class InMemoryFile {
+    /**
+     * Creates a new {@link FileTree.InMemoryFile | InMemoryFile} instance.
+     * @param absolutePath - The absolute path of the file.
+     * @param contents - The contents of the file.
+     * @param contentType - Optional content type of the file.
+     */
+    constructor(absolutePath, contents, contentType) {
+        this.absolutePath = absolutePath;
+        this.contents = contents;
+        this.contentType = contentType;
+    }
+}
+/**
+ * Represents a directory in an in-memory file tree.
+ * @public
+ */
+export class InMemoryDirectory {
+    /**
+     * The children of the directory.
+     */
+    get children() {
+        return this._children;
+    }
+    /**
+     * Creates an empty new {@link FileTree.InMemoryDirectory | InMemoryDirectory} instance.
+     * @param absolutePath - The absolute path of the directory.
+     */
+    constructor(absolutePath) {
+        this.absolutePath = absolutePath;
+        this._children = new Map();
+    }
+    /**
+     * Gets or adds a child directory with the specified name.
+     * @param name - The name of the child directory.
+     * @returns `Success` with the child directory if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    getOrAddDirectory(name) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof InMemoryDirectory) {
+                return succeed(existing);
+            }
+            return fail(`${name}: not a directory`);
+        }
+        const child = new InMemoryDirectory(this.getChildPath(name));
+        this._children.set(name, child);
+        return succeed(child);
+    }
+    /**
+     * Adds a file to the directory.
+     * @param name - The name of the file.
+     * @param contents - The contents of the file.
+     * @param contentType - Optional content type of the file.
+     * @returns `Success` with the new file if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    addFile(name, contents, contentType) {
+        if (this._children.has(name)) {
+            return fail(`${name}: already exists`);
+        }
+        const child = new InMemoryFile(this.getChildPath(name), contents, contentType);
+        this._children.set(name, child);
+        return succeed(child);
+    }
+    /**
+     * Gets the absolute path for a child of this directory with the supplied
+     * name.
+     * @param name - The name of the child.
+     * @returns `Success` with the absolute path if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    getChildPath(name) {
+        if (this.absolutePath === '/') {
+            return `/${name}`;
+        }
+        return [this.absolutePath, name].join('/');
+    }
+}
+/**
+ * Helper class to build an in-memory file tree.
+ * @public
+ */
+export class TreeBuilder {
+    /**
+     * Protected constructor for derived classes.
+     * @param prefix - The prefix for all paths in the tree.
+     * @public
+     */
+    constructor(prefix) {
+        this.prefix = prefix !== null && prefix !== void 0 ? prefix : '/';
+        if (!this.prefix.startsWith('/')) {
+            throw new Error(`${prefix}: not an absolute path`);
+        }
+        // Normalize the prefix to remove trailing slashes (except for root)
+        /* c8 ignore next 3 - tested but code coverage has intermittent issues */
+        if (this.prefix !== '/' && this.prefix.endsWith('/')) {
+            this.prefix = this.prefix.slice(0, -1);
+        }
+        this.root = new InMemoryDirectory(this.prefix);
+        this.byAbsolutePath = new Map();
+        this.byAbsolutePath.set(this.prefix, this.root);
+    }
+    /**
+     * Creates a new {@link TreeBuilder} instance.
+     * @param prefix - The prefix for all paths in the tree.
+     * @returns `Success` with the new {@link TreeBuilder} instance if successful,
+     * or `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(prefix) {
+        return captureResult(() => new TreeBuilder(prefix));
+    }
+    /**
+     * Adds a file to the tree.
+     * @param absolutePath - The absolute path of the file.
+     * @param contents - The contents of the file.
+     * @param contentType - The content type of the file.
+     * @returns `Success` with the new file if successful, or
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    addFile(absolutePath, contents, contentType) {
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return fail(`${absolutePath}: invalid file path`);
+        }
+        let dir = this.root;
+        while (parts.length > 1) {
+            const part = parts.shift();
+            const result = dir.getOrAddDirectory(part);
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            dir = result.value;
+            if (!this.byAbsolutePath.has(dir.absolutePath)) {
+                this.byAbsolutePath.set(dir.absolutePath, dir);
+            }
+        }
+        return dir.addFile(parts[0], contents, contentType).onSuccess((file) => {
+            this.byAbsolutePath.set(file.absolutePath, file);
+            return succeed(file);
+        });
+    }
+}
+//# sourceMappingURL=treeBuilder.js.map

package/dist/packlets/file-tree/index.browser.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// Browser-safe FileTree exports - excludes Node.js filesystem dependencies
+// Export core interfaces and classes
+export * from './fileTreeAccessors';
+export * from './fileTree';
+export * from './directoryItem';
+export * from './fileItem';
+// Export in-memory implementations for web compatibility
+export * from './in-memory';
+export { inMemory } from './fileTreeHelpers.inMemory';
+// Exclude:
+// - fsTree (requires Node.js fs/path)
+// - fileTreeHelpers (imports fsTree)
+//# sourceMappingURL=index.browser.js.map

package/dist/packlets/file-tree/index.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+// Export core interfaces and classes
+export * from './fileTreeAccessors';
+export * from './fileTree';
+export * from './directoryItem';
+export * from './fileItem';
+// Export tree-shakeable helpers (filesystem ones will be shaken out if not used)
+export * from './fileTreeHelpers';
+export { inMemory } from './fileTreeHelpers.inMemory';
+// Export in-memory implementations for web compatibility
+export * from './in-memory';
+// Note: FsFileTreeAccessors is now only imported by fileTreeHelpers.ts
+// Web apps that don't use forFilesystem() won't bundle fs/path dependencies
+export * from './fsTree';
+//# sourceMappingURL=index.js.map