@quilted/create 0.2.43 → 0.2.45

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/matchers/partial.mjs

@@ -0,0 +1,50 @@
+import { __exports as partial } from '../../../../../../../../_virtual/partial.mjs';
+import { __require as requireMatcher } from './matcher.mjs';
+
+var hasRequiredPartial;
+function requirePartial() {
+  if (hasRequiredPartial) return partial;
+  hasRequiredPartial = 1;
+  Object.defineProperty(partial, "__esModule", {
+    value: true
+  });
+  const matcher_1 = requireMatcher();
+  class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+      const parts = filepath.split('/');
+      const levels = parts.length;
+      const patterns = this._storage.filter(info => !info.complete || info.segments.length > levels);
+      for (const pattern of patterns) {
+        const section = pattern.sections[0];
+        /**
+         * In this case, the pattern has a globstar and we must read all directories unconditionally,
+         * but only if the level has reached the end of the first group.
+         *
+         * fixtures/{a,b}/**
+         *  ^ true/false  ^ always true
+        */
+        if (!pattern.complete && levels > section.length) {
+          return true;
+        }
+        const match = parts.every((part, index) => {
+          const segment = pattern.segments[index];
+          if (segment.dynamic && segment.patternRe.test(part)) {
+            return true;
+          }
+          if (!segment.dynamic && segment.pattern === part) {
+            return true;
+          }
+          return false;
+        });
+        if (match) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  partial.default = PartialMatcher;
+  return partial;
+}
+
+export { requirePartial as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.mjs

@@ -0,0 +1,64 @@
+import { __exports as provider } from '../../../../../../../_virtual/provider.mjs';
+import path__default from 'node:path';
+import { __require as requireDeep } from './filters/deep.mjs';
+import { __require as requireEntry } from './filters/entry.mjs';
+import { __require as requireError } from './filters/error.mjs';
+import { __require as requireEntry$1 } from './transformers/entry.mjs';
+
+var hasRequiredProvider;
+function requireProvider() {
+  if (hasRequiredProvider) return provider;
+  hasRequiredProvider = 1;
+  Object.defineProperty(provider, "__esModule", {
+    value: true
+  });
+  const path = path__default;
+  const deep_1 = requireDeep();
+  const entry_1 = requireEntry();
+  const error_1 = requireError();
+  const entry_2 = requireEntry$1();
+  class Provider {
+    constructor(_settings) {
+      this._settings = _settings;
+      this.errorFilter = new error_1.default(this._settings);
+      this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+      this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+      this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+      return path.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+      const basePath = task.base === '.' ? '' : task.base;
+      return {
+        basePath,
+        pathSegmentSeparator: '/',
+        concurrency: this._settings.concurrency,
+        deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+        entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+        errorFilter: this.errorFilter.getFilter(),
+        followSymbolicLinks: this._settings.followSymbolicLinks,
+        fs: this._settings.fs,
+        stats: this._settings.stats,
+        throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+        transform: this.entryTransformer.getTransformer()
+      };
+    }
+    _getMicromatchOptions() {
+      return {
+        dot: this._settings.dot,
+        matchBase: this._settings.baseNameMatch,
+        nobrace: !this._settings.braceExpansion,
+        nocase: !this._settings.caseSensitiveMatch,
+        noext: !this._settings.extglob,
+        noglobstar: !this._settings.globstar,
+        posix: true,
+        strictSlashes: false
+      };
+    }
+  }
+  provider.default = Provider;
+  return provider;
+}
+
+export { requireProvider as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/stream.mjs

@@ -0,0 +1,44 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream.mjs';
+import require$$0 from 'node:stream';
+import { __require as requireStream$1 } from '../readers/stream.mjs';
+import { __require as requireProvider } from './provider.mjs';
+
+var hasRequiredStream;
+function requireStream() {
+  if (hasRequiredStream) return stream;
+  hasRequiredStream = 1;
+  Object.defineProperty(stream, "__esModule", {
+    value: true
+  });
+  const stream_1 = require$$0;
+  const stream_2 = requireStream$1();
+  const provider_1 = requireProvider();
+  class ProviderStream extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const source = this.api(root, task, options);
+      const destination = new stream_1.Readable({
+        objectMode: true,
+        read: () => {}
+      });
+      source.once('error', error => destination.emit('error', error)).on('data', entry => destination.emit('data', options.transform(entry))).once('end', () => destination.emit('end'));
+      destination.once('close', () => source.destroy());
+      return destination;
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  stream.default = ProviderStream;
+  return stream;
+}
+
+export { requireStream as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/sync.mjs

@@ -0,0 +1,36 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync.mjs';
+import { __require as requireSync$1 } from '../readers/sync.mjs';
+import { __require as requireProvider } from './provider.mjs';
+
+var hasRequiredSync;
+function requireSync() {
+  if (hasRequiredSync) return sync;
+  hasRequiredSync = 1;
+  Object.defineProperty(sync, "__esModule", {
+    value: true
+  });
+  const sync_1 = requireSync$1();
+  const provider_1 = requireProvider();
+  class ProviderSync extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new sync_1.default(this._settings);
+    }
+    read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const entries = this.api(root, task, options);
+      return entries.map(options.transform);
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
+    }
+  }
+  sync.default = ProviderSync;
+  return sync;
+}
+
+export { requireSync as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/transformers/entry.mjs

@@ -0,0 +1,40 @@
+import { __exports as entry } from '../../../../../../../../_virtual/entry2.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+
+var hasRequiredEntry;
+function requireEntry() {
+  if (hasRequiredEntry) return entry;
+  hasRequiredEntry = 1;
+  Object.defineProperty(entry, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class EntryTransformer {
+    constructor(_settings) {
+      this._settings = _settings;
+    }
+    getTransformer() {
+      return entry => this._transform(entry);
+    }
+    _transform(entry) {
+      let filepath = entry.path;
+      if (this._settings.absolute) {
+        filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+        filepath = utils.path.unixify(filepath);
+      }
+      if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+        filepath += '/';
+      }
+      if (!this._settings.objectMode) {
+        return filepath;
+      }
+      return Object.assign(Object.assign({}, entry), {
+        path: filepath
+      });
+    }
+  }
+  entry.default = EntryTransformer;
+  return entry;
+}
+
+export { requireEntry as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/async.mjs

@@ -0,0 +1,48 @@
+import { __exports as async } from '../../../../../../../_virtual/async2.mjs';
+import { __require as requireOut } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.mjs';
+import { __require as requireReader } from './reader.mjs';
+import { __require as requireStream } from './stream.mjs';
+
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", {
+    value: true
+  });
+  const fsWalk = requireOut();
+  const reader_1 = requireReader();
+  const stream_1 = requireStream();
+  class ReaderAsync extends reader_1.default {
+    constructor() {
+      super(...arguments);
+      this._walkAsync = fsWalk.walk;
+      this._readerStream = new stream_1.default(this._settings);
+    }
+    dynamic(root, options) {
+      return new Promise((resolve, reject) => {
+        this._walkAsync(root, options, (error, entries) => {
+          if (error === null) {
+            resolve(entries);
+          } else {
+            reject(error);
+          }
+        });
+      });
+    }
+    async static(patterns, options) {
+      const entries = [];
+      const stream = this._readerStream.static(patterns, options);
+      // After #235, replace it with an asynchronous iterator.
+      return new Promise((resolve, reject) => {
+        stream.once('error', reject);
+        stream.on('data', entry => entries.push(entry));
+        stream.once('end', () => resolve(entries));
+      });
+    }
+  }
+  async.default = ReaderAsync;
+  return async;
+}
+
+export { requireAsync as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/reader.mjs

@@ -0,0 +1,47 @@
+import { __exports as reader } from '../../../../../../../_virtual/reader.mjs';
+import path__default from 'node:path';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.mjs';
+import { __require as requireUtils } from '../utils/index.mjs';
+
+var hasRequiredReader;
+function requireReader() {
+  if (hasRequiredReader) return reader;
+  hasRequiredReader = 1;
+  Object.defineProperty(reader, "__esModule", {
+    value: true
+  });
+  const path = path__default;
+  const fsStat = requireOut();
+  const utils = requireUtils();
+  class Reader {
+    constructor(_settings) {
+      this._settings = _settings;
+      this._fsStatSettings = new fsStat.Settings({
+        followSymbolicLink: this._settings.followSymbolicLinks,
+        fs: this._settings.fs,
+        throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+      });
+    }
+    _getFullEntryPath(filepath) {
+      return path.resolve(this._settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+      const entry = {
+        name: pattern,
+        path: pattern,
+        dirent: utils.fs.createDirentFromStats(pattern, stats)
+      };
+      if (this._settings.stats) {
+        entry.stats = stats;
+      }
+      return entry;
+    }
+    _isFatalError(error) {
+      return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+    }
+  }
+  reader.default = Reader;
+  return reader;
+}
+
+export { requireReader as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/stream.mjs

@@ -0,0 +1,68 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream2.mjs';
+import require$$0 from 'node:stream';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.mjs';
+import { __require as requireOut$1 } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.mjs';
+import { __require as requireReader } from './reader.mjs';
+
+var hasRequiredStream;
+function requireStream() {
+  if (hasRequiredStream) return stream;
+  hasRequiredStream = 1;
+  Object.defineProperty(stream, "__esModule", {
+    value: true
+  });
+  const stream_1 = require$$0;
+  const fsStat = requireOut();
+  const fsWalk = requireOut$1();
+  const reader_1 = requireReader();
+  class ReaderStream extends reader_1.default {
+    constructor() {
+      super(...arguments);
+      this._walkStream = fsWalk.walkStream;
+      this._stat = fsStat.stat;
+    }
+    dynamic(root, options) {
+      return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+      const filepaths = patterns.map(this._getFullEntryPath, this);
+      const stream = new stream_1.PassThrough({
+        objectMode: true
+      });
+      stream._write = (index, _enc, done) => {
+        return this._getEntry(filepaths[index], patterns[index], options).then(entry => {
+          if (entry !== null && options.entryFilter(entry)) {
+            stream.push(entry);
+          }
+          if (index === filepaths.length - 1) {
+            stream.end();
+          }
+          done();
+        }).catch(done);
+      };
+      for (let i = 0; i < filepaths.length; i++) {
+        stream.write(i);
+      }
+      return stream;
+    }
+    _getEntry(filepath, pattern, options) {
+      return this._getStat(filepath).then(stats => this._makeEntry(stats, pattern)).catch(error => {
+        if (options.errorFilter(error)) {
+          return null;
+        }
+        throw error;
+      });
+    }
+    _getStat(filepath) {
+      return new Promise((resolve, reject) => {
+        this._stat(filepath, this._fsStatSettings, (error, stats) => {
+          return error === null ? resolve(stats) : reject(error);
+        });
+      });
+    }
+  }
+  stream.default = ReaderStream;
+  return stream;
+}
+
+export { requireStream as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/sync.mjs

@@ -0,0 +1,56 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync2.mjs';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.mjs';
+import { __require as requireOut$1 } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.mjs';
+import { __require as requireReader } from './reader.mjs';
+
+var hasRequiredSync;
+function requireSync() {
+  if (hasRequiredSync) return sync;
+  hasRequiredSync = 1;
+  Object.defineProperty(sync, "__esModule", {
+    value: true
+  });
+  const fsStat = requireOut();
+  const fsWalk = requireOut$1();
+  const reader_1 = requireReader();
+  class ReaderSync extends reader_1.default {
+    constructor() {
+      super(...arguments);
+      this._walkSync = fsWalk.walkSync;
+      this._statSync = fsStat.statSync;
+    }
+    dynamic(root, options) {
+      return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+      const entries = [];
+      for (const pattern of patterns) {
+        const filepath = this._getFullEntryPath(pattern);
+        const entry = this._getEntry(filepath, pattern, options);
+        if (entry === null || !options.entryFilter(entry)) {
+          continue;
+        }
+        entries.push(entry);
+      }
+      return entries;
+    }
+    _getEntry(filepath, pattern, options) {
+      try {
+        const stats = this._getStat(filepath);
+        return this._makeEntry(stats, pattern);
+      } catch (error) {
+        if (options.errorFilter(error)) {
+          return null;
+        }
+        throw error;
+      }
+    }
+    _getStat(filepath) {
+      return this._statSync(filepath, this._fsStatSettings);
+    }
+  }
+  sync.default = ReaderSync;
+  return sync;
+}
+
+export { requireSync as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/settings.mjs

@@ -0,0 +1,75 @@
+import { __exports as settings } from '../../../../../../_virtual/settings.mjs';
+import fs__default from 'node:fs';
+import require$$0 from 'node:os';
+
+var hasRequiredSettings;
+function requireSettings() {
+  if (hasRequiredSettings) return settings;
+  hasRequiredSettings = 1;
+  (function (exports) {
+
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+    const fs = fs__default;
+    const os = require$$0;
+    /**
+     * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
+     * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
+     */
+    const CPU_COUNT = Math.max(os.cpus().length, 1);
+    exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+      lstat: fs.lstat,
+      lstatSync: fs.lstatSync,
+      stat: fs.stat,
+      statSync: fs.statSync,
+      readdir: fs.readdir,
+      readdirSync: fs.readdirSync
+    };
+    class Settings {
+      constructor(_options = {}) {
+        this._options = _options;
+        this.absolute = this._getValue(this._options.absolute, false);
+        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+        this.cwd = this._getValue(this._options.cwd, process.cwd());
+        this.deep = this._getValue(this._options.deep, Infinity);
+        this.dot = this._getValue(this._options.dot, false);
+        this.extglob = this._getValue(this._options.extglob, true);
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+        this.fs = this._getFileSystemMethods(this._options.fs);
+        this.globstar = this._getValue(this._options.globstar, true);
+        this.ignore = this._getValue(this._options.ignore, []);
+        this.markDirectories = this._getValue(this._options.markDirectories, false);
+        this.objectMode = this._getValue(this._options.objectMode, false);
+        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+        this.stats = this._getValue(this._options.stats, false);
+        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+        this.unique = this._getValue(this._options.unique, true);
+        if (this.onlyDirectories) {
+          this.onlyFiles = false;
+        }
+        if (this.stats) {
+          this.objectMode = true;
+        }
+        // Remove the cast to the array in the next major (#404).
+        this.ignore = [].concat(this.ignore);
+      }
+      _getValue(option, value) {
+        return option === undefined ? value : option;
+      }
+      _getFileSystemMethods(methods = {}) {
+        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+      }
+    }
+    exports.default = Settings;
+  })(settings);
+  return settings;
+}
+
+export { requireSettings as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.mjs

@@ -0,0 +1,32 @@
+import { __exports as array } from '../../../../../../../_virtual/array.mjs';
+
+var hasRequiredArray;
+function requireArray() {
+  if (hasRequiredArray) return array;
+  hasRequiredArray = 1;
+  Object.defineProperty(array, "__esModule", {
+    value: true
+  });
+  array.splitWhen = array.flatten = void 0;
+  function flatten(items) {
+    return items.reduce((collection, item) => [].concat(collection, item), []);
+  }
+  array.flatten = flatten;
+  function splitWhen(items, predicate) {
+    const result = [[]];
+    let groupIndex = 0;
+    for (const item of items) {
+      if (predicate(item)) {
+        groupIndex++;
+        result[groupIndex] = [];
+      } else {
+        result[groupIndex].push(item);
+      }
+    }
+    return result;
+  }
+  array.splitWhen = splitWhen;
+  return array;
+}
+
+export { requireArray as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/errno.mjs

@@ -0,0 +1,18 @@
+import { __exports as errno } from '../../../../../../../_virtual/errno.mjs';
+
+var hasRequiredErrno;
+function requireErrno() {
+  if (hasRequiredErrno) return errno;
+  hasRequiredErrno = 1;
+  Object.defineProperty(errno, "__esModule", {
+    value: true
+  });
+  errno.isEnoentCodeError = void 0;
+  function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+  }
+  errno.isEnoentCodeError = isEnoentCodeError;
+  return errno;
+}
+
+export { requireErrno as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/fs.mjs

@@ -0,0 +1,30 @@
+import { __exports as fs } from '../../../../../../../_virtual/fs.mjs';
+
+var hasRequiredFs;
+function requireFs() {
+  if (hasRequiredFs) return fs;
+  hasRequiredFs = 1;
+  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;
+  return fs;
+}
+
+export { requireFs as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/index.mjs

@@ -0,0 +1,35 @@
+import { __exports as utils } from '../../../../../../../_virtual/index8.mjs';
+import { __require as requireArray } from './array.mjs';
+import { __require as requireErrno } from './errno.mjs';
+import { __require as requireFs } from './fs.mjs';
+import { __require as requirePath } from './path.mjs';
+import { __require as requirePattern } from './pattern.mjs';
+import { __require as requireStream } from './stream.mjs';
+import { __require as requireString } from './string.mjs';
+
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  Object.defineProperty(utils, "__esModule", {
+    value: true
+  });
+  utils.string = utils.stream = utils.pattern = utils.path = utils.fs = utils.errno = utils.array = void 0;
+  const array = requireArray();
+  utils.array = array;
+  const errno = requireErrno();
+  utils.errno = errno;
+  const fs = requireFs();
+  utils.fs = fs;
+  const path = requirePath();
+  utils.path = path;
+  const pattern = requirePattern();
+  utils.pattern = pattern;
+  const stream = requireStream();
+  utils.stream = stream;
+  const string = requireString();
+  utils.string = string;
+  return utils;
+}
+
+export { requireUtils as __require };