@quilted/create 0.2.43 → 0.2.45

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

@@ -0,0 +1,79 @@
+import { __exports as path } from '../../../../../../../_virtual/path.mjs';
+import require$$0 from 'node:os';
+import path__default from 'node:path';
+
+var hasRequiredPath;
+function requirePath() {
+  if (hasRequiredPath) return path;
+  hasRequiredPath = 1;
+  Object.defineProperty(path, "__esModule", {
+    value: true
+  });
+  path.convertPosixPathToPattern = path.convertWindowsPathToPattern = path.convertPathToPattern = path.escapePosixPath = path.escapeWindowsPath = path.escape = path.removeLeadingDotSegment = path.makeAbsolute = path.unixify = void 0;
+  const os = require$$0;
+  const path$1 = path__default;
+  const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
+  const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+  /**
+   * All non-escaped special characters.
+   * Posix: ()*?[]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
+   * Windows: (){}[], !+@ before (, ! at the beginning.
+   */
+  const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+  const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
+  /**
+   * The device path (\\.\ or \\?\).
+   * https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
+   */
+  const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
+  /**
+   * All backslashes except those escaping special characters.
+   * Windows: !()+@{}
+   * https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+   */
+  const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
+  /**
+   * Designed to work only with simple paths: `dir\\file`.
+   */
+  function unixify(filepath) {
+    return filepath.replace(/\\/g, '/');
+  }
+  path.unixify = unixify;
+  function makeAbsolute(cwd, filepath) {
+    return path$1.resolve(cwd, filepath);
+  }
+  path.makeAbsolute = makeAbsolute;
+  function removeLeadingDotSegment(entry) {
+    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+    if (entry.charAt(0) === '.') {
+      const secondCharactery = entry.charAt(1);
+      if (secondCharactery === '/' || secondCharactery === '\\') {
+        return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+      }
+    }
+    return entry;
+  }
+  path.removeLeadingDotSegment = removeLeadingDotSegment;
+  path.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+  function escapeWindowsPath(pattern) {
+    return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+  }
+  path.escapeWindowsPath = escapeWindowsPath;
+  function escapePosixPath(pattern) {
+    return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+  }
+  path.escapePosixPath = escapePosixPath;
+  path.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+  function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath).replace(DOS_DEVICE_PATH_RE, '//$1').replace(WINDOWS_BACKSLASHES_RE, '/');
+  }
+  path.convertWindowsPathToPattern = convertWindowsPathToPattern;
+  function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+  }
+  path.convertPosixPathToPattern = convertPosixPathToPattern;
+  return path;
+}
+
+export { requirePath as __require };

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

@@ -0,0 +1,229 @@
+import { __exports as pattern } from '../../../../../../../_virtual/pattern.mjs';
+import path__default from 'node:path';
+import { __require as requireGlobParent } from '../../../../../glob-parent@5.1.2/node_modules/glob-parent/index.mjs';
+import { __require as requireMicromatch } from '../../../../../micromatch@4.0.8/node_modules/micromatch/index.mjs';
+
+var hasRequiredPattern;
+function requirePattern() {
+  if (hasRequiredPattern) return pattern;
+  hasRequiredPattern = 1;
+  Object.defineProperty(pattern, "__esModule", {
+    value: true
+  });
+  pattern.isAbsolute = pattern.partitionAbsoluteAndRelative = pattern.removeDuplicateSlashes = pattern.matchAny = pattern.convertPatternsToRe = pattern.makeRe = pattern.getPatternParts = pattern.expandBraceExpansion = pattern.expandPatternsWithBraceExpansion = pattern.isAffectDepthOfReadingPattern = pattern.endsWithSlashGlobStar = pattern.hasGlobStar = pattern.getBaseDirectory = pattern.isPatternRelatedToParentDirectory = pattern.getPatternsOutsideCurrentDirectory = pattern.getPatternsInsideCurrentDirectory = pattern.getPositivePatterns = pattern.getNegativePatterns = pattern.isPositivePattern = pattern.isNegativePattern = pattern.convertToNegativePattern = pattern.convertToPositivePattern = pattern.isDynamicPattern = pattern.isStaticPattern = void 0;
+  const path = path__default;
+  const globParent = requireGlobParent();
+  const micromatch = requireMicromatch();
+  const GLOBSTAR = '**';
+  const ESCAPE_SYMBOL = '\\';
+  const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+  const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+  const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+  const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+  const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+  /**
+   * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+   * The latter is due to the presence of the device path at the beginning of the UNC path.
+   */
+  const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+  function isStaticPattern(pattern, options = {}) {
+    return !isDynamicPattern(pattern, options);
+  }
+  pattern.isStaticPattern = isStaticPattern;
+  function isDynamicPattern(pattern, options = {}) {
+    /**
+     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+     * An empty string cannot be a dynamic pattern.
+     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+     */
+    if (pattern === '') {
+      return false;
+    }
+    /**
+     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+     * filepath directly (without read directory).
+     */
+    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+      return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+      return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+      return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+      return true;
+    }
+    return false;
+  }
+  pattern.isDynamicPattern = isDynamicPattern;
+  function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+      return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+      return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+  }
+  function convertToPositivePattern(pattern) {
+    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+  }
+  pattern.convertToPositivePattern = convertToPositivePattern;
+  function convertToNegativePattern(pattern) {
+    return '!' + pattern;
+  }
+  pattern.convertToNegativePattern = convertToNegativePattern;
+  function isNegativePattern(pattern) {
+    return pattern.startsWith('!') && pattern[1] !== '(';
+  }
+  pattern.isNegativePattern = isNegativePattern;
+  function isPositivePattern(pattern) {
+    return !isNegativePattern(pattern);
+  }
+  pattern.isPositivePattern = isPositivePattern;
+  function getNegativePatterns(patterns) {
+    return patterns.filter(isNegativePattern);
+  }
+  pattern.getNegativePatterns = getNegativePatterns;
+  function getPositivePatterns(patterns) {
+    return patterns.filter(isPositivePattern);
+  }
+  pattern.getPositivePatterns = getPositivePatterns;
+  /**
+   * Returns patterns that can be applied inside the current directory.
+   *
+   * @example
+   * // ['./*', '*', 'a/*']
+   * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+   */
+  function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter(pattern => !isPatternRelatedToParentDirectory(pattern));
+  }
+  pattern.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+  /**
+   * Returns patterns to be expanded relative to (outside) the current directory.
+   *
+   * @example
+   * // ['../*', './../*']
+   * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+   */
+  function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter(isPatternRelatedToParentDirectory);
+  }
+  pattern.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+  function isPatternRelatedToParentDirectory(pattern) {
+    return pattern.startsWith('..') || pattern.startsWith('./..');
+  }
+  pattern.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+  function getBaseDirectory(pattern) {
+    return globParent(pattern, {
+      flipBackslashes: false
+    });
+  }
+  pattern.getBaseDirectory = getBaseDirectory;
+  function hasGlobStar(pattern) {
+    return pattern.includes(GLOBSTAR);
+  }
+  pattern.hasGlobStar = hasGlobStar;
+  function endsWithSlashGlobStar(pattern) {
+    return pattern.endsWith('/' + GLOBSTAR);
+  }
+  pattern.endsWithSlashGlobStar = endsWithSlashGlobStar;
+  function isAffectDepthOfReadingPattern(pattern) {
+    const basename = path.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+  }
+  pattern.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+  function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern) => {
+      return collection.concat(expandBraceExpansion(pattern));
+    }, []);
+  }
+  pattern.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+  function expandBraceExpansion(pattern) {
+    const patterns = micromatch.braces(pattern, {
+      expand: true,
+      nodupes: true,
+      keepEscaping: true
+    });
+    /**
+     * Sort the patterns by length so that the same depth patterns are processed side by side.
+     * `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
+     */
+    patterns.sort((a, b) => a.length - b.length);
+    /**
+     * Micromatch can return an empty string in the case of patterns like `{a,}`.
+     */
+    return patterns.filter(pattern => pattern !== '');
+  }
+  pattern.expandBraceExpansion = expandBraceExpansion;
+  function getPatternParts(pattern, options) {
+    let {
+      parts
+    } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), {
+      parts: true
+    }));
+    /**
+     * The scan method returns an empty array in some cases.
+     * See micromatch/picomatch#58 for more details.
+     */
+    if (parts.length === 0) {
+      parts = [pattern];
+    }
+    /**
+     * The scan method does not return an empty part for the pattern with a forward slash.
+     * This is another part of micromatch/picomatch#58.
+     */
+    if (parts[0].startsWith('/')) {
+      parts[0] = parts[0].slice(1);
+      parts.unshift('');
+    }
+    return parts;
+  }
+  pattern.getPatternParts = getPatternParts;
+  function makeRe(pattern, options) {
+    return micromatch.makeRe(pattern, options);
+  }
+  pattern.makeRe = makeRe;
+  function convertPatternsToRe(patterns, options) {
+    return patterns.map(pattern => makeRe(pattern, options));
+  }
+  pattern.convertPatternsToRe = convertPatternsToRe;
+  function matchAny(entry, patternsRe) {
+    return patternsRe.some(patternRe => patternRe.test(entry));
+  }
+  pattern.matchAny = matchAny;
+  /**
+   * This package only works with forward slashes as a path separator.
+   * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+   */
+  function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE, '/');
+  }
+  pattern.removeDuplicateSlashes = removeDuplicateSlashes;
+  function partitionAbsoluteAndRelative(patterns) {
+    const absolute = [];
+    const relative = [];
+    for (const pattern of patterns) {
+      if (isAbsolute(pattern)) {
+        absolute.push(pattern);
+      } else {
+        relative.push(pattern);
+      }
+    }
+    return [absolute, relative];
+  }
+  pattern.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
+  function isAbsolute(pattern) {
+    return path.isAbsolute(pattern);
+  }
+  pattern.isAbsolute = isAbsolute;
+  return pattern;
+}
+
+export { requirePattern as __require };

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

@@ -0,0 +1,29 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream3.mjs';
+import { __require as requireMerge2 } from '../../../../../merge2@1.4.1/node_modules/merge2/index.mjs';
+
+var hasRequiredStream;
+function requireStream() {
+  if (hasRequiredStream) return stream;
+  hasRequiredStream = 1;
+  Object.defineProperty(stream, "__esModule", {
+    value: true
+  });
+  stream.merge = void 0;
+  const merge2 = requireMerge2();
+  function merge(streams) {
+    const mergedStream = merge2(streams);
+    streams.forEach(stream => {
+      stream.once('error', error => mergedStream.emit('error', error));
+    });
+    mergedStream.once('close', () => propagateCloseEventToSources(streams));
+    mergedStream.once('end', () => propagateCloseEventToSources(streams));
+    return mergedStream;
+  }
+  stream.merge = merge;
+  function propagateCloseEventToSources(streams) {
+    streams.forEach(stream => stream.emit('close'));
+  }
+  return stream;
+}
+
+export { requireStream as __require };

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

@@ -0,0 +1,22 @@
+import { __exports as string } from '../../../../../../../_virtual/string.mjs';
+
+var hasRequiredString;
+function requireString() {
+  if (hasRequiredString) return string;
+  hasRequiredString = 1;
+  Object.defineProperty(string, "__esModule", {
+    value: true
+  });
+  string.isEmpty = string.isString = void 0;
+  function isString(input) {
+    return typeof input === 'string';
+  }
+  string.isString = isString;
+  function isEmpty(input) {
+    return input === '';
+  }
+  string.isEmpty = isEmpty;
+  return string;
+}
+
+export { requireString as __require };