@quilted/create 0.2.43 → 0.2.44

package/build/esm/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/tasks.mjs

@@ -1,85 +1,90 @@
 import { __exports as tasks } from '../../../../../../../_virtual/tasks.mjs';
-import '../utils/index.mjs';
-import { __exports as utils$1 } from '../../../../../../../_virtual/index.mjs';
+import { __require as requireUtils } from '../utils/index.mjs';
 
-Object.defineProperty(tasks, "__esModule", {
-  value: true
-});
-tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils = utils$1;
-function generate(patterns, settings) {
-  const positivePatterns = getPositivePatterns(patterns);
-  const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
-  const staticPatterns = positivePatterns.filter(pattern => utils.pattern.isStaticPattern(pattern, settings));
-  const dynamicPatterns = positivePatterns.filter(pattern => utils.pattern.isDynamicPattern(pattern, settings));
-  const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */false);
-  const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */true);
-  return staticTasks.concat(dynamicTasks);
-}
-tasks.generate = generate;
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-function convertPatternsToTasks(positive, negative, dynamic) {
-  const tasks = [];
-  const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
-  const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
-  const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-  const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-  tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-  /*
-   * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-   * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
-   */
-  if ('.' in insideCurrentDirectoryGroup) {
-    tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
-  } else {
-    tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+var hasRequiredTasks;
+function requireTasks() {
+  if (hasRequiredTasks) return tasks;
+  hasRequiredTasks = 1;
+  Object.defineProperty(tasks, "__esModule", {
+    value: true
+  });
+  tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+  const utils = requireUtils();
+  function generate(patterns, settings) {
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
+    const staticPatterns = positivePatterns.filter(pattern => utils.pattern.isStaticPattern(pattern, settings));
+    const dynamicPatterns = positivePatterns.filter(pattern => utils.pattern.isDynamicPattern(pattern, settings));
+    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */false);
+    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */true);
+    return staticTasks.concat(dynamicTasks);
   }
-  return tasks;
-}
-tasks.convertPatternsToTasks = convertPatternsToTasks;
-function getPositivePatterns(patterns) {
-  return utils.pattern.getPositivePatterns(patterns);
-}
-tasks.getPositivePatterns = getPositivePatterns;
-function getNegativePatternsAsPositive(patterns, ignore) {
-  const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
-  const positive = negative.map(utils.pattern.convertToPositivePattern);
-  return positive;
-}
-tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
-function groupPatternsByBaseDirectory(patterns) {
-  const group = {};
-  return patterns.reduce((collection, pattern) => {
-    const base = utils.pattern.getBaseDirectory(pattern);
-    if (base in collection) {
-      collection[base].push(pattern);
+  tasks.generate = generate;
+  /**
+   * Returns tasks grouped by basic pattern directories.
+   *
+   * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+   * This is necessary because directory traversal starts at the base directory and goes deeper.
+   */
+  function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks = [];
+    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    /*
+     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+     */
+    if ('.' in insideCurrentDirectoryGroup) {
+      tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
     } else {
-      collection[base] = [pattern];
+      tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
     }
-    return collection;
-  }, group);
-}
-tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
-function convertPatternGroupsToTasks(positive, negative, dynamic) {
-  return Object.keys(positive).map(base => {
-    return convertPatternGroupToTask(base, positive[base], negative, dynamic);
-  });
-}
-tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-function convertPatternGroupToTask(base, positive, negative, dynamic) {
-  return {
-    dynamic,
-    positive,
-    negative,
-    base,
-    patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
-  };
+    return tasks;
+  }
+  tasks.convertPatternsToTasks = convertPatternsToTasks;
+  function getPositivePatterns(patterns) {
+    return utils.pattern.getPositivePatterns(patterns);
+  }
+  tasks.getPositivePatterns = getPositivePatterns;
+  function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils.pattern.convertToPositivePattern);
+    return positive;
+  }
+  tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+  function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+      const base = utils.pattern.getBaseDirectory(pattern);
+      if (base in collection) {
+        collection[base].push(pattern);
+      } else {
+        collection[base] = [pattern];
+      }
+      return collection;
+    }, group);
+  }
+  tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+  function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map(base => {
+      return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+  }
+  tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+  function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+      dynamic,
+      positive,
+      negative,
+      base,
+      patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
+    };
+  }
+  tasks.convertPatternGroupToTask = convertPatternGroupToTask;
+  return tasks;
 }
-tasks.convertPatternGroupToTask = convertPatternGroupToTask;
 
-export { tasks as default };
+export { requireTasks as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/async.mjs

@@ -1,30 +1,36 @@
 import { __exports as async } from '../../../../../../../_virtual/async.mjs';
-import '../readers/async.mjs';
-import './provider.mjs';
-import { __exports as async$1 } from '../../../../../../../_virtual/async2.mjs';
-import { __exports as provider } from '../../../../../../../_virtual/provider.mjs';
+import { __require as requireAsync$1 } from '../readers/async.mjs';
+import { __require as requireProvider } from './provider.mjs';
 
-Object.defineProperty(async, "__esModule", {
-  value: true
-});
-const async_1 = async$1;
-const provider_1 = provider;
-class ProviderAsync extends provider_1.default {
-  constructor() {
-    super(...arguments);
-    this._reader = new async_1.default(this._settings);
-  }
-  async read(task) {
-    const root = this._getRootDirectory(task);
-    const options = this._getReaderOptions(task);
-    const entries = await this.api(root, task, options);
-    return entries.map(entry => options.transform(entry));
-  }
-  api(root, task, options) {
-    if (task.dynamic) {
-      return this._reader.dynamic(root, options);
+var hasRequiredAsync;
+function requireAsync() {
+  if (hasRequiredAsync) return async;
+  hasRequiredAsync = 1;
+  Object.defineProperty(async, "__esModule", {
+    value: true
+  });
+  const async_1 = requireAsync$1();
+  const provider_1 = requireProvider();
+  class ProviderAsync extends provider_1.default {
+    constructor() {
+      super(...arguments);
+      this._reader = new async_1.default(this._settings);
+    }
+    async read(task) {
+      const root = this._getRootDirectory(task);
+      const options = this._getReaderOptions(task);
+      const entries = await this.api(root, task, options);
+      return entries.map(entry => options.transform(entry));
+    }
+    api(root, task, options) {
+      if (task.dynamic) {
+        return this._reader.dynamic(root, options);
+      }
+      return this._reader.static(task.patterns, options);
     }
-    return this._reader.static(task.patterns, options);
   }
+  async.default = ProviderAsync;
+  return async;
 }
-async.default = ProviderAsync;
+
+export { requireAsync as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/filters/deep.mjs

@@ -1,69 +1,75 @@
 import { __exports as deep } from '../../../../../../../../_virtual/deep.mjs';
-import '../../utils/index.mjs';
-import '../matchers/partial.mjs';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.mjs';
-import { __exports as partial } from '../../../../../../../../_virtual/partial.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
+import { __require as requirePartial } from '../matchers/partial.mjs';
 
-Object.defineProperty(deep, "__esModule", {
-  value: true
-});
-const utils = utils$1;
-const partial_1 = partial;
-class DeepFilter {
-  constructor(_settings, _micromatchOptions) {
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-  }
-  getFilter(basePath, positive, negative) {
-    const matcher = this._getMatcher(positive);
-    const negativeRe = this._getNegativePatternsRe(negative);
-    return entry => this._filter(basePath, entry, matcher, negativeRe);
-  }
-  _getMatcher(patterns) {
-    return new partial_1.default(patterns, this._settings, this._micromatchOptions);
-  }
-  _getNegativePatternsRe(patterns) {
-    const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
-    return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
-  }
-  _filter(basePath, entry, matcher, negativeRe) {
-    if (this._isSkippedByDeep(basePath, entry.path)) {
-      return false;
+var hasRequiredDeep;
+function requireDeep() {
+  if (hasRequiredDeep) return deep;
+  hasRequiredDeep = 1;
+  Object.defineProperty(deep, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  const partial_1 = requirePartial();
+  class DeepFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
     }
-    if (this._isSkippedSymbolicLink(entry)) {
-      return false;
+    getFilter(basePath, positive, negative) {
+      const matcher = this._getMatcher(positive);
+      const negativeRe = this._getNegativePatternsRe(negative);
+      return entry => this._filter(basePath, entry, matcher, negativeRe);
     }
-    const filepath = utils.path.removeLeadingDotSegment(entry.path);
-    if (this._isSkippedByPositivePatterns(filepath, matcher)) {
-      return false;
+    _getMatcher(patterns) {
+      return new partial_1.default(patterns, this._settings, this._micromatchOptions);
     }
-    return this._isSkippedByNegativePatterns(filepath, negativeRe);
-  }
-  _isSkippedByDeep(basePath, entryPath) {
-    /**
-     * Avoid unnecessary depth calculations when it doesn't matter.
-     */
-    if (this._settings.deep === Infinity) {
-      return false;
+    _getNegativePatternsRe(patterns) {
+      const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+      return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
     }
-    return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
-  }
-  _getEntryLevel(basePath, entryPath) {
-    const entryPathDepth = entryPath.split('/').length;
-    if (basePath === '') {
-      return entryPathDepth;
+    _filter(basePath, entry, matcher, negativeRe) {
+      if (this._isSkippedByDeep(basePath, entry.path)) {
+        return false;
+      }
+      if (this._isSkippedSymbolicLink(entry)) {
+        return false;
+      }
+      const filepath = utils.path.removeLeadingDotSegment(entry.path);
+      if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+        return false;
+      }
+      return this._isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    _isSkippedByDeep(basePath, entryPath) {
+      /**
+       * Avoid unnecessary depth calculations when it doesn't matter.
+       */
+      if (this._settings.deep === Infinity) {
+        return false;
+      }
+      return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+    }
+    _getEntryLevel(basePath, entryPath) {
+      const entryPathDepth = entryPath.split('/').length;
+      if (basePath === '') {
+        return entryPathDepth;
+      }
+      const basePathDepth = basePath.split('/').length;
+      return entryPathDepth - basePathDepth;
+    }
+    _isSkippedSymbolicLink(entry) {
+      return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(entryPath, matcher) {
+      return !this._settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    _isSkippedByNegativePatterns(entryPath, patternsRe) {
+      return !utils.pattern.matchAny(entryPath, patternsRe);
     }
-    const basePathDepth = basePath.split('/').length;
-    return entryPathDepth - basePathDepth;
-  }
-  _isSkippedSymbolicLink(entry) {
-    return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
-  }
-  _isSkippedByPositivePatterns(entryPath, matcher) {
-    return !this._settings.baseNameMatch && !matcher.match(entryPath);
-  }
-  _isSkippedByNegativePatterns(entryPath, patternsRe) {
-    return !utils.pattern.matchAny(entryPath, patternsRe);
   }
+  deep.default = DeepFilter;
+  return deep;
 }
-deep.default = DeepFilter;
+
+export { requireDeep as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/filters/entry.mjs

@@ -1,69 +1,76 @@
 import { __exports as entry } from '../../../../../../../../_virtual/entry.mjs';
-import '../../utils/index.mjs';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
 
-Object.defineProperty(entry, "__esModule", {
-  value: true
-});
-const utils = utils$1;
-class EntryFilter {
-  constructor(_settings, _micromatchOptions) {
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-    this.index = new Map();
-  }
-  getFilter(positive, negative) {
-    const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-    const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
-    return entry => this._filter(entry, positiveRe, negativeRe);
-  }
-  _filter(entry, positiveRe, negativeRe) {
-    if (this._settings.unique && this._isDuplicateEntry(entry)) {
-      return false;
+var hasRequiredEntry;
+function requireEntry() {
+  if (hasRequiredEntry) return entry;
+  hasRequiredEntry = 1;
+  Object.defineProperty(entry, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this.index = new Map();
     }
-    if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
-      return false;
+    getFilter(positive, negative) {
+      const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+      const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+      return entry => this._filter(entry, positiveRe, negativeRe);
     }
-    if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
-      return false;
+    _filter(entry, positiveRe, negativeRe) {
+      if (this._settings.unique && this._isDuplicateEntry(entry)) {
+        return false;
+      }
+      if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+        return false;
+      }
+      if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
+        return false;
+      }
+      const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
+      const isDirectory = entry.dirent.isDirectory();
+      const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry.path, negativeRe, isDirectory);
+      if (this._settings.unique && isMatched) {
+        this._createIndexRecord(entry);
+      }
+      return isMatched;
     }
-    const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
-    const isDirectory = entry.dirent.isDirectory();
-    const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry.path, negativeRe, isDirectory);
-    if (this._settings.unique && isMatched) {
-      this._createIndexRecord(entry);
+    _isDuplicateEntry(entry) {
+      return this.index.has(entry.path);
     }
-    return isMatched;
-  }
-  _isDuplicateEntry(entry) {
-    return this.index.has(entry.path);
-  }
-  _createIndexRecord(entry) {
-    this.index.set(entry.path, undefined);
-  }
-  _onlyFileFilter(entry) {
-    return this._settings.onlyFiles && !entry.dirent.isFile();
-  }
-  _onlyDirectoryFilter(entry) {
-    return this._settings.onlyDirectories && !entry.dirent.isDirectory();
-  }
-  _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
-    if (!this._settings.absolute) {
-      return false;
+    _createIndexRecord(entry) {
+      this.index.set(entry.path, undefined);
     }
-    const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
-    return utils.pattern.matchAny(fullpath, patternsRe);
-  }
-  _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
-    const filepath = utils.path.removeLeadingDotSegment(entryPath);
-    // Trying to match files and directories by patterns.
-    const isMatched = utils.pattern.matchAny(filepath, patternsRe);
-    // A pattern with a trailling slash can be used for directory matching.
-    // To apply such pattern, we need to add a tralling slash to the path.
-    if (!isMatched && isDirectory) {
-      return utils.pattern.matchAny(filepath + '/', patternsRe);
+    _onlyFileFilter(entry) {
+      return this._settings.onlyFiles && !entry.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry) {
+      return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+    }
+    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+      if (!this._settings.absolute) {
+        return false;
+      }
+      const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
+      return utils.pattern.matchAny(fullpath, patternsRe);
+    }
+    _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
+      const filepath = utils.path.removeLeadingDotSegment(entryPath);
+      // Trying to match files and directories by patterns.
+      const isMatched = utils.pattern.matchAny(filepath, patternsRe);
+      // A pattern with a trailling slash can be used for directory matching.
+      // To apply such pattern, we need to add a tralling slash to the path.
+      if (!isMatched && isDirectory) {
+        return utils.pattern.matchAny(filepath + '/', patternsRe);
+      }
+      return isMatched;
     }
-    return isMatched;
   }
+  entry.default = EntryFilter;
+  return entry;
 }
-entry.default = EntryFilter;
+
+export { requireEntry as __require };

package/build/esm/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/filters/error.mjs

@@ -1,20 +1,27 @@
 import { __exports as error } from '../../../../../../../../_virtual/error.mjs';
-import '../../utils/index.mjs';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
 
-Object.defineProperty(error, "__esModule", {
-  value: true
-});
-const utils = utils$1;
-class ErrorFilter {
-  constructor(_settings) {
-    this._settings = _settings;
-  }
-  getFilter() {
-    return error => this._isNonFatalError(error);
-  }
-  _isNonFatalError(error) {
-    return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+var hasRequiredError;
+function requireError() {
+  if (hasRequiredError) return error;
+  hasRequiredError = 1;
+  Object.defineProperty(error, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class ErrorFilter {
+    constructor(_settings) {
+      this._settings = _settings;
+    }
+    getFilter() {
+      return error => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+      return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
   }
+  error.default = ErrorFilter;
+  return error;
 }
-error.default = ErrorFilter;
+
+export { requireError as __require };