@quilted/create 0.2.43 → 0.2.45

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

@@ -0,0 +1,45 @@
+import { __exports as reader } from '../../../../../../../_virtual/reader.esnext';
+import path__default from 'node:path';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import { __require as requireUtils } from '../utils/index.esnext';
+
+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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/stream.esnext

@@ -0,0 +1,64 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream2.esnext';
+import require$$0 from 'node:stream';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import { __require as requireOut$1 } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext';
+import { __require as requireReader } from './reader.esnext';
+
+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 stream2 = new stream_1.PassThrough({ objectMode: true });
+      stream2._write = (index, _enc, done) => {
+        return this._getEntry(filepaths[index], patterns[index], options).then((entry) => {
+          if (entry !== null && options.entryFilter(entry)) {
+            stream2.push(entry);
+          }
+          if (index === filepaths.length - 1) {
+            stream2.end();
+          }
+          done();
+        }).catch(done);
+      };
+      for (let i = 0; i < filepaths.length; i++) {
+        stream2.write(i);
+      }
+      return stream2;
+    }
+    _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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/sync.esnext

@@ -0,0 +1,54 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync2.esnext';
+import { __require as requireOut } from '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import { __require as requireOut$1 } from '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext';
+import { __require as requireReader } from './reader.esnext';
+
+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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/settings.esnext

@@ -0,0 +1,67 @@
+import { __exports as settings } from '../../../../../../_virtual/settings.esnext';
+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;
+    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;
+        }
+        this.ignore = [].concat(this.ignore);
+      }
+      _getValue(option, value) {
+        return option === void 0 ? 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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/array.esnext

@@ -0,0 +1,30 @@
+import { __exports as array } from '../../../../../../../_virtual/array.esnext';
+
+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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/errno.esnext

@@ -0,0 +1,16 @@
+import { __exports as errno } from '../../../../../../../_virtual/errno.esnext';
+
+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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/fs.esnext

@@ -0,0 +1,28 @@
+import { __exports as fs } from '../../../../../../../_virtual/fs.esnext';
+
+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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/index.esnext

@@ -0,0 +1,33 @@
+import { __exports as utils } from '../../../../../../../_virtual/index7.esnext';
+import { __require as requireArray } from './array.esnext';
+import { __require as requireErrno } from './errno.esnext';
+import { __require as requireFs } from './fs.esnext';
+import { __require as requirePath } from './path.esnext';
+import { __require as requirePattern } from './pattern.esnext';
+import { __require as requireStream } from './stream.esnext';
+import { __require as requireString } from './string.esnext';
+
+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 };

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

@@ -0,0 +1,58 @@
+import { __exports as path } from '../../../../../../../_virtual/path.esnext';
+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;
+  const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+  const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
+  const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
+  const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
+  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) {
+    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/esnext/node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/utils/pattern.esnext

@@ -0,0 +1,171 @@
+import { __exports as pattern } from '../../../../../../../_virtual/pattern.esnext';
+import path__default from 'node:path';
+import { __require as requireGlobParent } from '../../../../../glob-parent@5.1.2/node_modules/glob-parent/index.esnext';
+import { __require as requireMicromatch } from '../../../../../micromatch@4.0.8/node_modules/micromatch/index.esnext';
+
+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 = /,|\.\./;
+  const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+  function isStaticPattern(pattern2, options = {}) {
+    return !isDynamicPattern(pattern2, options);
+  }
+  pattern.isStaticPattern = isStaticPattern;
+  function isDynamicPattern(pattern2, options = {}) {
+    if (pattern2 === "") {
+      return false;
+    }
+    if (options.caseSensitiveMatch === false || pattern2.includes(ESCAPE_SYMBOL)) {
+      return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern2) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern2) || REGEX_GROUP_SYMBOLS_RE.test(pattern2)) {
+      return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern2)) {
+      return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern2)) {
+      return true;
+    }
+    return false;
+  }
+  pattern.isDynamicPattern = isDynamicPattern;
+  function hasBraceExpansion(pattern2) {
+    const openingBraceIndex = pattern2.indexOf("{");
+    if (openingBraceIndex === -1) {
+      return false;
+    }
+    const closingBraceIndex = pattern2.indexOf("}", openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+      return false;
+    }
+    const braceContent = pattern2.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+  }
+  function convertToPositivePattern(pattern2) {
+    return isNegativePattern(pattern2) ? pattern2.slice(1) : pattern2;
+  }
+  pattern.convertToPositivePattern = convertToPositivePattern;
+  function convertToNegativePattern(pattern2) {
+    return "!" + pattern2;
+  }
+  pattern.convertToNegativePattern = convertToNegativePattern;
+  function isNegativePattern(pattern2) {
+    return pattern2.startsWith("!") && pattern2[1] !== "(";
+  }
+  pattern.isNegativePattern = isNegativePattern;
+  function isPositivePattern(pattern2) {
+    return !isNegativePattern(pattern2);
+  }
+  pattern.isPositivePattern = isPositivePattern;
+  function getNegativePatterns(patterns) {
+    return patterns.filter(isNegativePattern);
+  }
+  pattern.getNegativePatterns = getNegativePatterns;
+  function getPositivePatterns(patterns) {
+    return patterns.filter(isPositivePattern);
+  }
+  pattern.getPositivePatterns = getPositivePatterns;
+  function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern2) => !isPatternRelatedToParentDirectory(pattern2));
+  }
+  pattern.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+  function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter(isPatternRelatedToParentDirectory);
+  }
+  pattern.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+  function isPatternRelatedToParentDirectory(pattern2) {
+    return pattern2.startsWith("..") || pattern2.startsWith("./..");
+  }
+  pattern.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+  function getBaseDirectory(pattern2) {
+    return globParent(pattern2, { flipBackslashes: false });
+  }
+  pattern.getBaseDirectory = getBaseDirectory;
+  function hasGlobStar(pattern2) {
+    return pattern2.includes(GLOBSTAR);
+  }
+  pattern.hasGlobStar = hasGlobStar;
+  function endsWithSlashGlobStar(pattern2) {
+    return pattern2.endsWith("/" + GLOBSTAR);
+  }
+  pattern.endsWithSlashGlobStar = endsWithSlashGlobStar;
+  function isAffectDepthOfReadingPattern(pattern2) {
+    const basename = path.basename(pattern2);
+    return endsWithSlashGlobStar(pattern2) || isStaticPattern(basename);
+  }
+  pattern.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+  function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern2) => {
+      return collection.concat(expandBraceExpansion(pattern2));
+    }, []);
+  }
+  pattern.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+  function expandBraceExpansion(pattern2) {
+    const patterns = micromatch.braces(pattern2, { expand: true, nodupes: true, keepEscaping: true });
+    patterns.sort((a, b) => a.length - b.length);
+    return patterns.filter((pattern3) => pattern3 !== "");
+  }
+  pattern.expandBraceExpansion = expandBraceExpansion;
+  function getPatternParts(pattern2, options) {
+    let { parts } = micromatch.scan(pattern2, Object.assign(Object.assign({}, options), { parts: true }));
+    if (parts.length === 0) {
+      parts = [pattern2];
+    }
+    if (parts[0].startsWith("/")) {
+      parts[0] = parts[0].slice(1);
+      parts.unshift("");
+    }
+    return parts;
+  }
+  pattern.getPatternParts = getPatternParts;
+  function makeRe(pattern2, options) {
+    return micromatch.makeRe(pattern2, options);
+  }
+  pattern.makeRe = makeRe;
+  function convertPatternsToRe(patterns, options) {
+    return patterns.map((pattern2) => makeRe(pattern2, options));
+  }
+  pattern.convertPatternsToRe = convertPatternsToRe;
+  function matchAny(entry, patternsRe) {
+    return patternsRe.some((patternRe) => patternRe.test(entry));
+  }
+  pattern.matchAny = matchAny;
+  function removeDuplicateSlashes(pattern2) {
+    return pattern2.replace(DOUBLE_SLASH_RE, "/");
+  }
+  pattern.removeDuplicateSlashes = removeDuplicateSlashes;
+  function partitionAbsoluteAndRelative(patterns) {
+    const absolute = [];
+    const relative = [];
+    for (const pattern2 of patterns) {
+      if (isAbsolute(pattern2)) {
+        absolute.push(pattern2);
+      } else {
+        relative.push(pattern2);
+      }
+    }
+    return [absolute, relative];
+  }
+  pattern.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
+  function isAbsolute(pattern2) {
+    return path.isAbsolute(pattern2);
+  }
+  pattern.isAbsolute = isAbsolute;
+  return pattern;
+}
+
+export { requirePattern as __require };

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

@@ -0,0 +1,27 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream3.esnext';
+import { __require as requireMerge2 } from '../../../../../merge2@1.4.1/node_modules/merge2/index.esnext';
+
+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((stream2) => {
+      stream2.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((stream2) => stream2.emit("close"));
+  }
+  return stream;
+}
+
+export { requireStream as __require };

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

@@ -0,0 +1,20 @@
+import { __exports as string } from '../../../../../../../_virtual/string.esnext';
+
+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 };