@wener/common 2.0.3 → 2.0.6

package/lib/fs/createMemoryFileSystem.js

@@ -1,516 +1,479 @@
-import { computeIfAbsent } from "@wener/utils";
-import { basename, dirname, normalize } from "pathe";
-import { findMimeType } from "./findMimeType.js";
+import { computeIfAbsent } from '@wener/utils';
+import { basename, dirname, normalize } from 'pathe';
+import { FileSystemError } from './FileSystemError.js';
+import { findMimeType } from './findMimeType.js';
 export function createMemoryFileSystem(options = {}) {
-    return new MemFS(options);
+	return new MemFS(options);
 }
-let MemoryFileSystemError = class MemoryFileSystemError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.name = "MemoryFileSystemError";
-        this.code = code;
-    }
+let MemoryFileSystemError = class MemoryFileSystemError extends FileSystemError {
+	constructor(message, code) {
+		super(message, code);
+		this.name = 'MemoryFileSystemError';
+	}
 };
 let MemFS = class MemFS {
-    root;
-    cache = new WeakMap();
-    constructor({ root } = {}) {
-        this.root = root || {
-            name: "",
-            kind: "directory",
-            path: "/",
-            directory: "",
-            children: [],
-            size: 0,
-            mtime: Date.now(),
-            meta: {}
-        };
-    }
-    /**
-     * 核心辅助方法：通过路径查找节点
-     * @returns A tuple: [foundNode, parentNode, finalName]
-     */ _getNodeByPath(path) {
-        if (!path || typeof path !== "string") {
-            throw new MemoryFileSystemError("Invalid path: path must be a non-empty string", "EINVAL");
-        }
-        const normalized = normalize(path);
-        if (normalized === "/") {
-            // the parent of root is itself
-            return [
-                this.root,
-                this.root,
-                ""
-            ];
-        }
-        const parts = normalized.split("/").filter((p) => p);
-        if (parts.length === 0) {
-            return [
-                this.root,
-                this.root,
-                ""
-            ];
-        }
-        const finalName = parts.pop();
-        let current = this.root;
-        for (const part of parts) {
-            if (!part)
-                continue; // skip empty parts
-            const found = current.children.find((child) => child.name === part);
-            if (!found || found.kind !== "directory") {
-                return [
-                    null,
-                    null,
-                    finalName
-                ];
-            }
-            current = found;
-        }
-        const node = current.children.find((child) => child.name === finalName) ?? null;
-        return [
-            node,
-            current,
-            finalName
-        ];
-    }
-    /**
-     * 核心辅助方法：查找或创建目录
-     */ _findOrCreateDirectory(path) {
-        if (!path || typeof path !== "string") {
-            throw new MemoryFileSystemError("Invalid path: path must be a non-empty string", "EINVAL");
-        }
-        const normalized = normalize(path);
-        if (normalized === "/")
-            return this.root;
-        const parts = normalized.split("/").filter((p) => p);
-        if (parts.length === 0)
-            return this.root;
-        let current = this.root;
-        let currentPath = "";
-        for (const part of parts) {
-            if (!part)
-                continue; // skip empty parts
-            currentPath = `${currentPath}/${part}`;
-            let found = current.children.find((child) => child.name === part);
-            if (!found) {
-                const now = Date.now();
-                const newDir = {
-                    name: part,
-                    kind: "directory",
-                    path: currentPath,
-                    directory: dirname(currentPath),
-                    children: [],
-                    size: 0,
-                    mtime: now,
-                    meta: {}
-                };
-                current.children.push(newDir);
-                current = newDir;
-            }
-            else if (found.kind !== "directory") {
-                throw new MemoryFileSystemError(`Path conflict: ${currentPath} is a file`, "ENOTDIR");
-            }
-            else {
-                current = found;
-            }
-        }
-        return current;
-    }
-    async stat(path, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (!node) {
-            throw new MemoryFileSystemError(`File not found: ${path}`, "ENOENT");
-        }
-        return {
-            ...node
-        };
-    }
-    async exists(path) {
-        const [node] = this._getNodeByPath(path);
-        return !!node;
-    }
-    async readdir(path, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (!node) {
-            throw new MemoryFileSystemError(`Directory not found: ${path}`, "ENOENT");
-        }
-        if (node.kind !== "directory") {
-            throw new MemoryFileSystemError(`Not a directory: ${path}`, "ENOTDIR");
-        }
-        // 返回副本
-        return node.children.map((child) => ({
-            ...child
-        }));
-    }
-    async mkdir(path, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (node) {
-            if (node.kind === "file")
-                throw new MemoryFileSystemError(`File already exists: ${path}`, "EEXIST");
-            return; // 目录已存在
-        }
-        if (options?.recursive) {
-            this._findOrCreateDirectory(path);
-        }
-        else {
-            const parentPath = dirname(path);
-            const [, parent] = this._getNodeByPath(parentPath);
-            if (!parent) {
-                throw new MemoryFileSystemError(`Parent directory does not exist: ${parentPath}`, "ENOENT");
-            }
-            this._findOrCreateDirectory(path);
-        }
-    }
-    async readFile(path, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (!node) {
-            throw new MemoryFileSystemError(`File not found: ${path}`, "ENOENT");
-        }
-        if (node.kind !== "file") {
-            throw new MemoryFileSystemError(`Is a directory: ${path}`, "EISDIR");
-        }
-        const content = "content" in node ? node.content : "";
-        return options?.encoding === "text" ? content.toString() : Buffer.from(content);
-    }
-    async writeFile(path, data, options = {}) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        if (!path || typeof path !== "string") {
-            throw new MemoryFileSystemError("Invalid path: path must be a non-empty string", "EINVAL");
-        }
-        if (data === null || data === undefined) {
-            throw new MemoryFileSystemError("Invalid data: data cannot be null or undefined", "EINVAL");
-        }
-        const { overwrite = true } = options;
-        const parentPath = dirname(path);
-        const filename = basename(path);
-        if (!filename) {
-            throw new MemoryFileSystemError("Invalid path: filename cannot be empty", "EINVAL");
-        }
-        const parent = this._findOrCreateDirectory(parentPath);
-        const nodeIndex = parent.children.findIndex((child) => child.name === filename);
-        const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
-        if (existingNode) {
-            if (!overwrite)
-                throw new MemoryFileSystemError(`File already exists: ${path}`, "EEXIST");
-            if (existingNode.kind === "directory")
-                throw new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, "EISDIR");
-            // 更新文件
-            existingNode.content = data;
-            existingNode.size = data.length;
-            existingNode.mtime = Date.now();
-        }
-        else {
-            // 创建新文件
-            const now = Date.now();
-            const newFile = {
-                name: filename,
-                kind: "file",
-                path: path,
-                directory: parentPath,
-                content: data,
-                size: data.length,
-                mtime: now,
-                meta: {}
-            };
-            parent.children.push(newFile);
-        }
-    }
-    async rm(path, options = {}) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const { recursive = false, force = false } = options;
-        const [node, parent] = this._getNodeByPath(path);
-        if (!node) {
-            if (force)
-                return;
-            throw new MemoryFileSystemError(`File not found: ${path}`, "ENOENT");
-        }
-        if (node.kind === "directory" && node.children.length > 0 && !recursive) {
-            throw new MemoryFileSystemError(`Directory not empty: ${path}`, "ENOTEMPTY");
-        }
-        if (parent) {
-            const index = parent.children.findIndex((child) => child.name === node.name);
-            if (index !== -1) {
-                parent.children.splice(index, 1);
-            }
-        }
-    }
-    async rename(oldPath, newPath, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [oldNode, oldParent, oldName] = this._getNodeByPath(oldPath);
-        if (!oldNode || !oldParent)
-            throw new MemoryFileSystemError(`Source not found: ${oldPath}`, "ENOENT");
-        const oldNodeIndex = oldParent.children.findIndex((c) => c.name === oldName);
-        oldParent.children.splice(oldNodeIndex, 1);
-        const newParentPath = dirname(newPath);
-        const newName = basename(newPath);
-        const newParent = this._findOrCreateDirectory(newParentPath);
-        const existingNodeIndex = newParent.children.findIndex((c) => c.name === newName);
-        if (existingNodeIndex !== -1) {
-            if (!options?.overwrite)
-                throw new MemoryFileSystemError(`Destination exists: ${newPath}`, "EEXIST");
-            newParent.children.splice(existingNodeIndex, 1);
-        }
-        oldNode.name = newName;
-        oldNode.path = newPath;
-        oldNode.directory = newParentPath;
-        oldNode.mtime = Date.now();
-        newParent.children.push(oldNode);
-    }
-    async copy(srcPath, destPath, options) {
-        if (options?.signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [srcNode] = this._getNodeByPath(srcPath);
-        if (!srcNode)
-            throw new MemoryFileSystemError(`Source not found: ${srcPath}`, "ENOENT");
-        const deepClone = (node) => JSON.parse(JSON.stringify(node));
-        const newNode = deepClone(srcNode);
-        const newParentPath = dirname(destPath);
-        const newName = basename(destPath);
-        const newParent = this._findOrCreateDirectory(newParentPath);
-        newNode.name = newName;
-        newNode.path = destPath;
-        newNode.directory = newParentPath;
-        const existingNodeIndex = newParent.children.findIndex((c) => c.name === newName);
-        if (existingNodeIndex !== -1) {
-            if (!options?.overwrite)
-                throw new MemoryFileSystemError(`Destination exists: ${destPath}`, "EEXIST");
-            newParent.children[existingNodeIndex] = newNode;
-        }
-        else {
-            newParent.children.push(newNode);
-        }
-    }
-    createReadStream(path, options) {
-        const { signal, range } = options || {};
-        if (signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (!node) {
-            throw new MemoryFileSystemError(`File not found: ${path}`, "ENOENT");
-        }
-        if (node.kind !== "file") {
-            throw new MemoryFileSystemError(`Is a directory: ${path}`, "EISDIR");
-        }
-        const content = Buffer.from("content" in node ? node.content : "");
-        const { Readable } = require("node:stream");
-        let data = content;
-        if (range) {
-            const start = range.start || 0;
-            const end = range.end || content.length - 1;
-            data = content.subarray(start, end + 1);
-        }
-        const stream = Readable.from([
-            data
-        ]);
-        if (signal) {
-            signal.addEventListener("abort", () => {
-                stream.destroy(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-            });
-        }
-        return stream;
-    }
-    createWriteStream(path, options) {
-        const { signal, overwrite = true } = options || {};
-        if (signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const { Writable } = require("node:stream");
-        const chunks = [];
-        const self = this;
-        const stream = new Writable({
-            write(chunk, encoding, callback) {
-                if (signal?.aborted) {
-                    callback(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-                    return;
-                }
-                chunks.push(chunk);
-                callback();
-            },
-            final(callback) {
-                if (signal?.aborted) {
-                    callback(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-                    return;
-                }
-                try {
-                    const content = Buffer.concat(chunks);
-                    const parentPath = dirname(path);
-                    const filename = basename(path);
-                    const parent = self._findOrCreateDirectory(parentPath);
-                    const nodeIndex = parent.children.findIndex((child) => child.name === filename);
-                    const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
-                    if (existingNode) {
-                        if (!overwrite) {
-                            callback(new MemoryFileSystemError(`File already exists: ${path}`, "EEXIST"));
-                            return;
-                        }
-                        if (existingNode.kind === "directory") {
-                            callback(new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, "EISDIR"));
-                            return;
-                        }
-                        existingNode.content = content;
-                        existingNode.size = content.length;
-                        existingNode.mtime = Date.now();
-                    }
-                    else {
-                        const now = Date.now();
-                        const newFile = {
-                            name: filename,
-                            kind: "file",
-                            path: path,
-                            directory: parentPath,
-                            content: content,
-                            size: content.length,
-                            mtime: now,
-                            meta: {}
-                        };
-                        parent.children.push(newFile);
-                    }
-                    callback();
-                }
-                catch (error) {
-                    callback(error instanceof Error ? error : new MemoryFileSystemError("Unknown error", "UNKNOWN"));
-                }
-            }
-        });
-        if (signal) {
-            signal.addEventListener("abort", () => {
-                stream.destroy(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-            });
-        }
-        return stream;
-    }
-    getUrl(file) {
-        let node;
-        if (typeof file === "string") {
-            [node] = this._getNodeByPath(file);
-        }
-        else {
-            node = file;
-        }
-        let mf = node;
-        if (mf.content) {
-            let c = computeIfAbsent(this.cache, mf, () => ({}));
-            if (!c.url) {
-                let mime = findMimeType(mf.name) || "application/octet-stream";
-                c.url = URL.createObjectURL(new Blob([
-                    mf.content
-                ], {
-                    type: mime
-                }));
-            }
-            return c.url;
-        }
-        return;
-    }
-    createReadableStream(path, options) {
-        const { signal, range } = options || {};
-        if (signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const [node] = this._getNodeByPath(path);
-        if (!node) {
-            throw new MemoryFileSystemError(`File not found: ${path}`, "ENOENT");
-        }
-        if (node.kind !== "file") {
-            throw new MemoryFileSystemError(`Is a directory: ${path}`, "EISDIR");
-        }
-        const content = Buffer.from("content" in node ? node.content : "");
-        let data = content;
-        if (range) {
-            const start = range.start || 0;
-            const end = range.end || content.length - 1;
-            data = content.subarray(start, end + 1);
-        }
-        const stream = new ReadableStream({
-            start(controller) {
-                controller.enqueue(data);
-                controller.close();
-            }
-        });
-        if (signal) {
-            signal.addEventListener("abort", () => {
-                stream.cancel(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-            });
-        }
-        return stream;
-    }
-    createWritableStream(path, options) {
-        const { signal, overwrite = true } = options || {};
-        if (signal?.aborted) {
-            throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-        }
-        const chunks = [];
-        const self = this;
-        const stream = new WritableStream({
-            write(chunk) {
-                if (signal?.aborted) {
-                    throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-                }
-                chunks.push(chunk);
-            },
-            close() {
-                if (signal?.aborted) {
-                    throw new MemoryFileSystemError("Operation aborted", "ABORT_ERR");
-                }
-                const content = Buffer.concat(chunks);
-                const parentPath = dirname(path);
-                const filename = basename(path);
-                const parent = self._findOrCreateDirectory(parentPath);
-                const nodeIndex = parent.children.findIndex((child) => child.name === filename);
-                const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
-                if (existingNode) {
-                    if (!overwrite) {
-                        throw new MemoryFileSystemError(`File already exists: ${path}`, "EEXIST");
-                    }
-                    if (existingNode.kind === "directory") {
-                        throw new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, "EISDIR");
-                    }
-                    existingNode.content = content;
-                    existingNode.size = content.length;
-                    existingNode.mtime = Date.now();
-                }
-                else {
-                    const now = Date.now();
-                    const newFile = {
-                        name: filename,
-                        kind: "file",
-                        path: path,
-                        directory: parentPath,
-                        content: content,
-                        size: content.length,
-                        mtime: now,
-                        meta: {}
-                    };
-                    parent.children.push(newFile);
-                }
-            }
-        });
-        if (signal) {
-            signal.addEventListener("abort", () => {
-                stream.abort(new MemoryFileSystemError("Operation aborted", "ABORT_ERR"));
-            });
-        }
-        return stream;
-    }
+	root;
+	cache = new WeakMap();
+	constructor({ root } = {}) {
+		this.root = root || {
+			name: '',
+			kind: 'directory',
+			path: '/',
+			directory: '',
+			children: [],
+			size: 0,
+			mtime: Date.now(),
+			meta: {},
+		};
+	}
+	/**
+	 * 核心辅助方法：通过路径查找节点
+	 * @returns A tuple: [foundNode, parentNode, finalName]
+	 */ _getNodeByPath(path) {
+		if (!path || typeof path !== 'string') {
+			throw new MemoryFileSystemError('Invalid path: path must be a non-empty string', 'EINVAL');
+		}
+		const normalized = normalize(path);
+		if (normalized === '/') {
+			// the parent of root is itself
+			return [this.root, this.root, ''];
+		}
+		const parts = normalized.split('/').filter((p) => p);
+		if (parts.length === 0) {
+			return [this.root, this.root, ''];
+		}
+		const finalName = parts.pop();
+		let current = this.root;
+		for (const part of parts) {
+			if (!part) continue; // skip empty parts
+			const found = current.children.find((child) => child.name === part);
+			if (!found || found.kind !== 'directory') {
+				return [null, null, finalName];
+			}
+			current = found;
+		}
+		const node = current.children.find((child) => child.name === finalName) ?? null;
+		return [node, current, finalName];
+	}
+	/**
+	 * 核心辅助方法：查找或创建目录
+	 */ _findOrCreateDirectory(path) {
+		if (!path || typeof path !== 'string') {
+			throw new MemoryFileSystemError('Invalid path: path must be a non-empty string', 'EINVAL');
+		}
+		const normalized = normalize(path);
+		if (normalized === '/') return this.root;
+		const parts = normalized.split('/').filter((p) => p);
+		if (parts.length === 0) return this.root;
+		let current = this.root;
+		let currentPath = '';
+		for (const part of parts) {
+			if (!part) continue; // skip empty parts
+			currentPath = `${currentPath}/${part}`;
+			let found = current.children.find((child) => child.name === part);
+			if (!found) {
+				const now = Date.now();
+				const newDir = {
+					name: part,
+					kind: 'directory',
+					path: currentPath,
+					directory: dirname(currentPath),
+					children: [],
+					size: 0,
+					mtime: now,
+					meta: {},
+				};
+				current.children.push(newDir);
+				current = newDir;
+			} else if (found.kind !== 'directory') {
+				throw new MemoryFileSystemError(`Path conflict: ${currentPath} is a file`, 'ENOTDIR');
+			} else {
+				current = found;
+			}
+		}
+		return current;
+	}
+	async stat(path, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (!node) {
+			throw new MemoryFileSystemError(`File not found: ${path}`, 'ENOENT');
+		}
+		return {
+			...node,
+		};
+	}
+	async exists(path) {
+		const [node] = this._getNodeByPath(path);
+		return !!node;
+	}
+	async readdir(path, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (!node) {
+			throw new MemoryFileSystemError(`Directory not found: ${path}`, 'ENOENT');
+		}
+		if (node.kind !== 'directory') {
+			throw new MemoryFileSystemError(`Not a directory: ${path}`, 'ENOTDIR');
+		}
+		// 返回副本
+		return node.children.map((child) => ({
+			...child,
+		}));
+	}
+	async mkdir(path, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (node) {
+			if (node.kind === 'file') throw new MemoryFileSystemError(`File already exists: ${path}`, 'EEXIST');
+			return; // 目录已存在
+		}
+		if (options?.recursive) {
+			this._findOrCreateDirectory(path);
+		} else {
+			const parentPath = dirname(path);
+			const [, parent] = this._getNodeByPath(parentPath);
+			if (!parent) {
+				throw new MemoryFileSystemError(`Parent directory does not exist: ${parentPath}`, 'ENOENT');
+			}
+			this._findOrCreateDirectory(path);
+		}
+	}
+	async readFile(path, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (!node) {
+			throw new MemoryFileSystemError(`File not found: ${path}`, 'ENOENT');
+		}
+		if (node.kind !== 'file') {
+			throw new MemoryFileSystemError(`Is a directory: ${path}`, 'EISDIR');
+		}
+		const content = 'content' in node ? node.content : '';
+		return options?.encoding === 'text' ? content.toString() : Buffer.from(content);
+	}
+	async writeFile(path, data, options = {}) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		if (!path || typeof path !== 'string') {
+			throw new MemoryFileSystemError('Invalid path: path must be a non-empty string', 'EINVAL');
+		}
+		if (data === null || data === undefined) {
+			throw new MemoryFileSystemError('Invalid data: data cannot be null or undefined', 'EINVAL');
+		}
+		const { overwrite = true } = options;
+		const parentPath = dirname(path);
+		const filename = basename(path);
+		if (!filename) {
+			throw new MemoryFileSystemError('Invalid path: filename cannot be empty', 'EINVAL');
+		}
+		const parent = this._findOrCreateDirectory(parentPath);
+		const nodeIndex = parent.children.findIndex((child) => child.name === filename);
+		const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
+		if (existingNode) {
+			if (!overwrite) throw new MemoryFileSystemError(`File already exists: ${path}`, 'EEXIST');
+			if (existingNode.kind === 'directory')
+				throw new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, 'EISDIR');
+			// 更新文件
+			existingNode.content = data;
+			existingNode.size = data.length;
+			existingNode.mtime = Date.now();
+		} else {
+			// 创建新文件
+			const now = Date.now();
+			const newFile = {
+				name: filename,
+				kind: 'file',
+				path: path,
+				directory: parentPath,
+				content: data,
+				size: data.length,
+				mtime: now,
+				meta: {},
+			};
+			parent.children.push(newFile);
+		}
+	}
+	async rm(path, options = {}) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const { recursive = false, force = false } = options;
+		const [node, parent] = this._getNodeByPath(path);
+		if (!node) {
+			if (force) return;
+			throw new MemoryFileSystemError(`File not found: ${path}`, 'ENOENT');
+		}
+		if (node.kind === 'directory' && node.children.length > 0 && !recursive) {
+			throw new MemoryFileSystemError(`Directory not empty: ${path}`, 'ENOTEMPTY');
+		}
+		if (parent) {
+			const index = parent.children.findIndex((child) => child.name === node.name);
+			if (index !== -1) {
+				parent.children.splice(index, 1);
+			}
+		}
+	}
+	async rename(oldPath, newPath, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [oldNode, oldParent, oldName] = this._getNodeByPath(oldPath);
+		if (!oldNode || !oldParent) throw new MemoryFileSystemError(`Source not found: ${oldPath}`, 'ENOENT');
+		const oldNodeIndex = oldParent.children.findIndex((c) => c.name === oldName);
+		oldParent.children.splice(oldNodeIndex, 1);
+		const newParentPath = dirname(newPath);
+		const newName = basename(newPath);
+		const newParent = this._findOrCreateDirectory(newParentPath);
+		const existingNodeIndex = newParent.children.findIndex((c) => c.name === newName);
+		if (existingNodeIndex !== -1) {
+			if (!options?.overwrite) throw new MemoryFileSystemError(`Destination exists: ${newPath}`, 'EEXIST');
+			newParent.children.splice(existingNodeIndex, 1);
+		}
+		oldNode.name = newName;
+		oldNode.path = newPath;
+		oldNode.directory = newParentPath;
+		oldNode.mtime = Date.now();
+		newParent.children.push(oldNode);
+	}
+	async copy(srcPath, destPath, options) {
+		if (options?.signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [srcNode] = this._getNodeByPath(srcPath);
+		if (!srcNode) throw new MemoryFileSystemError(`Source not found: ${srcPath}`, 'ENOENT');
+		const deepClone = (node) => JSON.parse(JSON.stringify(node));
+		const newNode = deepClone(srcNode);
+		const newParentPath = dirname(destPath);
+		const newName = basename(destPath);
+		const newParent = this._findOrCreateDirectory(newParentPath);
+		newNode.name = newName;
+		newNode.path = destPath;
+		newNode.directory = newParentPath;
+		const existingNodeIndex = newParent.children.findIndex((c) => c.name === newName);
+		if (existingNodeIndex !== -1) {
+			if (!options?.overwrite) throw new MemoryFileSystemError(`Destination exists: ${destPath}`, 'EEXIST');
+			newParent.children[existingNodeIndex] = newNode;
+		} else {
+			newParent.children.push(newNode);
+		}
+	}
+	createReadStream(path, options) {
+		const { signal, range } = options || {};
+		if (signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (!node) {
+			throw new MemoryFileSystemError(`File not found: ${path}`, 'ENOENT');
+		}
+		if (node.kind !== 'file') {
+			throw new MemoryFileSystemError(`Is a directory: ${path}`, 'EISDIR');
+		}
+		const content = Buffer.from('content' in node ? node.content : '');
+		const { Readable } = require('node:stream');
+		let data = content;
+		if (range) {
+			const start = range.start || 0;
+			const end = range.end || content.length - 1;
+			data = content.subarray(start, end + 1);
+		}
+		const stream = Readable.from([data]);
+		if (signal) {
+			signal.addEventListener('abort', () => {
+				stream.destroy(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+			});
+		}
+		return stream;
+	}
+	createWriteStream(path, options) {
+		const { signal, overwrite = true } = options || {};
+		if (signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const { Writable } = require('node:stream');
+		const chunks = [];
+		const self = this;
+		const stream = new Writable({
+			write(chunk, _encoding, callback) {
+				if (signal?.aborted) {
+					callback(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+					return;
+				}
+				chunks.push(chunk);
+				callback();
+			},
+			final(callback) {
+				if (signal?.aborted) {
+					callback(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+					return;
+				}
+				try {
+					const content = Buffer.concat(chunks);
+					const parentPath = dirname(path);
+					const filename = basename(path);
+					const parent = self._findOrCreateDirectory(parentPath);
+					const nodeIndex = parent.children.findIndex((child) => child.name === filename);
+					const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
+					if (existingNode) {
+						if (!overwrite) {
+							callback(new MemoryFileSystemError(`File already exists: ${path}`, 'EEXIST'));
+							return;
+						}
+						if (existingNode.kind === 'directory') {
+							callback(new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, 'EISDIR'));
+							return;
+						}
+						existingNode.content = content;
+						existingNode.size = content.length;
+						existingNode.mtime = Date.now();
+					} else {
+						const now = Date.now();
+						const newFile = {
+							name: filename,
+							kind: 'file',
+							path: path,
+							directory: parentPath,
+							content: content,
+							size: content.length,
+							mtime: now,
+							meta: {},
+						};
+						parent.children.push(newFile);
+					}
+					callback();
+				} catch (error) {
+					callback(error instanceof Error ? error : new MemoryFileSystemError('Unknown error', 'UNKNOWN'));
+				}
+			},
+		});
+		if (signal) {
+			signal.addEventListener('abort', () => {
+				stream.destroy(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+			});
+		}
+		return stream;
+	}
+	getUrl(file) {
+		let node;
+		if (typeof file === 'string') {
+			[node] = this._getNodeByPath(file);
+		} else {
+			node = file;
+		}
+		let mf = node;
+		if (mf.content) {
+			let c = computeIfAbsent(this.cache, mf, () => ({}));
+			if (!c.url) {
+				let mime = findMimeType(mf.name) || 'application/octet-stream';
+				// Convert Buffer to Uint8Array for Blob compatibility with TypeScript 5.x strict typing
+				const blobPart = typeof mf.content === 'string' ? mf.content : new Uint8Array(mf.content);
+				c.url = URL.createObjectURL(
+					new Blob([blobPart], {
+						type: mime,
+					}),
+				);
+			}
+			return c.url;
+		}
+		return;
+	}
+	createReadableStream(path, options) {
+		const { signal, range } = options || {};
+		if (signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const [node] = this._getNodeByPath(path);
+		if (!node) {
+			throw new MemoryFileSystemError(`File not found: ${path}`, 'ENOENT');
+		}
+		if (node.kind !== 'file') {
+			throw new MemoryFileSystemError(`Is a directory: ${path}`, 'EISDIR');
+		}
+		const content = Buffer.from('content' in node ? node.content : '');
+		let data = content;
+		if (range) {
+			const start = range.start || 0;
+			const end = range.end || content.length - 1;
+			data = content.subarray(start, end + 1);
+		}
+		const stream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(data);
+				controller.close();
+			},
+		});
+		if (signal) {
+			signal.addEventListener('abort', () => {
+				stream.cancel(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+			});
+		}
+		return stream;
+	}
+	createWritableStream(path, options) {
+		const { signal, overwrite = true } = options || {};
+		if (signal?.aborted) {
+			throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+		}
+		const chunks = [];
+		const self = this;
+		const stream = new WritableStream({
+			write(chunk) {
+				if (signal?.aborted) {
+					throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+				}
+				chunks.push(chunk);
+			},
+			close() {
+				if (signal?.aborted) {
+					throw new MemoryFileSystemError('Operation aborted', 'ABORT_ERR');
+				}
+				const content = Buffer.concat(chunks);
+				const parentPath = dirname(path);
+				const filename = basename(path);
+				const parent = self._findOrCreateDirectory(parentPath);
+				const nodeIndex = parent.children.findIndex((child) => child.name === filename);
+				const existingNode = nodeIndex !== -1 ? parent.children[nodeIndex] : null;
+				if (existingNode) {
+					if (!overwrite) {
+						throw new MemoryFileSystemError(`File already exists: ${path}`, 'EEXIST');
+					}
+					if (existingNode.kind === 'directory') {
+						throw new MemoryFileSystemError(`Cannot overwrite a directory: ${path}`, 'EISDIR');
+					}
+					existingNode.content = content;
+					existingNode.size = content.length;
+					existingNode.mtime = Date.now();
+				} else {
+					const now = Date.now();
+					const newFile = {
+						name: filename,
+						kind: 'file',
+						path: path,
+						directory: parentPath,
+						content: content,
+						size: content.length,
+						mtime: now,
+						meta: {},
+					};
+					parent.children.push(newFile);
+				}
+			},
+		});
+		if (signal) {
+			signal.addEventListener('abort', () => {
+				stream.abort(new MemoryFileSystemError('Operation aborted', 'ABORT_ERR'));
+			});
+		}
+		return stream;
+	}
 };
 //# sourceMappingURL=createMemoryFileSystem.js.map