@quilted/create 0.2.42 → 0.2.44

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

@@ -1,55 +1,62 @@
 import { __exports as matcher } from '../../../../../../../../_virtual/matcher.mjs';
-import '../../utils/index.mjs';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.mjs';
+import { __require as requireUtils } from '../../utils/index.mjs';
 
-Object.defineProperty(matcher, "__esModule", {
-  value: true
-});
-const utils = utils$1;
-class Matcher {
-  constructor(_patterns, _settings, _micromatchOptions) {
-    this._patterns = _patterns;
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-    this._storage = [];
-    this._fillStorage();
-  }
-  _fillStorage() {
-    /**
-     * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
-     * So, before expand patterns with brace expansion into separated patterns.
-     */
-    const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
-    for (const pattern of patterns) {
-      const segments = this._getPatternSegments(pattern);
-      const sections = this._splitSegmentsIntoSections(segments);
-      this._storage.push({
-        complete: sections.length <= 1,
-        pattern,
-        segments,
-        sections
-      });
+var hasRequiredMatcher;
+function requireMatcher() {
+  if (hasRequiredMatcher) return matcher;
+  hasRequiredMatcher = 1;
+  Object.defineProperty(matcher, "__esModule", {
+    value: true
+  });
+  const utils = requireUtils();
+  class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+      this._patterns = _patterns;
+      this._settings = _settings;
+      this._micromatchOptions = _micromatchOptions;
+      this._storage = [];
+      this._fillStorage();
     }
-  }
-  _getPatternSegments(pattern) {
-    const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
-    return parts.map(part => {
-      const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
-      if (!dynamic) {
+    _fillStorage() {
+      /**
+       * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
+       * So, before expand patterns with brace expansion into separated patterns.
+       */
+      const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
+      for (const pattern of patterns) {
+        const segments = this._getPatternSegments(pattern);
+        const sections = this._splitSegmentsIntoSections(segments);
+        this._storage.push({
+          complete: sections.length <= 1,
+          pattern,
+          segments,
+          sections
+        });
+      }
+    }
+    _getPatternSegments(pattern) {
+      const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+      return parts.map(part => {
+        const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+        if (!dynamic) {
+          return {
+            dynamic: false,
+            pattern: part
+          };
+        }
         return {
-          dynamic: false,
-          pattern: part
+          dynamic: true,
+          pattern: part,
+          patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
         };
-      }
-      return {
-        dynamic: true,
-        pattern: part,
-        patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
-      };
-    });
-  }
-  _splitSegmentsIntoSections(segments) {
-    return utils.array.splitWhen(segments, segment => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+      });
+    }
+    _splitSegmentsIntoSections(segments) {
+      return utils.array.splitWhen(segments, segment => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+    }
   }
+  matcher.default = Matcher;
+  return matcher;
 }
-matcher.default = Matcher;
+
+export { requireMatcher as __require };

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

@@ -1,43 +1,50 @@
 import { __exports as partial } from '../../../../../../../../_virtual/partial.mjs';
-import './matcher.mjs';
-import { __exports as matcher } from '../../../../../../../../_virtual/matcher.mjs';
+import { __require as requireMatcher } from './matcher.mjs';
 
-Object.defineProperty(partial, "__esModule", {
-  value: true
-});
-const matcher_1 = matcher;
-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)) {
+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;
         }
-        if (!segment.dynamic && segment.pattern === part) {
+        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;
-      });
-      if (match) {
-        return true;
       }
+      return false;
     }
-    return false;
   }
+  partial.default = PartialMatcher;
+  return partial;
 }
-partial.default = PartialMatcher;
+
+export { requirePartial as __require };

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

@@ -1,60 +1,64 @@
 import { __exports as provider } from '../../../../../../../_virtual/provider.mjs';
 import path__default from 'node:path';
-import './filters/deep.mjs';
-import './filters/entry.mjs';
-import './filters/error.mjs';
-import './transformers/entry.mjs';
-import { __exports as deep } from '../../../../../../../_virtual/deep.mjs';
-import { __exports as entry } from '../../../../../../../_virtual/entry.mjs';
-import { __exports as error } from '../../../../../../../_virtual/error.mjs';
-import { __exports as entry$1 } from '../../../../../../../_virtual/entry2.mjs';
+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';
 
-Object.defineProperty(provider, "__esModule", {
-  value: true
-});
-const path = path__default;
-const deep_1 = deep;
-const entry_1 = entry;
-const error_1 = error;
-const entry_2 = entry$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
-    };
+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;
 }
-provider.default = Provider;
+
+export { requireProvider as __require };

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

@@ -1,38 +1,44 @@
 import { __exports as stream } from '../../../../../../../_virtual/stream.mjs';
 import require$$0 from 'node:stream';
-import '../readers/stream.mjs';
-import './provider.mjs';
-import { __exports as stream$1 } from '../../../../../../../_virtual/stream2.mjs';
-import { __exports as provider } from '../../../../../../../_virtual/provider.mjs';
+import { __require as requireStream$1 } from '../readers/stream.mjs';
+import { __require as requireProvider } from './provider.mjs';
 
-Object.defineProperty(stream, "__esModule", {
-  value: true
-});
-const stream_1 = require$$0;
-const stream_2 = stream$1;
-const provider_1 = provider;
-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);
+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);
     }
-    return this._reader.static(task.patterns, options);
   }
+  stream.default = ProviderStream;
+  return stream;
 }
-stream.default = ProviderStream;
+
+export { requireStream as __require };

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

@@ -1,30 +1,36 @@
 import { __exports as sync } from '../../../../../../../_virtual/sync.mjs';
-import '../readers/sync.mjs';
-import './provider.mjs';
-import { __exports as sync$1 } from '../../../../../../../_virtual/sync2.mjs';
-import { __exports as provider } from '../../../../../../../_virtual/provider.mjs';
+import { __require as requireSync$1 } from '../readers/sync.mjs';
+import { __require as requireProvider } from './provider.mjs';
 
-Object.defineProperty(sync, "__esModule", {
-  value: true
-});
-const sync_1 = sync$1;
-const provider_1 = provider;
-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);
+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);
     }
-    return this._reader.static(task.patterns, options);
   }
+  sync.default = ProviderSync;
+  return sync;
 }
-sync.default = ProviderSync;
+
+export { requireSync as __require };

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

@@ -1,33 +1,40 @@
 import { __exports as entry } from '../../../../../../../../_virtual/entry2.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 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);
+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;
     }
-    if (this._settings.markDirectories && entry.dirent.isDirectory()) {
-      filepath += '/';
+    getTransformer() {
+      return entry => this._transform(entry);
     }
-    if (!this._settings.objectMode) {
-      return filepath;
+    _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
+      });
     }
-    return Object.assign(Object.assign({}, entry), {
-      path: filepath
-    });
   }
+  entry.default = EntryTransformer;
+  return entry;
 }
-entry.default = EntryTransformer;
+
+export { requireEntry as __require };

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

@@ -1,43 +1,48 @@
 import { __exports as async } from '../../../../../../../_virtual/async2.mjs';
-import '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.mjs';
-import './reader.mjs';
-import './stream.mjs';
-import { __exports as out } from '../../../../../../../_virtual/index4.mjs';
-import { __exports as reader } from '../../../../../../../_virtual/reader.mjs';
-import { __exports as stream } from '../../../../../../../_virtual/stream2.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';
 
-Object.defineProperty(async, "__esModule", {
-  value: true
-});
-const fsWalk = out;
-const reader_1 = reader;
-const stream_1 = stream;
-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);
-        }
+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 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;
 }
-async.default = ReaderAsync;
+
+export { requireAsync as __require };