@quilted/create 0.2.43 → 0.2.44

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.mjs

@@ -1,29 +1,35 @@
-import './utils.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils2.mjs';
+import { __require as requireUtils } from './utils.mjs';
 
-const utils = utils$1;
-var stringify = (ast, options = {}) => {
-  let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let output = '';
-    if (node.value) {
-      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
-        return '\\' + node.value;
+var stringify;
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify;
+  hasRequiredStringify = 1;
+  const utils = requireUtils();
+  stringify = (ast, options = {}) => {
+    let stringify = (node, parent = {}) => {
+      let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+      let invalidNode = node.invalid === true && options.escapeInvalid === true;
+      let output = '';
+      if (node.value) {
+        if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+          return '\\' + node.value;
+        }
+        return node.value;
       }
-      return node.value;
-    }
-    if (node.value) {
-      return node.value;
-    }
-    if (node.nodes) {
-      for (let child of node.nodes) {
-        output += stringify(child);
+      if (node.value) {
+        return node.value;
       }
-    }
-    return output;
+      if (node.nodes) {
+        for (let child of node.nodes) {
+          output += stringify(child);
+        }
+      }
+      return output;
+    };
+    return stringify(ast);
   };
-  return stringify(ast);
-};
+  return stringify;
+}
 
-export { stringify };
+export { requireStringify as __require };

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.mjs

@@ -1,114 +1,122 @@
 import { __exports as utils } from '../../../../../../_virtual/utils2.mjs';
 
-(function (exports) {
-
-  exports.isInteger = num => {
-    if (typeof num === 'number') {
-      return Number.isInteger(num);
-    }
-    if (typeof num === 'string' && num.trim() !== '') {
-      return Number.isInteger(Number(num));
-    }
-    return false;
-  };
-
-  /**
-   * Find a node of the given type
-   */
-
-  exports.find = (node, type) => node.nodes.find(node => node.type === type);
-
-  /**
-   * Find a node of the given type
-   */
-
-  exports.exceedsLimit = (min, max, step = 1, limit) => {
-    if (limit === false) return false;
-    if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
-    return (Number(max) - Number(min)) / Number(step) >= limit;
-  };
-
-  /**
-   * Escape the given node with '\\' before node.value
-   */
-
-  exports.escapeNode = (block, n = 0, type) => {
-    let node = block.nodes[n];
-    if (!node) return;
-    if (type && node.type === type || node.type === 'open' || node.type === 'close') {
-      if (node.escaped !== true) {
-        node.value = '\\' + node.value;
-        node.escaped = true;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function (exports) {
+
+    exports.isInteger = num => {
+      if (typeof num === 'number') {
+        return Number.isInteger(num);
       }
-    }
-  };
-
-  /**
-   * Returns true if the given brace node should be enclosed in literal braces
-   */
-
-  exports.encloseBrace = node => {
-    if (node.type !== 'brace') return false;
-    if (node.commas >> 0 + node.ranges >> 0 === 0) {
-      node.invalid = true;
-      return true;
-    }
-    return false;
-  };
-
-  /**
-   * Returns true if a brace node is invalid.
-   */
-
-  exports.isInvalidBrace = block => {
-    if (block.type !== 'brace') return false;
-    if (block.invalid === true || block.dollar) return true;
-    if (block.commas >> 0 + block.ranges >> 0 === 0) {
-      block.invalid = true;
-      return true;
-    }
-    if (block.open !== true || block.close !== true) {
-      block.invalid = true;
-      return true;
-    }
-    return false;
-  };
-
-  /**
-   * Returns true if a node is an open or close node
-   */
-
-  exports.isOpenOrClose = node => {
-    if (node.type === 'open' || node.type === 'close') {
-      return true;
-    }
-    return node.open === true || node.close === true;
-  };
-
-  /**
-   * Reduce an array of text nodes.
-   */
-
-  exports.reduce = nodes => nodes.reduce((acc, node) => {
-    if (node.type === 'text') acc.push(node.value);
-    if (node.type === 'range') node.type = 'text';
-    return acc;
-  }, []);
-
-  /**
-   * Flatten an array
-   */
-
-  exports.flatten = (...args) => {
-    const result = [];
-    const flat = arr => {
-      for (let i = 0; i < arr.length; i++) {
-        let ele = arr[i];
-        Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+      if (typeof num === 'string' && num.trim() !== '') {
+        return Number.isInteger(Number(num));
       }
+      return false;
+    };
+
+    /**
+     * Find a node of the given type
+     */
+
+    exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+    /**
+     * Find a node of the given type
+     */
+
+    exports.exceedsLimit = (min, max, step = 1, limit) => {
+      if (limit === false) return false;
+      if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+      return (Number(max) - Number(min)) / Number(step) >= limit;
+    };
+
+    /**
+     * Escape the given node with '\\' before node.value
+     */
+
+    exports.escapeNode = (block, n = 0, type) => {
+      let node = block.nodes[n];
+      if (!node) return;
+      if (type && node.type === type || node.type === 'open' || node.type === 'close') {
+        if (node.escaped !== true) {
+          node.value = '\\' + node.value;
+          node.escaped = true;
+        }
+      }
+    };
+
+    /**
+     * Returns true if the given brace node should be enclosed in literal braces
+     */
+
+    exports.encloseBrace = node => {
+      if (node.type !== 'brace') return false;
+      if (node.commas >> 0 + node.ranges >> 0 === 0) {
+        node.invalid = true;
+        return true;
+      }
+      return false;
+    };
+
+    /**
+     * Returns true if a brace node is invalid.
+     */
+
+    exports.isInvalidBrace = block => {
+      if (block.type !== 'brace') return false;
+      if (block.invalid === true || block.dollar) return true;
+      if (block.commas >> 0 + block.ranges >> 0 === 0) {
+        block.invalid = true;
+        return true;
+      }
+      if (block.open !== true || block.close !== true) {
+        block.invalid = true;
+        return true;
+      }
+      return false;
+    };
+
+    /**
+     * Returns true if a node is an open or close node
+     */
+
+    exports.isOpenOrClose = node => {
+      if (node.type === 'open' || node.type === 'close') {
+        return true;
+      }
+      return node.open === true || node.close === true;
+    };
+
+    /**
+     * Reduce an array of text nodes.
+     */
+
+    exports.reduce = nodes => nodes.reduce((acc, node) => {
+      if (node.type === 'text') acc.push(node.value);
+      if (node.type === 'range') node.type = 'text';
+      return acc;
+    }, []);
+
+    /**
+     * Flatten an array
+     */
+
+    exports.flatten = (...args) => {
+      const result = [];
+      const flat = arr => {
+        for (let i = 0; i < arr.length; i++) {
+          let ele = arr[i];
+          Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
+        }
+        return result;
+      };
+      flat(args);
       return result;
     };
-    flat(args);
-    return result;
-  };
-})(utils);
+  })(utils);
+  return utils;
+}
+
+export { requireUtils as __require };

package/build/esm/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/splitStringTransformer/splitStringTransformer.mjs

@@ -1,12 +1,10 @@
 var splitStringTransformer = function splitStringTransformer(splitBy) {
   return {
     onSubstitution: function onSubstitution(substitution, resultSoFar) {
-      if (splitBy != null && typeof splitBy === 'string') {
+      {
         if (typeof substitution === 'string' && substitution.includes(splitBy)) {
           substitution = substitution.split(splitBy);
         }
-      } else {
-        throw new Error('You need to specify a string character to split by.');
       }
       return substitution;
     }

package/build/esm/node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.mjs

@@ -1,68 +1,70 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.mjs';
-import { __module as dirGlob$1 } from '../../../../../_virtual/index2.mjs';
+import { __module as dirGlob } from '../../../../../_virtual/index8.mjs';
 import path__default from 'node:path';
-import '../../../path-type@4.0.0/node_modules/path-type/index.mjs';
-import { __exports as pathType$1 } from '../../../../../_virtual/index3.mjs';
+import { __require as requirePathType } from '../../../path-type@4.0.0/node_modules/path-type/index.mjs';
 
-const path = path__default;
-const pathType = pathType$1;
-const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
-const getPath = (filepath, cwd) => {
-  const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
-  return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
-};
-const addExtensions = (file, extensions) => {
-  if (path.extname(file)) {
-    return `**/${file}`;
-  }
-  return `**/${file}.${getExtensions(extensions)}`;
-};
-const getGlob = (directory, options) => {
-  if (options.files && !Array.isArray(options.files)) {
-    throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
-  }
-  if (options.extensions && !Array.isArray(options.extensions)) {
-    throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
-  }
-  if (options.files && options.extensions) {
-    return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
-  }
-  if (options.files) {
-    return options.files.map(x => path.posix.join(directory, `**/${x}`));
-  }
-  if (options.extensions) {
-    return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
-  }
-  return [path.posix.join(directory, '**')];
-};
-dirGlob$1.exports = async (input, options) => {
-  options = {
-    cwd: process.cwd(),
-    ...options
+var hasRequiredDirGlob;
+function requireDirGlob() {
+  if (hasRequiredDirGlob) return dirGlob.exports;
+  hasRequiredDirGlob = 1;
+  const path = path__default;
+  const pathType = requirePathType();
+  const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
+  const getPath = (filepath, cwd) => {
+    const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
+    return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
+  };
+  const addExtensions = (file, extensions) => {
+    if (path.extname(file)) {
+      return `**/${file}`;
+    }
+    return `**/${file}.${getExtensions(extensions)}`;
+  };
+  const getGlob = (directory, options) => {
+    if (options.files && !Array.isArray(options.files)) {
+      throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+    }
+    if (options.extensions && !Array.isArray(options.extensions)) {
+      throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+    }
+    if (options.files && options.extensions) {
+      return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
+    }
+    if (options.files) {
+      return options.files.map(x => path.posix.join(directory, `**/${x}`));
+    }
+    if (options.extensions) {
+      return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+    }
+    return [path.posix.join(directory, '**')];
+  };
+  dirGlob.exports = async (input, options) => {
+    options = {
+      cwd: process.cwd(),
+      ...options
+    };
+    if (typeof options.cwd !== 'string') {
+      throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+    }
+    const globs = await Promise.all([].concat(input).map(async x => {
+      const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+      return isDirectory ? getGlob(x, options) : x;
+    }));
+    return [].concat.apply([], globs); // eslint-disable-line prefer-spread
   };
-  if (typeof options.cwd !== 'string') {
-    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-  }
-  const globs = await Promise.all([].concat(input).map(async x => {
-    const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
-    return isDirectory ? getGlob(x, options) : x;
-  }));
-  return [].concat.apply([], globs); // eslint-disable-line prefer-spread
-};
 
-dirGlob$1.exports.sync = (input, options) => {
-  options = {
-    cwd: process.cwd(),
-    ...options
+  dirGlob.exports.sync = (input, options) => {
+    options = {
+      cwd: process.cwd(),
+      ...options
+    };
+    if (typeof options.cwd !== 'string') {
+      throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+    }
+    const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+    return [].concat.apply([], globs); // eslint-disable-line prefer-spread
   };
-  if (typeof options.cwd !== 'string') {
-    throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
-  }
-  const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
-  return [].concat.apply([], globs); // eslint-disable-line prefer-spread
-};
 
-var dirGlobExports = dirGlob$1.exports;
-const dirGlob = /*@__PURE__*/getDefaultExportFromCjs(dirGlobExports);
+  return dirGlob.exports;
+}
 
-export { dirGlob as default };
+export { requireDirGlob as __require };

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

@@ -1,86 +1,84 @@
-import { getDefaultExportFromCjs } from '../../../../../../_virtual/_commonjsHelpers.mjs';
-import './managers/tasks.mjs';
-import './managers/patterns.mjs';
-import './providers/async.mjs';
-import './providers/stream.mjs';
-import './providers/sync.mjs';
-import './settings.mjs';
-import './utils/index.mjs';
-import { __exports as tasks } from '../../../../../../_virtual/tasks.mjs';
-import { __exports as patterns } from '../../../../../../_virtual/patterns.mjs';
-import { __exports as async } from '../../../../../../_virtual/async.mjs';
-import { __exports as stream } from '../../../../../../_virtual/stream.mjs';
-import { __exports as sync } from '../../../../../../_virtual/sync.mjs';
-import { __exports as settings } from '../../../../../../_virtual/settings.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/index.mjs';
+import { __require as requireTasks } from './managers/tasks.mjs';
+import { __require as requirePatterns } from './managers/patterns.mjs';
+import { __require as requireAsync } from './providers/async.mjs';
+import { __require as requireStream } from './providers/stream.mjs';
+import { __require as requireSync } from './providers/sync.mjs';
+import { __require as requireSettings } from './settings.mjs';
+import { __require as requireUtils } from './utils/index.mjs';
 
-const taskManager = tasks;
-const patternManager = patterns;
-const async_1 = async;
-const stream_1 = stream;
-const sync_1 = sync;
-const settings_1 = settings;
-const utils = utils$1;
-async function FastGlob(source, options) {
-  assertPatternsInput(source);
-  const works = getWorks(source, async_1.default, options);
-  const result = await Promise.all(works);
-  return utils.array.flatten(result);
-}
-// https://github.com/typescript-eslint/typescript-eslint/issues/60
-// eslint-disable-next-line no-redeclare
-(function (FastGlob) {
-  function sync(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, sync_1.default, options);
-    return utils.array.flatten(works);
-  }
-  FastGlob.sync = sync;
-  function stream(source, options) {
+var out;
+var hasRequiredOut;
+function requireOut() {
+  if (hasRequiredOut) return out;
+  hasRequiredOut = 1;
+  const taskManager = requireTasks();
+  const patternManager = requirePatterns();
+  const async_1 = requireAsync();
+  const stream_1 = requireStream();
+  const sync_1 = requireSync();
+  const settings_1 = requireSettings();
+  const utils = requireUtils();
+  async function FastGlob(source, options) {
     assertPatternsInput(source);
-    const works = getWorks(source, stream_1.default, options);
-    /**
-     * The stream returned by the provider cannot work with an asynchronous iterator.
-     * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-     * This affects performance (+25%). I don't see best solution right now.
-     */
-    return utils.stream.merge(works);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
   }
-  FastGlob.stream = stream;
-  function generateTasks(source, options) {
-    assertPatternsInput(source);
+  // https://github.com/typescript-eslint/typescript-eslint/issues/60
+  // eslint-disable-next-line no-redeclare
+  (function (FastGlob) {
+    function sync(source, options) {
+      assertPatternsInput(source);
+      const works = getWorks(source, sync_1.default, options);
+      return utils.array.flatten(works);
+    }
+    FastGlob.sync = sync;
+    function stream(source, options) {
+      assertPatternsInput(source);
+      const works = getWorks(source, stream_1.default, options);
+      /**
+       * The stream returned by the provider cannot work with an asynchronous iterator.
+       * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+       * This affects performance (+25%). I don't see best solution right now.
+       */
+      return utils.stream.merge(works);
+    }
+    FastGlob.stream = stream;
+    function generateTasks(source, options) {
+      assertPatternsInput(source);
+      const patterns = patternManager.transform([].concat(source));
+      const settings = new settings_1.default(options);
+      return taskManager.generate(patterns, settings);
+    }
+    FastGlob.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+      assertPatternsInput(source);
+      const settings = new settings_1.default(options);
+      return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+      assertPatternsInput(source);
+      return utils.path.escape(source);
+    }
+    FastGlob.escapePath = escapePath;
+  })(FastGlob || (FastGlob = {}));
+  function getWorks(source, _Provider, options) {
     const patterns = patternManager.transform([].concat(source));
     const settings = new settings_1.default(options);
-    return taskManager.generate(patterns, settings);
-  }
-  FastGlob.generateTasks = generateTasks;
-  function isDynamicPattern(source, options) {
-    assertPatternsInput(source);
-    const settings = new settings_1.default(options);
-    return utils.pattern.isDynamicPattern(source, settings);
+    const tasks = taskManager.generate(patterns, settings);
+    const provider = new _Provider(settings);
+    return tasks.map(provider.read, provider);
   }
-  FastGlob.isDynamicPattern = isDynamicPattern;
-  function escapePath(source) {
-    assertPatternsInput(source);
-    return utils.path.escape(source);
-  }
-  FastGlob.escapePath = escapePath;
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-  const patterns = patternManager.transform([].concat(source));
-  const settings = new settings_1.default(options);
-  const tasks = taskManager.generate(patterns, settings);
-  const provider = new _Provider(settings);
-  return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-  const source = [].concat(input);
-  const isValidSource = source.every(item => utils.string.isString(item) && !utils.string.isEmpty(item));
-  if (!isValidSource) {
-    throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+  function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every(item => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+      throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
   }
+  out = FastGlob;
+  return out;
 }
-var out = FastGlob;
-const fastGlob = /*@__PURE__*/getDefaultExportFromCjs(out);
 
-export { fastGlob as default };
+export { requireOut as __require };

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

@@ -1,26 +1,32 @@
 import { __exports as patterns } from '../../../../../../../_virtual/patterns.mjs';
 
-Object.defineProperty(patterns, "__esModule", {
-  value: true
-});
-patterns.removeDuplicateSlashes = patterns.transform = void 0;
-/**
- * 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.
- * @todo rewrite to negative lookbehind with the next major release.
- */
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns) {
-  return patterns.map(pattern => removeDuplicateSlashes(pattern));
+var hasRequiredPatterns;
+function requirePatterns() {
+  if (hasRequiredPatterns) return patterns;
+  hasRequiredPatterns = 1;
+  Object.defineProperty(patterns, "__esModule", {
+    value: true
+  });
+  patterns.removeDuplicateSlashes = patterns.transform = void 0;
+  /**
+   * 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.
+   * @todo rewrite to negative lookbehind with the next major release.
+   */
+  const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+  function transform(patterns) {
+    return patterns.map(pattern => removeDuplicateSlashes(pattern));
+  }
+  patterns.transform = transform;
+  /**
+   * 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, '/');
+  }
+  patterns.removeDuplicateSlashes = removeDuplicateSlashes;
+  return patterns;
 }
-patterns.transform = transform;
-/**
- * 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, '/');
-}
-patterns.removeDuplicateSlashes = removeDuplicateSlashes;
 
-export { patterns as default };
+export { requirePatterns as __require };