@quilted/create 0.1.56 → 0.1.57

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/providers/sync.esnext

@@ -0,0 +1,64 @@
+import { __exports as sync } from '../../../../../../../../_virtual/sync6.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/sync6.esnext';
+import '../../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import '../constants.esnext';
+import '../utils/index.esnext';
+import './common.esnext';
+import { __exports as out } from '../../../../../../../../_virtual/index7.esnext';
+import { __exports as constants } from '../../../../../../../../_virtual/constants.esnext';
+import { __exports as utils$1 } from '../../../../../../../../_virtual/index11.esnext';
+import { __exports as common$1 } from '../../../../../../../../_virtual/common2.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+sync.readdir = sync.readdirWithFileTypes = sync.read = void 0;
+const fsStat = out;
+const constants_1 = constants;
+const utils = utils$1;
+const common = common$1;
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir(directory, settings);
+}
+sync.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: common.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+sync.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = common.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+        const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
+sync.readdir = readdir;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.esnext

@@ -0,0 +1,30 @@
+import { __exports as settings } from '../../../../../../../_virtual/settings4.esnext';
+import path__default from 'node:path';
+import '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import './adapters/fs.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index7.esnext';
+import { __exports as fs$1 } from '../../../../../../../_virtual/fs3.esnext';
+
+Object.defineProperty(settings, "__esModule", { value: true });
+const path = path__default;
+const fsStat = out;
+const fs = fs$1;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+settings.default = Settings;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/fs.esnext

@@ -0,0 +1,21 @@
+import { __exports as fs } from '../../../../../../../../_virtual/fs4.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/fs4.esnext';
+
+Object.defineProperty(fs, "__esModule", { value: true });
+fs.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+fs.createDirentFromStats = createDirentFromStats;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/utils/index.esnext

@@ -0,0 +1,9 @@
+import { __exports as utils } from '../../../../../../../../_virtual/index11.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/index11.esnext';
+import './fs.esnext';
+import { __exports as fs$1 } from '../../../../../../../../_virtual/fs4.esnext';
+
+Object.defineProperty(utils, "__esModule", { value: true });
+utils.fs = void 0;
+const fs = fs$1;
+utils.fs = fs;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/adapters/fs.esnext

@@ -0,0 +1,21 @@
+import { __exports as fs } from '../../../../../../../../_virtual/fs2.esnext';
+import fs__default from 'node:fs';
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs__default;
+	exports.FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    stat: fs.stat,
+	    lstatSync: fs.lstatSync,
+	    statSync: fs.statSync
+	};
+	function createFileSystemAdapter(fsMethods) {
+	    if (fsMethods === undefined) {
+	        return exports.FILE_SYSTEM_ADAPTER;
+	    }
+	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+	}
+	exports.createFileSystemAdapter = createFileSystemAdapter;
+} (fs));

package/build/esnext/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext

@@ -0,0 +1,34 @@
+import { __exports as out } from '../../../../../../../_virtual/index7.esnext';
+export { __exports as default } from '../../../../../../../_virtual/index7.esnext';
+import './providers/async.esnext';
+import './providers/sync.esnext';
+import './settings.esnext';
+import { __exports as settings } from '../../../../../../../_virtual/settings2.esnext';
+import { __exports as async$1 } from '../../../../../../../_virtual/async2.esnext';
+import { __exports as sync$1 } from '../../../../../../../_virtual/sync3.esnext';
+
+Object.defineProperty(out, "__esModule", { value: true });
+out.statSync = out.stat = out.Settings = void 0;
+const async = async$1;
+const sync = sync$1;
+const settings_1 = settings;
+out.Settings = settings_1.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        async.read(path, getSettings(), optionsOrSettingsOrCallback);
+        return;
+    }
+    async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+out.stat = stat;
+function statSync(path, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    return sync.read(path, settings);
+}
+out.statSync = statSync;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/async.esnext

@@ -0,0 +1,38 @@
+import { __exports as async } from '../../../../../../../../_virtual/async2.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/async2.esnext';
+
+Object.defineProperty(async, "__esModule", { value: true });
+async.read = void 0;
+function read(path, settings, callback) {
+    settings.fs.lstat(path, (lstatError, lstat) => {
+        if (lstatError !== null) {
+            callFailureCallback(callback, lstatError);
+            return;
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            callSuccessCallback(callback, lstat);
+            return;
+        }
+        settings.fs.stat(path, (statError, stat) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    callFailureCallback(callback, statError);
+                    return;
+                }
+                callSuccessCallback(callback, lstat);
+                return;
+            }
+            if (settings.markSymbolicLink) {
+                stat.isSymbolicLink = () => true;
+            }
+            callSuccessCallback(callback, stat);
+        });
+    });
+}
+async.read = read;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, result) {
+    callback(null, result);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/providers/sync.esnext

@@ -0,0 +1,25 @@
+import { __exports as sync } from '../../../../../../../../_virtual/sync3.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/sync3.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+sync.read = void 0;
+function read(path, settings) {
+    const lstat = settings.fs.lstatSync(path);
+    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+        return lstat;
+    }
+    try {
+        const stat = settings.fs.statSync(path);
+        if (settings.markSymbolicLink) {
+            stat.isSymbolicLink = () => true;
+        }
+        return stat;
+    }
+    catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink) {
+            return lstat;
+        }
+        throw error;
+    }
+}
+sync.read = read;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.esnext

@@ -0,0 +1,19 @@
+import { __exports as settings } from '../../../../../../../_virtual/settings2.esnext';
+import './adapters/fs.esnext';
+import { __exports as fs$1 } from '../../../../../../../_virtual/fs2.esnext';
+
+Object.defineProperty(settings, "__esModule", { value: true });
+const fs = fs$1;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+settings.default = Settings;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext

@@ -0,0 +1,44 @@
+import { __exports as out } from '../../../../../../../_virtual/index8.esnext';
+export { __exports as default } from '../../../../../../../_virtual/index8.esnext';
+import './providers/async.esnext';
+import './providers/stream.esnext';
+import './providers/sync.esnext';
+import './settings.esnext';
+import { __exports as settings } from '../../../../../../../_virtual/settings3.esnext';
+import { __exports as async } from '../../../../../../../_virtual/async3.esnext';
+import { __exports as stream } from '../../../../../../../_virtual/stream4.esnext';
+import { __exports as sync } from '../../../../../../../_virtual/sync4.esnext';
+
+Object.defineProperty(out, "__esModule", { value: true });
+out.Settings = out.walkStream = out.walkSync = out.walk = void 0;
+const async_1 = async;
+const stream_1 = stream;
+const sync_1 = sync;
+const settings_1 = settings;
+out.Settings = settings_1.default;
+function walk(directory, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        new async_1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+        return;
+    }
+    new async_1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+out.walk = walk;
+function walkSync(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new sync_1.default(directory, settings);
+    return provider.read();
+}
+out.walkSync = walkSync;
+function walkStream(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new stream_1.default(directory, settings);
+    return provider.read();
+}
+out.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1.default(settingsOrOptions);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/async.esnext

@@ -0,0 +1,33 @@
+import { __exports as async } from '../../../../../../../../_virtual/async3.esnext';
+import '../readers/async.esnext';
+import { __exports as async$1 } from '../../../../../../../../_virtual/async4.esnext';
+
+Object.defineProperty(async, "__esModule", { value: true });
+const async_1 = async$1;
+class AsyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1.default(this._root, this._settings);
+        this._storage = [];
+    }
+    read(callback) {
+        this._reader.onError((error) => {
+            callFailureCallback(callback, error);
+        });
+        this._reader.onEntry((entry) => {
+            this._storage.push(entry);
+        });
+        this._reader.onEnd(() => {
+            callSuccessCallback(callback, this._storage);
+        });
+        this._reader.read();
+    }
+}
+async.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, entries) {
+    callback(null, entries);
+}

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/stream.esnext

@@ -0,0 +1,38 @@
+import { __exports as stream } from '../../../../../../../../_virtual/stream4.esnext';
+import require$$0 from 'node:stream';
+import '../readers/async.esnext';
+import { __exports as async } from '../../../../../../../../_virtual/async4.esnext';
+
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1 = require$$0;
+const async_1 = async;
+class StreamProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1.default(this._root, this._settings);
+        this._stream = new stream_1.Readable({
+            objectMode: true,
+            read: () => { },
+            destroy: () => {
+                if (!this._reader.isDestroyed) {
+                    this._reader.destroy();
+                }
+            }
+        });
+    }
+    read() {
+        this._reader.onError((error) => {
+            this._stream.emit('error', error);
+        });
+        this._reader.onEntry((entry) => {
+            this._stream.push(entry);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
+    }
+}
+stream.default = StreamProvider;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/providers/sync.esnext

@@ -0,0 +1,17 @@
+import { __exports as sync } from '../../../../../../../../_virtual/sync4.esnext';
+import '../readers/sync.esnext';
+import { __exports as sync$1 } from '../../../../../../../../_virtual/sync5.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+const sync_1 = sync$1;
+class SyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new sync_1.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
+sync.default = SyncProvider;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/async.esnext

@@ -0,0 +1,107 @@
+import { __exports as async } from '../../../../../../../../_virtual/async4.esnext';
+import require$$2 from 'node:events';
+import '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
+import '../../../../../../fastq@1.13.0/node_modules/fastq/queue.esnext';
+import './common.esnext';
+import './reader.esnext';
+import { __exports as out } from '../../../../../../../../_virtual/index10.esnext';
+import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
+import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
+import { q as queue } from '../../../../../../../../_virtual/queue.esnext';
+
+Object.defineProperty(async, "__esModule", { value: true });
+const events_1 = require$$2;
+const fsScandir = out;
+const fastq = queue.exports;
+const common = common$1;
+const reader_1 = reader;
+class AsyncReader extends reader_1.default {
+    constructor(_root, _settings) {
+        super(_root, _settings);
+        this._settings = _settings;
+        this._scandir = fsScandir.scandir;
+        this._emitter = new events_1.EventEmitter();
+        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit('end');
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error('The reader is already destroyed');
+        }
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(callback) {
+        this._emitter.on('entry', callback);
+    }
+    onError(callback) {
+        this._emitter.once('error', callback);
+    }
+    onEnd(callback) {
+        this._emitter.once('end', callback);
+    }
+    _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+            if (error !== null) {
+                this._handleError(error);
+            }
+        });
+    }
+    _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+            if (error !== null) {
+                done(error, undefined);
+                return;
+            }
+            for (const entry of entries) {
+                this._handleEntry(entry, item.base);
+            }
+            done(null, undefined);
+        });
+    }
+    _handleError(error) {
+        if (this._isDestroyed || !common.isFatalError(this._settings, error)) {
+            return;
+        }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit('error', error);
+    }
+    _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
+        }
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._emitEntry(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
+        }
+    }
+    _emitEntry(entry) {
+        this._emitter.emit('entry', entry);
+    }
+}
+async.default = AsyncReader;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/common.esnext

@@ -0,0 +1,33 @@
+import { __exports as common } from '../../../../../../../../_virtual/common.esnext';
+export { __exports as default } from '../../../../../../../../_virtual/common.esnext';
+
+Object.defineProperty(common, "__esModule", { value: true });
+common.joinPathSegments = common.replacePathSegmentSeparator = common.isAppliedFilter = common.isFatalError = void 0;
+function isFatalError(settings, error) {
+    if (settings.errorFilter === null) {
+        return true;
+    }
+    return !settings.errorFilter(error);
+}
+common.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+}
+common.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[/\\]/).join(separator);
+}
+common.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+    if (a === '') {
+        return b;
+    }
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+common.joinPathSegments = joinPathSegments;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/reader.esnext

@@ -0,0 +1,14 @@
+import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
+import './common.esnext';
+import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
+
+Object.defineProperty(reader, "__esModule", { value: true });
+const common = common$1;
+class Reader {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
+}
+reader.default = Reader;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/readers/sync.esnext

@@ -0,0 +1,66 @@
+import { __exports as sync } from '../../../../../../../../_virtual/sync5.esnext';
+import '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
+import './common.esnext';
+import './reader.esnext';
+import { __exports as out } from '../../../../../../../../_virtual/index10.esnext';
+import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
+import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+const fsScandir = out;
+const common = common$1;
+const reader_1 = reader;
+class SyncReader extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = fsScandir.scandirSync;
+        this._storage = [];
+        this._queue = new Set();
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return this._storage;
+    }
+    _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+        for (const item of this._queue.values()) {
+            this._handleDirectory(item.directory, item.base);
+        }
+    }
+    _handleDirectory(directory, base) {
+        try {
+            const entries = this._scandir(directory, this._settings.fsScandirSettings);
+            for (const entry of entries) {
+                this._handleEntry(entry, base);
+            }
+        }
+        catch (error) {
+            this._handleError(error);
+        }
+    }
+    _handleError(error) {
+        if (!common.isFatalError(this._settings, error)) {
+            return;
+        }
+        throw error;
+    }
+    _handleEntry(entry, base) {
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._pushToStorage(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
+        }
+    }
+    _pushToStorage(entry) {
+        this._storage.push(entry);
+    }
+}
+sync.default = SyncReader;

package/build/esnext/node_modules/.pnpm/@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.esnext

@@ -0,0 +1,30 @@
+import { __exports as settings } from '../../../../../../../_virtual/settings3.esnext';
+import path__default from 'node:path';
+import '../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index10.esnext';
+
+Object.defineProperty(settings, "__esModule", { value: true });
+const path = path__default;
+const fsScandir = out;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+        this.fsScandirSettings = new fsScandir.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+settings.default = Settings;