@atlaspack/fs 2.12.1-canary.3354

package/lib/browser.js

@@ -0,0 +1,1134 @@
+var $eHCLO$path = require("path");
+var $eHCLO$stream = require("stream");
+var $eHCLO$util = require("util");
+var $eHCLO$buffer = require("buffer");
+var $eHCLO$atlaspackcore = require("@atlaspack/core");
+var $eHCLO$atlaspackutils = require("@atlaspack/utils");
+var $eHCLO$atlaspackworkers = require("@atlaspack/workers");
+var $eHCLO$events = require("events");
+
+
+function $atlaspack$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+function $atlaspack$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+
+function $atlaspack$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$atlaspack$export(module.exports, "ncp", () => $416aba2172cbc610$export$d3a8044e3fef7335);
+
+
+
+var $4d6ec4a7ba8784a9$exports = {};
+
+$atlaspack$export($4d6ec4a7ba8784a9$exports, "NodeFS", () => $4d6ec4a7ba8784a9$export$c4e0ef2ab73c21e7);
+// $FlowFixMe[prop-missing] handled by the throwing constructor
+class $4d6ec4a7ba8784a9$export$c4e0ef2ab73c21e7 {
+    constructor(){
+        throw new Error("NodeFS isn't available in the browser");
+    }
+}
+
+
+var $995ba0f44994569b$exports = {};
+
+$atlaspack$export($995ba0f44994569b$exports, "MemoryFS", () => $995ba0f44994569b$export$3048eb7ec07c2c4e);
+$atlaspack$export($995ba0f44994569b$exports, "FSError", () => $995ba0f44994569b$export$d414276624ebf134);
+$atlaspack$export($995ba0f44994569b$exports, "makeShared", () => $995ba0f44994569b$export$df9eb3e75aa27a22);
+$atlaspack$export($995ba0f44994569b$exports, "File", () => $995ba0f44994569b$export$b6afa8811b7e644e);
+
+
+
+
+var $b6ff243d7d5008ac$exports = {};
+$b6ff243d7d5008ac$exports = JSON.parse("{\"name\":\"@atlaspack/fs\",\"version\":\"2.12.1-canary.3354+7bb54d46a\",\"description\":\"Blazing fast, zero configuration web application bundler\",\"license\":\"MIT\",\"publishConfig\":{\"access\":\"public\"},\"repository\":{\"type\":\"git\",\"url\":\"https://github.com/atlassian-labs/atlaspack.git\"},\"main\":\"lib/index.js\",\"source\":\"src/index.js\",\"types\":\"index.d.ts\",\"engines\":{\"node\":\">= 16.0.0\"},\"targets\":{\"types\":false,\"main\":{\"includeNodeModules\":{\"@atlaspack/core\":false,\"@atlaspack/feature-flags\":false,\"@atlaspack/rust\":false,\"@atlaspack/types-internal\":false,\"@atlaspack/utils\":false,\"@atlaspack/watcher-watchman-js\":false,\"@parcel/watcher\":false,\"@atlaspack/workers\":false}},\"browser\":{\"includeNodeModules\":{\"@atlaspack/core\":false,\"@atlaspack/feature-flags\":false,\"@atlaspack/rust\":false,\"@atlaspack/types-internal\":false,\"@atlaspack/utils\":false,\"@atlaspack/watcher-watchman-js\":false,\"@parcel/watcher\":false,\"@atlaspack/workers\":false}}},\"scripts\":{\"build-ts\":\"mkdir -p lib && flow-to-ts src/types.js > lib/types.d.ts\",\"check-ts\":\"tsc --noEmit index.d.ts\"},\"dependencies\":{\"@atlaspack/feature-flags\":\"2.12.1-canary.3354+7bb54d46a\",\"@atlaspack/rust\":\"2.12.1-canary.3354+7bb54d46a\",\"@atlaspack/types-internal\":\"2.12.1-canary.3354+7bb54d46a\",\"@atlaspack/utils\":\"2.12.1-canary.3354+7bb54d46a\",\"@atlaspack/workers\":\"2.12.1-canary.3354+7bb54d46a\",\"@parcel/watcher\":\"^2.0.7\"},\"devDependencies\":{\"@atlaspack/watcher-watchman-js\":\"2.12.1-canary.3354+7bb54d46a\",\"graceful-fs\":\"^4.2.4\",\"ncp\":\"^2.0.0\",\"nullthrows\":\"^1.1.1\",\"utility-types\":\"^3.10.0\"},\"peerDependencies\":{\"@atlaspack/core\":\"2.12.1-canary.3354+7bb54d46a\"},\"browser\":{\"@atlaspack/fs\":\"./lib/browser.js\",\"./src/NodeFS.js\":\"./src/NodeFS.browser.js\"},\"gitHead\":\"7bb54d46a00c5ba9cdbc2ee426dcbe82c8d79a3e\"}");
+
+
+
+var $023b8d639760db5c$exports = {};
+'use strict';
+function $023b8d639760db5c$var$nullthrows(x, message) {
+    if (x != null) return x;
+    var error = new Error(message !== undefined ? message : 'Got unexpected ' + x);
+    error.framesToPop = 1; // Skip nullthrows's own stack frame.
+    throw error;
+}
+$023b8d639760db5c$exports = $023b8d639760db5c$var$nullthrows;
+$023b8d639760db5c$exports.default = $023b8d639760db5c$var$nullthrows;
+Object.defineProperty($023b8d639760db5c$exports, '__esModule', {
+    value: true
+});
+
+
+
+
+function $a9ed96e57e8d2cf3$export$4c6d088a7d7f9947(fs, moduleName, dir) {
+    let { root: root } = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(dir);
+    while(dir !== root){
+        // Skip node_modules directories
+        if ((0, ($atlaspack$interopDefault($eHCLO$path))).basename(dir) === 'node_modules') dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(dir);
+        try {
+            let moduleDir = (0, ($atlaspack$interopDefault($eHCLO$path))).join(dir, 'node_modules', moduleName);
+            let stats = fs.statSync(moduleDir);
+            if (stats.isDirectory()) return moduleDir;
+        } catch (err) {
+        // ignore
+        }
+        // Move up a directory
+        dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(dir);
+    }
+    return null;
+}
+function $a9ed96e57e8d2cf3$export$d51a93c758976388(fs, fileNames, dir, root) {
+    let { root: pathRoot } = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(dir);
+    // eslint-disable-next-line no-constant-condition
+    while(true){
+        if ((0, ($atlaspack$interopDefault($eHCLO$path))).basename(dir) === 'node_modules') return null;
+        for (const fileName of fileNames){
+            let filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(dir, fileName);
+            try {
+                if (fs.statSync(filePath).isFile()) return filePath;
+            } catch (err) {
+            // ignore
+            }
+        }
+        if (dir === root || dir === pathRoot) break;
+        dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(dir);
+    }
+    return null;
+}
+function $a9ed96e57e8d2cf3$export$64df6e3182fd5b2d(fs, filePaths) {
+    for (let filePath of filePaths)try {
+        if (fs.statSync(filePath).isFile()) return filePath;
+    } catch (err) {
+    // ignore
+    }
+}
+
+
+
+var $995ba0f44994569b$require$Buffer = $eHCLO$buffer.Buffer;
+const $995ba0f44994569b$var$instances = new Map();
+let $995ba0f44994569b$var$id = 0;
+class $995ba0f44994569b$export$3048eb7ec07c2c4e {
+    _numWorkerInstances = 0;
+    _workerRegisterResolves = [];
+    _emitter = new (0, ($atlaspack$interopDefault($eHCLO$events)))();
+    constructor(workerFarm){
+        this.farm = workerFarm;
+        this._cwd = (0, ($atlaspack$interopDefault($eHCLO$path))).resolve((0, ($atlaspack$interopDefault($eHCLO$path))).sep);
+        this.dirs = new Map([
+            [
+                this._cwd,
+                new $995ba0f44994569b$var$Directory()
+            ]
+        ]);
+        this.files = new Map();
+        this.symlinks = new Map();
+        this.watchers = new Map();
+        this.events = [];
+        this.id = $995ba0f44994569b$var$id++;
+        this._workerHandles = [];
+        this._eventQueue = [];
+        $995ba0f44994569b$var$instances.set(this.id, this);
+        this._emitter.on('allWorkersRegistered', ()=>{
+            for (let resolve of this._workerRegisterResolves)resolve();
+            this._workerRegisterResolves = [];
+        });
+    }
+    static deserialize(opts) {
+        let existing = $995ba0f44994569b$var$instances.get(opts.id);
+        if (existing != null) {
+            // Correct the count of worker instances since serialization assumes a new instance is created
+            (0, ($atlaspack$interopDefault($eHCLO$atlaspackworkers))).getWorkerApi().runHandle(opts.handle, [
+                'decrementWorkerInstance',
+                []
+            ]);
+            return existing;
+        }
+        let fs = new $995ba0f44994569b$var$WorkerFS(opts.id, (0, (/*@__PURE__*/$atlaspack$interopDefault($023b8d639760db5c$exports)))(opts.handle));
+        fs.dirs = opts.dirs;
+        fs.files = opts.files;
+        fs.symlinks = opts.symlinks;
+        return fs;
+    }
+    serialize() {
+        if (!this.handle) this.handle = this.farm.createReverseHandle((fn, args)=>{
+            // $FlowFixMe
+            return this[fn](...args);
+        });
+        // If a worker instance already exists, it will decrement this number
+        this._numWorkerInstances++;
+        return {
+            $$raw: false,
+            id: this.id,
+            handle: this.handle,
+            dirs: this.dirs,
+            files: this.files,
+            symlinks: this.symlinks
+        };
+    }
+    decrementWorkerInstance() {
+        this._numWorkerInstances--;
+        if (this._numWorkerInstances === this._workerHandles.length) this._emitter.emit('allWorkersRegistered');
+    }
+    cwd() {
+        return this._cwd;
+    }
+    chdir(dir) {
+        this._cwd = dir;
+    }
+    _normalizePath(filePath, realpath = true) {
+        filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).normalize(filePath);
+        if (!filePath.startsWith(this.cwd())) filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).resolve(this.cwd(), filePath);
+        // get realpath by following symlinks
+        if (realpath) {
+            let { root: root, dir: dir, base: base } = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(filePath);
+            let parts = dir.slice(root.length).split((0, ($atlaspack$interopDefault($eHCLO$path))).sep).concat(base);
+            let res = root;
+            for (let part of parts){
+                res = (0, ($atlaspack$interopDefault($eHCLO$path))).join(res, part);
+                let symlink = this.symlinks.get(res);
+                if (symlink) res = symlink;
+            }
+            return res;
+        }
+        return filePath;
+    }
+    async writeFile(filePath, contents, options) {
+        filePath = this._normalizePath(filePath);
+        if (this.dirs.has(filePath)) throw new $995ba0f44994569b$export$d414276624ebf134('EISDIR', filePath, 'is a directory');
+        let dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(filePath);
+        if (!this.dirs.has(dir)) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', dir, 'does not exist');
+        let buffer = $995ba0f44994569b$export$df9eb3e75aa27a22(contents);
+        let file = this.files.get(filePath);
+        let mode = options && options.mode || 438;
+        if (file) {
+            file.write(buffer, mode);
+            this.files.set(filePath, file);
+        } else this.files.set(filePath, new $995ba0f44994569b$export$b6afa8811b7e644e(buffer, mode));
+        await this._sendWorkerEvent({
+            type: 'writeFile',
+            path: filePath,
+            entry: this.files.get(filePath)
+        });
+        this._triggerEvent({
+            type: file ? 'update' : 'create',
+            path: filePath
+        });
+    }
+    // eslint-disable-next-line require-await
+    async readFile(filePath, encoding) {
+        return this.readFileSync(filePath, encoding);
+    }
+    readFileSync(filePath, encoding) {
+        filePath = this._normalizePath(filePath);
+        let file = this.files.get(filePath);
+        if (file == null) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', filePath, 'does not exist');
+        let buffer = file.read();
+        if (encoding) return buffer.toString(encoding);
+        return buffer;
+    }
+    async copyFile(source, destination) {
+        let contents = await this.readFile(source);
+        await this.writeFile(destination, contents);
+    }
+    statSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        let dir = this.dirs.get(filePath);
+        if (dir) return dir.stat();
+        let file = this.files.get(filePath);
+        if (file == null) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', filePath, 'does not exist');
+        return file.stat();
+    }
+    // eslint-disable-next-line require-await
+    async stat(filePath) {
+        return this.statSync(filePath);
+    }
+    readdirSync(dir, opts) {
+        dir = this._normalizePath(dir);
+        if (!this.dirs.has(dir)) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', dir, 'does not exist');
+        if (!dir.endsWith((0, ($atlaspack$interopDefault($eHCLO$path))).sep)) dir += (0, ($atlaspack$interopDefault($eHCLO$path))).sep;
+        let res = [];
+        for (let [filePath, entry] of this.dirs){
+            if (filePath === dir) continue;
+            if (filePath.startsWith(dir) && filePath.indexOf((0, ($atlaspack$interopDefault($eHCLO$path))).sep, dir.length) === -1) {
+                let name = filePath.slice(dir.length);
+                if (opts?.withFileTypes) res.push(new $995ba0f44994569b$var$Dirent(name, entry));
+                else res.push(name);
+            }
+        }
+        for (let [filePath, entry] of this.files)if (filePath.startsWith(dir) && filePath.indexOf((0, ($atlaspack$interopDefault($eHCLO$path))).sep, dir.length) === -1) {
+            let name = filePath.slice(dir.length);
+            if (opts?.withFileTypes) res.push(new $995ba0f44994569b$var$Dirent(name, entry));
+            else res.push(name);
+        }
+        for (let [from] of this.symlinks)if (from.startsWith(dir) && from.indexOf((0, ($atlaspack$interopDefault($eHCLO$path))).sep, dir.length) === -1) {
+            let name = from.slice(dir.length);
+            if (opts?.withFileTypes) res.push(new $995ba0f44994569b$var$Dirent(name, {
+                mode: $995ba0f44994569b$var$S_IFLNK
+            }));
+            else res.push(name);
+        }
+        return res;
+    }
+    // eslint-disable-next-line require-await
+    async readdir(dir, opts) {
+        return this.readdirSync(dir, opts);
+    }
+    async unlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (!this.files.has(filePath) && !this.dirs.has(filePath)) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', filePath, 'does not exist');
+        this.files.delete(filePath);
+        this.dirs.delete(filePath);
+        this.watchers.delete(filePath);
+        await this._sendWorkerEvent({
+            type: 'unlink',
+            path: filePath
+        });
+        this._triggerEvent({
+            type: 'delete',
+            path: filePath
+        });
+        return Promise.resolve();
+    }
+    async mkdirp(dir) {
+        dir = this._normalizePath(dir);
+        if (this.dirs.has(dir)) return Promise.resolve();
+        if (this.files.has(dir)) throw new $995ba0f44994569b$export$d414276624ebf134('ENOENT', dir, 'is not a directory');
+        let root = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(dir).root;
+        while(dir !== root){
+            if (this.dirs.has(dir)) break;
+            this.dirs.set(dir, new $995ba0f44994569b$var$Directory());
+            await this._sendWorkerEvent({
+                type: 'mkdir',
+                path: dir
+            });
+            this._triggerEvent({
+                type: 'create',
+                path: dir
+            });
+            dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(dir);
+        }
+        return Promise.resolve();
+    }
+    async rimraf(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.dirs.has(filePath)) {
+            let dir = filePath + (0, ($atlaspack$interopDefault($eHCLO$path))).sep;
+            for (let filePath of this.files.keys())if (filePath.startsWith(dir)) {
+                this.files.delete(filePath);
+                await this._sendWorkerEvent({
+                    type: 'unlink',
+                    path: filePath
+                });
+                this._triggerEvent({
+                    type: 'delete',
+                    path: filePath
+                });
+            }
+            for (let dirPath of this.dirs.keys())if (dirPath.startsWith(dir)) {
+                this.dirs.delete(dirPath);
+                this.watchers.delete(dirPath);
+                await this._sendWorkerEvent({
+                    type: 'unlink',
+                    path: filePath
+                });
+                this._triggerEvent({
+                    type: 'delete',
+                    path: dirPath
+                });
+            }
+            for (let filePath of this.symlinks.keys())if (filePath.startsWith(dir)) {
+                this.symlinks.delete(filePath);
+                await this._sendWorkerEvent({
+                    type: 'unlink',
+                    path: filePath
+                });
+            }
+            this.dirs.delete(filePath);
+            await this._sendWorkerEvent({
+                type: 'unlink',
+                path: filePath
+            });
+            this._triggerEvent({
+                type: 'delete',
+                path: filePath
+            });
+        } else if (this.files.has(filePath)) {
+            this.files.delete(filePath);
+            await this._sendWorkerEvent({
+                type: 'unlink',
+                path: filePath
+            });
+            this._triggerEvent({
+                type: 'delete',
+                path: filePath
+            });
+        }
+        return Promise.resolve();
+    }
+    async ncp(source, destination) {
+        source = this._normalizePath(source);
+        if (this.dirs.has(source)) {
+            if (!this.dirs.has(destination)) {
+                this.dirs.set(destination, new $995ba0f44994569b$var$Directory());
+                await this._sendWorkerEvent({
+                    type: 'mkdir',
+                    path: destination
+                });
+                this._triggerEvent({
+                    type: 'create',
+                    path: destination
+                });
+            }
+            let dir = source + (0, ($atlaspack$interopDefault($eHCLO$path))).sep;
+            for (let dirPath of this.dirs.keys())if (dirPath.startsWith(dir)) {
+                let destName = (0, ($atlaspack$interopDefault($eHCLO$path))).join(destination, dirPath.slice(dir.length));
+                if (!this.dirs.has(destName)) {
+                    this.dirs.set(destName, new $995ba0f44994569b$var$Directory());
+                    await this._sendWorkerEvent({
+                        type: 'mkdir',
+                        path: destination
+                    });
+                    this._triggerEvent({
+                        type: 'create',
+                        path: destName
+                    });
+                }
+            }
+            for (let [filePath, file] of this.files)if (filePath.startsWith(dir)) {
+                let destName = (0, ($atlaspack$interopDefault($eHCLO$path))).join(destination, filePath.slice(dir.length));
+                let exists = this.files.has(destName);
+                this.files.set(destName, file);
+                await this._sendWorkerEvent({
+                    type: 'writeFile',
+                    path: destName,
+                    entry: file
+                });
+                this._triggerEvent({
+                    type: exists ? 'update' : 'create',
+                    path: destName
+                });
+            }
+        } else await this.copyFile(source, destination);
+    }
+    createReadStream(filePath) {
+        return new $995ba0f44994569b$var$ReadStream(this, filePath);
+    }
+    createWriteStream(filePath, options) {
+        return new $995ba0f44994569b$var$WriteStream(this, filePath, options);
+    }
+    realpathSync(filePath) {
+        return this._normalizePath(filePath);
+    }
+    // eslint-disable-next-line require-await
+    async realpath(filePath) {
+        return this.realpathSync(filePath);
+    }
+    async symlink(target, path) {
+        target = this._normalizePath(target);
+        path = this._normalizePath(path);
+        this.symlinks.set(path, target);
+        await this._sendWorkerEvent({
+            type: 'symlink',
+            path: path,
+            target: target
+        });
+    }
+    existsSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        return this.files.has(filePath) || this.dirs.has(filePath);
+    }
+    // eslint-disable-next-line require-await
+    async exists(filePath) {
+        return this.existsSync(filePath);
+    }
+    _triggerEvent(event) {
+        this.events.push(event);
+        if (this.watchers.size === 0) return;
+        // Batch events
+        this._eventQueue.push(event);
+        clearTimeout(this._watcherTimer);
+        this._watcherTimer = setTimeout(()=>{
+            let events = this._eventQueue;
+            this._eventQueue = [];
+            for (let [dir, watchers] of this.watchers){
+                if (!dir.endsWith((0, ($atlaspack$interopDefault($eHCLO$path))).sep)) dir += (0, ($atlaspack$interopDefault($eHCLO$path))).sep;
+                if (event.path.startsWith(dir)) for (let watcher of watchers)watcher.trigger(events);
+            }
+        }, 50);
+    }
+    _registerWorker(handle) {
+        this._workerHandles.push(handle);
+        if (this._numWorkerInstances === this._workerHandles.length) this._emitter.emit('allWorkersRegistered');
+    }
+    async _sendWorkerEvent(event) {
+        // Wait for worker instances to register their handles
+        while(this._workerHandles.length < this._numWorkerInstances)await new Promise((resolve)=>this._workerRegisterResolves.push(resolve));
+        await Promise.all(this._workerHandles.map((workerHandle)=>this.farm.workerApi.runHandle(workerHandle, [
+                event
+            ])));
+    }
+    watch(dir, fn, opts) {
+        dir = this._normalizePath(dir);
+        let watcher = new $995ba0f44994569b$var$Watcher(fn, opts);
+        let watchers = this.watchers.get(dir);
+        if (!watchers) {
+            watchers = new Set();
+            this.watchers.set(dir, watchers);
+        }
+        watchers.add(watcher);
+        return Promise.resolve({
+            unsubscribe: ()=>{
+                watchers = (0, (/*@__PURE__*/$atlaspack$interopDefault($023b8d639760db5c$exports)))(watchers);
+                watchers.delete(watcher);
+                if (watchers.size === 0) this.watchers.delete(dir);
+                return Promise.resolve();
+            }
+        });
+    }
+    async getEventsSince(dir, snapshot, opts) {
+        let contents = await this.readFile(snapshot, 'utf8');
+        let len = Number(contents);
+        let events = this.events.slice(len);
+        let ignore = opts.ignore;
+        if (ignore) events = events.filter((event)=>!ignore.some((i)=>event.path.startsWith(i + (0, ($atlaspack$interopDefault($eHCLO$path))).sep)));
+        return events;
+    }
+    async writeSnapshot(dir, snapshot) {
+        await this.writeFile(snapshot, '' + this.events.length);
+    }
+    findAncestorFile(fileNames, fromDir, root) {
+        return (0, $a9ed96e57e8d2cf3$export$d51a93c758976388)(this, fileNames, fromDir, root);
+    }
+    findNodeModule(moduleName, fromDir) {
+        return (0, $a9ed96e57e8d2cf3$export$4c6d088a7d7f9947)(this, moduleName, fromDir);
+    }
+    findFirstFile(filePaths) {
+        return (0, $a9ed96e57e8d2cf3$export$64df6e3182fd5b2d)(this, filePaths);
+    }
+}
+class $995ba0f44994569b$var$Watcher {
+    constructor(fn, options){
+        this.fn = fn;
+        this.options = options;
+    }
+    trigger(events) {
+        let ignore = this.options.ignore;
+        if (ignore) events = events.filter((event)=>!ignore.some((i)=>event.path.startsWith(i + (0, ($atlaspack$interopDefault($eHCLO$path))).sep)));
+        if (events.length > 0) this.fn(null, events);
+    }
+}
+class $995ba0f44994569b$export$d414276624ebf134 extends Error {
+    constructor(code, path, message){
+        super(`${code}: ${path} ${message}`);
+        this.name = 'FSError';
+        this.code = code;
+        this.path = path;
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+class $995ba0f44994569b$var$ReadStream extends (0, $eHCLO$stream.Readable) {
+    constructor(fs, filePath){
+        super();
+        this.fs = fs;
+        this.filePath = filePath;
+        this.reading = false;
+        this.bytesRead = 0;
+    }
+    _read() {
+        if (this.reading) return;
+        this.reading = true;
+        this.fs.readFile(this.filePath).then((res)=>{
+            this.bytesRead += res.byteLength;
+            this.push(res);
+            this.push(null);
+        }, (err)=>{
+            this.emit('error', err);
+        });
+    }
+}
+class $995ba0f44994569b$var$WriteStream extends (0, $eHCLO$stream.Writable) {
+    constructor(fs, filePath, options){
+        super({
+            emitClose: true,
+            autoDestroy: true
+        });
+        this.fs = fs;
+        this.filePath = filePath;
+        this.options = options;
+        this.buffer = $995ba0f44994569b$require$Buffer.alloc(0);
+    }
+    _write(chunk, encoding, callback) {
+        let c = typeof chunk === 'string' ? $995ba0f44994569b$require$Buffer.from(chunk, encoding) : chunk;
+        this.buffer = $995ba0f44994569b$require$Buffer.concat([
+            this.buffer,
+            c
+        ]);
+        callback();
+    }
+    _final(callback) {
+        this.fs.writeFile(this.filePath, this.buffer, this.options).then(callback).catch(callback);
+    }
+}
+const $995ba0f44994569b$var$S_IFREG = 32768;
+const $995ba0f44994569b$var$S_IFDIR = 16384;
+const $995ba0f44994569b$var$S_IFLNK = 40960;
+const $995ba0f44994569b$var$S_IFMT = 61440;
+class $995ba0f44994569b$var$Entry {
+    constructor(mode){
+        this.mode = mode;
+        let now = Date.now();
+        this.atime = now;
+        this.mtime = now;
+        this.ctime = now;
+        this.birthtime = now;
+    }
+    access() {
+        let now = Date.now();
+        this.atime = now;
+        this.ctime = now;
+    }
+    modify(mode) {
+        let now = Date.now();
+        this.mtime = now;
+        this.ctime = now;
+        this.mode = mode;
+    }
+    getSize() {
+        return 0;
+    }
+    stat() {
+        return new $995ba0f44994569b$var$Stat(this);
+    }
+}
+class $995ba0f44994569b$var$Stat {
+    dev = 0;
+    ino = 0;
+    nlink = 0;
+    uid = 0;
+    gid = 0;
+    rdev = 0;
+    blksize = 0;
+    blocks = 0;
+    constructor(entry){
+        this.mode = entry.mode;
+        this.size = entry.getSize();
+        this.atimeMs = entry.atime;
+        this.mtimeMs = entry.mtime;
+        this.ctimeMs = entry.ctime;
+        this.birthtimeMs = entry.birthtime;
+        this.atime = new Date(entry.atime);
+        this.mtime = new Date(entry.mtime);
+        this.ctime = new Date(entry.ctime);
+        this.birthtime = new Date(entry.birthtime);
+    }
+    isFile() {
+        return Boolean(this.mode & $995ba0f44994569b$var$S_IFREG);
+    }
+    isDirectory() {
+        return Boolean(this.mode & $995ba0f44994569b$var$S_IFDIR);
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+class $995ba0f44994569b$var$Dirent {
+    #mode;
+    constructor(name, entry){
+        this.name = name;
+        this.#mode = entry.mode;
+    }
+    isFile() {
+        return (this.#mode & $995ba0f44994569b$var$S_IFMT) === $995ba0f44994569b$var$S_IFREG;
+    }
+    isDirectory() {
+        return (this.#mode & $995ba0f44994569b$var$S_IFMT) === $995ba0f44994569b$var$S_IFDIR;
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return (this.#mode & $995ba0f44994569b$var$S_IFMT) === $995ba0f44994569b$var$S_IFLNK;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+class $995ba0f44994569b$export$b6afa8811b7e644e extends $995ba0f44994569b$var$Entry {
+    constructor(buffer, mode){
+        super($995ba0f44994569b$var$S_IFREG | mode);
+        this.buffer = buffer;
+    }
+    read() {
+        super.access();
+        return $995ba0f44994569b$require$Buffer.from(this.buffer);
+    }
+    write(buffer, mode) {
+        super.modify($995ba0f44994569b$var$S_IFREG | mode);
+        this.buffer = buffer;
+    }
+    getSize() {
+        return this.buffer.byteLength;
+    }
+}
+class $995ba0f44994569b$var$Directory extends $995ba0f44994569b$var$Entry {
+    constructor(){
+        super($995ba0f44994569b$var$S_IFDIR);
+    }
+}
+function $995ba0f44994569b$export$df9eb3e75aa27a22(contents) {
+    if (typeof contents !== 'string' && contents.buffer instanceof (0, $eHCLO$atlaspackutils.SharedBuffer)) return contents;
+    let contentsBuffer = contents;
+    // For the polyfilled buffer module, it's faster to always convert once so that the subsequent
+    // operations are fast (.byteLength and using .set instead of .write)
+    contentsBuffer = contentsBuffer instanceof $995ba0f44994569b$require$Buffer ? contentsBuffer : $995ba0f44994569b$require$Buffer.from(contentsBuffer);
+    let length = $995ba0f44994569b$require$Buffer.byteLength(contentsBuffer);
+    let shared = new (0, $eHCLO$atlaspackutils.SharedBuffer)(length);
+    let buffer = $995ba0f44994569b$require$Buffer.from(shared);
+    if (length > 0) {
+        if (typeof contentsBuffer === 'string') buffer.write(contentsBuffer);
+        else buffer.set(contentsBuffer);
+    }
+    return buffer;
+}
+class $995ba0f44994569b$var$WorkerFS extends $995ba0f44994569b$export$3048eb7ec07c2c4e {
+    constructor(id, handle){
+        // TODO Make this not a subclass
+        // $FlowFixMe
+        super();
+        this.id = id;
+        this.handleFn = (methodName, args)=>(0, ($atlaspack$interopDefault($eHCLO$atlaspackworkers))).getWorkerApi().runHandle(handle, [
+                methodName,
+                args
+            ]);
+        this.handleFn('_registerWorker', [
+            (0, ($atlaspack$interopDefault($eHCLO$atlaspackworkers))).getWorkerApi().createReverseHandle((event)=>{
+                switch(event.type){
+                    case 'writeFile':
+                        this.files.set(event.path, event.entry);
+                        break;
+                    case 'unlink':
+                        this.files.delete(event.path);
+                        this.dirs.delete(event.path);
+                        this.symlinks.delete(event.path);
+                        break;
+                    case 'mkdir':
+                        this.dirs.set(event.path, new $995ba0f44994569b$var$Directory());
+                        break;
+                    case 'symlink':
+                        this.symlinks.set(event.path, event.target);
+                        break;
+                }
+            })
+        ]);
+    }
+    static deserialize(opts) {
+        return (0, (/*@__PURE__*/$atlaspack$interopDefault($023b8d639760db5c$exports)))($995ba0f44994569b$var$instances.get(opts.id));
+    }
+    serialize() {
+        // $FlowFixMe
+        return {
+            id: this.id
+        };
+    }
+    writeFile(filePath, contents, options) {
+        super.writeFile(filePath, contents, options);
+        let buffer = $995ba0f44994569b$export$df9eb3e75aa27a22(contents);
+        return this.handleFn('writeFile', [
+            filePath,
+            buffer,
+            options
+        ]);
+    }
+    unlink(filePath) {
+        super.unlink(filePath);
+        return this.handleFn('unlink', [
+            filePath
+        ]);
+    }
+    mkdirp(dir) {
+        super.mkdirp(dir);
+        return this.handleFn('mkdirp', [
+            dir
+        ]);
+    }
+    rimraf(filePath) {
+        super.rimraf(filePath);
+        return this.handleFn('rimraf', [
+            filePath
+        ]);
+    }
+    ncp(source, destination) {
+        super.ncp(source, destination);
+        return this.handleFn('ncp', [
+            source,
+            destination
+        ]);
+    }
+    symlink(target, path) {
+        super.symlink(target, path);
+        return this.handleFn('symlink', [
+            target,
+            path
+        ]);
+    }
+}
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:MemoryFS`, $995ba0f44994569b$export$3048eb7ec07c2c4e);
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:WorkerFS`, $995ba0f44994569b$var$WorkerFS);
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:Stat`, $995ba0f44994569b$var$Stat);
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:File`, $995ba0f44994569b$export$b6afa8811b7e644e);
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:Directory`, $995ba0f44994569b$var$Directory);
+
+
+var $49e8d7e24153085c$exports = {};
+
+$atlaspack$export($49e8d7e24153085c$exports, "OverlayFS", () => $49e8d7e24153085c$export$5963299e2424ca1c);
+
+
+
+
+
+
+
+class $49e8d7e24153085c$export$5963299e2424ca1c {
+    deleted = new Set();
+    constructor(workerFarmOrFS, readable){
+        if (workerFarmOrFS instanceof (0, ($atlaspack$interopDefault($eHCLO$atlaspackworkers)))) this.writable = new (0, $995ba0f44994569b$export$3048eb7ec07c2c4e)(workerFarmOrFS);
+        else this.writable = workerFarmOrFS;
+        this.readable = readable;
+        this._cwd = readable.cwd();
+    }
+    static deserialize(opts) {
+        let fs = new $49e8d7e24153085c$export$5963299e2424ca1c(opts.writable, opts.readable);
+        if (opts.deleted != null) fs.deleted = opts.deleted;
+        return fs;
+    }
+    serialize() {
+        return {
+            $$raw: false,
+            writable: this.writable,
+            readable: this.readable,
+            deleted: this.deleted
+        };
+    }
+    _deletedThrows(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.deleted.has(filePath)) throw new $49e8d7e24153085c$var$FSError('ENOENT', filePath, 'does not exist');
+        return filePath;
+    }
+    _checkExists(filePath) {
+        filePath = this._deletedThrows(filePath);
+        if (!this.existsSync(filePath)) throw new $49e8d7e24153085c$var$FSError('ENOENT', filePath, 'does not exist');
+        return filePath;
+    }
+    _isSymlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        // Check the parts of the path to see if any are symlinks.
+        let { root: root, dir: dir, base: base } = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(filePath);
+        let segments = dir.slice(root.length).split((0, ($atlaspack$interopDefault($eHCLO$path))).sep).concat(base);
+        while(segments.length){
+            filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(root, ...segments);
+            let name = segments.pop();
+            if (this.deleted.has(filePath)) return false;
+            else if (this.writable instanceof (0, $995ba0f44994569b$export$3048eb7ec07c2c4e) && this.writable.symlinks.has(filePath)) return true;
+            else {
+                // HACK: Atlaspack fs does not provide `lstatSync`,
+                // so we use `readdirSync` to check if the path is a symlink.
+                let parent = (0, ($atlaspack$interopDefault($eHCLO$path))).resolve(filePath, '..');
+                if (parent === filePath) return false;
+                try {
+                    for (let dirent of this.readdirSync(parent, {
+                        withFileTypes: true
+                    })){
+                        if (typeof dirent === 'string') break; // {withFileTypes: true} not supported
+                        else if (dirent.name === name) {
+                            if (dirent.isSymbolicLink()) return true;
+                        }
+                    }
+                } catch (e) {
+                    if (e.code === 'ENOENT') return false;
+                    throw e;
+                }
+            }
+        }
+        return false;
+    }
+    async _copyPathForWrite(filePath) {
+        filePath = await this._normalizePath(filePath);
+        let dirPath = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(filePath);
+        if (this.existsSync(dirPath) && !this.writable.existsSync(dirPath)) await this.writable.mkdirp(dirPath);
+        return filePath;
+    }
+    _normalizePath(filePath) {
+        return (0, ($atlaspack$interopDefault($eHCLO$path))).resolve(this.cwd(), filePath);
+    }
+    // eslint-disable-next-line require-await
+    async readFile(filePath, encoding) {
+        return this.readFileSync(filePath, encoding);
+    }
+    async writeFile(filePath, contents, options) {
+        filePath = await this._copyPathForWrite(filePath);
+        await this.writable.writeFile(filePath, contents, options);
+        this.deleted.delete(filePath);
+    }
+    async copyFile(source, destination) {
+        source = this._normalizePath(source);
+        destination = await this._copyPathForWrite(destination);
+        if (await this.writable.exists(source)) await this.writable.writeFile(destination, await this.writable.readFile(source));
+        else await this.writable.writeFile(destination, await this.readable.readFile(source));
+        this.deleted.delete(destination);
+    }
+    // eslint-disable-next-line require-await
+    async stat(filePath) {
+        return this.statSync(filePath);
+    }
+    async symlink(target, filePath) {
+        target = this._normalizePath(target);
+        filePath = this._normalizePath(filePath);
+        await this.writable.symlink(target, filePath);
+        this.deleted.delete(filePath);
+    }
+    async unlink(filePath) {
+        filePath = this._normalizePath(filePath);
+        let toDelete = [
+            filePath
+        ];
+        if (this.writable instanceof (0, $995ba0f44994569b$export$3048eb7ec07c2c4e) && this._isSymlink(filePath)) this.writable.symlinks.delete(filePath);
+        else if (this.statSync(filePath).isDirectory()) {
+            let stack = [
+                filePath
+            ];
+            // Recursively add every descendant path to deleted.
+            while(stack.length){
+                let root = (0, (/*@__PURE__*/$atlaspack$interopDefault($023b8d639760db5c$exports)))(stack.pop());
+                for (let ent of this.readdirSync(root, {
+                    withFileTypes: true
+                }))if (typeof ent === 'string') {
+                    let childPath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(root, ent);
+                    toDelete.push(childPath);
+                    if (this.statSync(childPath).isDirectory()) stack.push(childPath);
+                } else {
+                    let childPath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(root, ent.name);
+                    toDelete.push(childPath);
+                    if (ent.isDirectory()) stack.push(childPath);
+                }
+            }
+        }
+        try {
+            await this.writable.unlink(filePath);
+        } catch (e) {
+            if (e.code === 'ENOENT' && !this.readable.existsSync(filePath)) throw e;
+        }
+        for (let pathToDelete of toDelete)this.deleted.add(pathToDelete);
+    }
+    async mkdirp(dir) {
+        dir = this._normalizePath(dir);
+        await this.writable.mkdirp(dir);
+        if (this.deleted != null) {
+            let root = (0, ($atlaspack$interopDefault($eHCLO$path))).parse(dir).root;
+            while(dir !== root){
+                this.deleted.delete(dir);
+                dir = (0, ($atlaspack$interopDefault($eHCLO$path))).dirname(dir);
+            }
+        }
+    }
+    async rimraf(filePath) {
+        try {
+            await this.unlink(filePath);
+        } catch (e) {
+        // noop
+        }
+    }
+    // eslint-disable-next-line require-await
+    async ncp(source, destination) {
+        // TODO: Implement this correctly.
+        return this.writable.ncp(source, destination);
+    }
+    createReadStream(filePath, opts) {
+        filePath = this._deletedThrows(filePath);
+        if (this.writable.existsSync(filePath)) return this.writable.createReadStream(filePath, opts);
+        return this.readable.createReadStream(filePath, opts);
+    }
+    createWriteStream(path, opts) {
+        path = this._normalizePath(path);
+        this.deleted.delete(path);
+        return this.writable.createWriteStream(path, opts);
+    }
+    cwd() {
+        return this._cwd;
+    }
+    chdir(path) {
+        this._cwd = this._checkExists(path);
+    }
+    // eslint-disable-next-line require-await
+    async realpath(filePath) {
+        return this.realpathSync(filePath);
+    }
+    readFileSync(filePath, encoding) {
+        filePath = this.realpathSync(filePath);
+        try {
+            // $FlowFixMe[incompatible-call]
+            return this.writable.readFileSync(filePath, encoding);
+        } catch (err) {
+            // $FlowFixMe[incompatible-call]
+            return this.readable.readFileSync(filePath, encoding);
+        }
+    }
+    statSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        try {
+            return this.writable.statSync(filePath);
+        } catch (e) {
+            if (e.code === 'ENOENT' && this.existsSync(filePath)) return this.readable.statSync(filePath);
+            throw e;
+        }
+    }
+    realpathSync(filePath) {
+        filePath = this._deletedThrows(filePath);
+        filePath = this._deletedThrows(this.writable.realpathSync(filePath));
+        if (!this.writable.existsSync(filePath)) return this.readable.realpathSync(filePath);
+        return filePath;
+    }
+    // eslint-disable-next-line require-await
+    async exists(filePath) {
+        return this.existsSync(filePath);
+    }
+    existsSync(filePath) {
+        filePath = this._normalizePath(filePath);
+        if (this.deleted.has(filePath)) return false;
+        try {
+            filePath = this.realpathSync(filePath);
+        } catch (err) {
+            if (err.code !== 'ENOENT') throw err;
+        }
+        if (this.deleted.has(filePath)) return false;
+        return this.writable.existsSync(filePath) || this.readable.existsSync(filePath);
+    }
+    // eslint-disable-next-line require-await
+    async readdir(path, opts) {
+        return this.readdirSync(path, opts);
+    }
+    readdirSync(dir, opts) {
+        dir = this.realpathSync(dir);
+        // Read from both filesystems and merge the results
+        let entries = new Map();
+        try {
+            for (let entry of this.writable.readdirSync(dir, opts)){
+                let filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(dir, entry.name ?? entry);
+                if (this.deleted.has(filePath)) continue;
+                entries.set(filePath, entry);
+            }
+        } catch  {
+        // noop
+        }
+        try {
+            for (let entry of this.readable.readdirSync(dir, opts)){
+                let filePath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(dir, entry.name ?? entry);
+                if (this.deleted.has(filePath)) continue;
+                if (entries.has(filePath)) continue;
+                entries.set(filePath, entry);
+            }
+        } catch  {
+        // noop
+        }
+        return Array.from(entries.values());
+    }
+    async watch(dir, fn, opts) {
+        let writableSubscription = await this.writable.watch(dir, fn, opts);
+        let readableSubscription = await this.readable.watch(dir, fn, opts);
+        return {
+            unsubscribe: async ()=>{
+                await writableSubscription.unsubscribe();
+                await readableSubscription.unsubscribe();
+            }
+        };
+    }
+    async getEventsSince(dir, snapshot, opts) {
+        let writableEvents = await this.writable.getEventsSince(dir, snapshot, opts);
+        let readableEvents = await this.readable.getEventsSince(dir, snapshot, opts);
+        return [
+            ...writableEvents,
+            ...readableEvents
+        ];
+    }
+    async writeSnapshot(dir, snapshot, opts) {
+        await this.writable.writeSnapshot(dir, snapshot, opts);
+    }
+    findAncestorFile(fileNames, fromDir, root) {
+        return (0, $a9ed96e57e8d2cf3$export$d51a93c758976388)(this, fileNames, fromDir, root);
+    }
+    findNodeModule(moduleName, fromDir) {
+        return (0, $a9ed96e57e8d2cf3$export$4c6d088a7d7f9947)(this, moduleName, fromDir);
+    }
+    findFirstFile(filePaths) {
+        return (0, $a9ed96e57e8d2cf3$export$64df6e3182fd5b2d)(this, filePaths);
+    }
+}
+class $49e8d7e24153085c$var$FSError extends Error {
+    constructor(code, path, message){
+        super(`${code}: ${path} ${message}`);
+        this.name = 'FSError';
+        this.code = code;
+        this.path = path;
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+(0, $eHCLO$atlaspackcore.registerSerializableClass)(`${(0, (/*@__PURE__*/$atlaspack$interopDefault($b6ff243d7d5008ac$exports))).version}:OverlayFS`, $49e8d7e24153085c$export$5963299e2424ca1c);
+
+
+const $416aba2172cbc610$var$pipeline = (0, $eHCLO$util.promisify)((0, ($atlaspack$interopDefault($eHCLO$stream))).pipeline);
+async function $416aba2172cbc610$export$d3a8044e3fef7335(sourceFS, source, destinationFS, destination) {
+    await destinationFS.mkdirp(destination);
+    let files = await sourceFS.readdir(source);
+    for (let file of files){
+        let sourcePath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(source, file);
+        let destPath = (0, ($atlaspack$interopDefault($eHCLO$path))).join(destination, file);
+        let stats = await sourceFS.stat(sourcePath);
+        if (stats.isFile()) await $416aba2172cbc610$var$pipeline(sourceFS.createReadStream(sourcePath), destinationFS.createWriteStream(destPath));
+        else if (stats.isDirectory()) await $416aba2172cbc610$export$d3a8044e3fef7335(sourceFS, sourcePath, destinationFS, destPath);
+    }
+}
+$atlaspack$exportWildcard(module.exports, $4d6ec4a7ba8784a9$exports);
+$atlaspack$exportWildcard(module.exports, $995ba0f44994569b$exports);
+$atlaspack$exportWildcard(module.exports, $49e8d7e24153085c$exports);
+
+
+//# sourceMappingURL=browser.js.map