@quilted/create 0.2.43 → 0.2.45

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

@@ -1,45 +1,47 @@
-import { __exports as out } from '../../../../../../../_virtual/index4.esnext';
-import './providers/async.esnext';
-import './providers/stream.esnext';
-import './providers/sync.esnext';
-import './settings.esnext';
-import { __exports as settings } from '../../../../../../../_virtual/settings2.esnext';
-import { __exports as async } from '../../../../../../../_virtual/async3.esnext';
-import { __exports as stream } from '../../../../../../../_virtual/stream4.esnext';
-import { __exports as sync } from '../../../../../../../_virtual/sync3.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index10.esnext';
+import { __require as requireAsync } from './providers/async.esnext';
+import { __require as requireStream } from './providers/stream.esnext';
+import { __require as requireSync } from './providers/sync.esnext';
+import { __require as requireSettings } from './settings.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;
+var hasRequiredOut;
+function requireOut() {
+  if (hasRequiredOut) return out;
+  hasRequiredOut = 1;
+  Object.defineProperty(out, "__esModule", { value: true });
+  out.Settings = out.walkStream = out.walkSync = out.walk = void 0;
+  const async_1 = requireAsync();
+  const stream_1 = requireStream();
+  const sync_1 = requireSync();
+  const settings_1 = requireSettings();
+  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);
   }
-  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;
+  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);
   }
-  return new settings_1.default(settingsOrOptions);
+  return out;
 }
 
-export { out as default };
+export { requireOut as __require };

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

@@ -1,33 +1,40 @@
 import { __exports as async } from '../../../../../../../../_virtual/async3.esnext';
-import '../readers/async.esnext';
-import { __exports as async$1 } from '../../../../../../../../_virtual/async5.esnext';
+import { __require as requireAsync$1 } from '../readers/async.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 = [];
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", { value: true });
+  const async_1 = requireAsync$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();
+    }
   }
-  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);
+  }
+  return async;
 }
-async.default = AsyncProvider;
-function callFailureCallback(callback, error) {
-  callback(error);
-}
-function callSuccessCallback(callback, entries) {
-  callback(null, entries);
-}
+
+export { requireAsync as __require };

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

@@ -1,39 +1,46 @@
 import { __exports as stream } from '../../../../../../../../_virtual/stream4.esnext';
 import require$$0 from 'node:stream';
-import '../readers/async.esnext';
-import { __exports as async } from '../../../../../../../../_virtual/async5.esnext';
+import { __require as requireAsync } from '../readers/async.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();
+var hasRequiredStream;
+function requireStream() {
+  if (hasRequiredStream) return stream;
+  hasRequiredStream = 1;
+  Object.defineProperty(stream, "__esModule", { value: true });
+  const stream_1 = require$$0;
+  const async_1 = requireAsync();
+  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;
+      });
+    }
+    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;
+  return stream;
 }
-stream.default = StreamProvider;
+
+export { requireStream as __require };

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

@@ -1,17 +1,24 @@
 import { __exports as sync } from '../../../../../../../../_virtual/sync3.esnext';
-import '../readers/sync.esnext';
-import { __exports as sync$1 } from '../../../../../../../../_virtual/sync5.esnext';
+import { __require as requireSync$1 } from '../readers/sync.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();
+var hasRequiredSync;
+function requireSync() {
+  if (hasRequiredSync) return sync;
+  hasRequiredSync = 1;
+  Object.defineProperty(sync, "__esModule", { value: true });
+  const sync_1 = requireSync$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;
+  return sync;
 }
-sync.default = SyncProvider;
+
+export { requireSync as __require };

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

@@ -1,106 +1,111 @@
 import { __exports as async } from '../../../../../../../../_virtual/async5.esnext';
 import require$$2 from 'node:events';
-import '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
-import { q as queueExports } from '../../../../../../fastq@1.13.0/node_modules/fastq/queue.esnext';
-import './common.esnext';
-import './reader.esnext';
-import { __exports as out } from '../../../../../../../../_virtual/index6.esnext';
-import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
-import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
+import { __require as requireOut } from '../../../../../../@nodelib_fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/index.esnext';
+import { __require as requireQueue } from '../../../../../../fastq@1.13.0/node_modules/fastq/queue.esnext';
+import { __require as requireCommon } from './common.esnext';
+import { __require as requireReader } from './reader.esnext';
 
-Object.defineProperty(async, "__esModule", { value: true });
-const events_1 = require$$2;
-const fsScandir = out;
-const fastq = queueExports;
-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");
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", { value: true });
+  const events_1 = require$$2;
+  const fsScandir = requireOut();
+  const fastq = requireQueue();
+  const common = requireCommon();
+  const reader_1 = requireReader();
+  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");
       }
-    };
-  }
-  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();
     }
-    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);
+    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, void 0);
+          return;
+        }
+        for (const entry of entries) {
+          this._handleEntry(entry, item.base);
+        }
+        done(null, void 0);
+      });
+    }
+    _handleError(error) {
+      if (this._isDestroyed || !common.isFatalError(this._settings, error)) {
+        return;
       }
-    });
-  }
-  _worker(item, done) {
-    this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
-      if (error !== null) {
-        done(error, void 0);
+      this._isFatalError = true;
+      this._isDestroyed = true;
+      this._emitter.emit("error", error);
+    }
+    _handleEntry(entry, base) {
+      if (this._isDestroyed || this._isFatalError) {
         return;
       }
-      for (const entry of entries) {
-        this._handleEntry(entry, item.base);
+      const fullpath = entry.path;
+      if (base !== void 0) {
+        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 === void 0 ? void 0 : entry.path);
       }
-      done(null, void 0);
-    });
-  }
-  _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 !== void 0) {
-      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 === void 0 ? void 0 : entry.path);
+    _emitEntry(entry) {
+      this._emitter.emit("entry", entry);
     }
   }
-  _emitEntry(entry) {
-    this._emitter.emit("entry", entry);
-  }
+  async.default = AsyncReader;
+  return async;
 }
-async.default = AsyncReader;
+
+export { requireAsync as __require };

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

@@ -1,31 +1,37 @@
 import { __exports as common } 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;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  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);
   }
-  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;
+  common.isFatalError = isFatalError;
+  function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+  }
+  common.isAppliedFilter = isAppliedFilter;
+  function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[/\\]/).join(separator);
   }
-  if (a.endsWith(separator)) {
-    return a + b;
+  common.replacePathSegmentSeparator = replacePathSegmentSeparator;
+  function joinPathSegments(a, b, separator) {
+    if (a === "") {
+      return b;
+    }
+    if (a.endsWith(separator)) {
+      return a + b;
+    }
+    return a + separator + b;
   }
-  return a + separator + b;
+  common.joinPathSegments = joinPathSegments;
+  return common;
 }
-common.joinPathSegments = joinPathSegments;
 
-export { common as default };
+export { requireCommon as __require };

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

@@ -1,14 +1,21 @@
 import { __exports as reader } from '../../../../../../../../_virtual/reader2.esnext';
-import './common.esnext';
-import { __exports as common$1 } from '../../../../../../../../_virtual/common.esnext';
+import { __require as requireCommon } from './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);
+var hasRequiredReader;
+function requireReader() {
+  if (hasRequiredReader) return reader;
+  hasRequiredReader = 1;
+  Object.defineProperty(reader, "__esModule", { value: true });
+  const common = requireCommon();
+  class Reader {
+    constructor(_root, _settings) {
+      this._root = _root;
+      this._settings = _settings;
+      this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
   }
+  reader.default = Reader;
+  return reader;
 }
-reader.default = Reader;
+
+export { requireReader as __require };