@quilted/create 0.2.43 → 0.2.44

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

@@ -1,12 +1,10 @@
 var splitStringTransformer = function splitStringTransformer2(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/esnext/node_modules/.pnpm/dir-glob@3.0.1/node_modules/dir-glob/index.esnext

@@ -1,66 +1,68 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.esnext';
-import { __module as dirGlob$1 } from '../../../../../_virtual/index2.esnext';
+import { __module as dirGlob } from '../../../../../_virtual/index8.esnext';
 import path__default from 'node:path';
-import '../../../path-type@4.0.0/node_modules/path-type/index.esnext';
-import { __exports as pathType$1 } from '../../../../../_virtual/index3.esnext';
+import { __require as requirePathType } from '../../../path-type@4.0.0/node_modules/path-type/index.esnext';
 
-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);
   };
-  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);
-};
-dirGlob$1.exports.sync = (input, options) => {
-  options = {
-    cwd: process.cwd(),
-    ...options
+  const addExtensions = (file, extensions) => {
+    if (path.extname(file)) {
+      return `**/${file}`;
+    }
+    return `**/${file}.${getExtensions(extensions)}`;
   };
-  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);
-};
-var dirGlobExports = dirGlob$1.exports;
-const dirGlob = /* @__PURE__ */ getDefaultExportFromCjs(dirGlobExports);
+  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);
+  };
+  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);
+  };
+  return dirGlob.exports;
+}
 
-export { dirGlob as default };
+export { requireDirGlob as __require };

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

@@ -1,79 +1,77 @@
-import { getDefaultExportFromCjs } from '../../../../../../_virtual/_commonjsHelpers.esnext';
-import './managers/tasks.esnext';
-import './managers/patterns.esnext';
-import './providers/async.esnext';
-import './providers/stream.esnext';
-import './providers/sync.esnext';
-import './settings.esnext';
-import './utils/index.esnext';
-import { __exports as tasks } from '../../../../../../_virtual/tasks.esnext';
-import { __exports as patterns } from '../../../../../../_virtual/patterns.esnext';
-import { __exports as async } from '../../../../../../_virtual/async.esnext';
-import { __exports as stream } from '../../../../../../_virtual/stream.esnext';
-import { __exports as sync } from '../../../../../../_virtual/sync.esnext';
-import { __exports as settings } from '../../../../../../_virtual/settings.esnext';
-import { __exports as utils$1 } from '../../../../../../_virtual/index.esnext';
+import { __require as requireTasks } from './managers/tasks.esnext';
+import { __require as requirePatterns } from './managers/patterns.esnext';
+import { __require as requireAsync } from './providers/async.esnext';
+import { __require as requireStream } from './providers/stream.esnext';
+import { __require as requireSync } from './providers/sync.esnext';
+import { __require as requireSettings } from './settings.esnext';
+import { __require as requireUtils } from './utils/index.esnext';
 
-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);
-}
-(function(FastGlob2) {
-  function sync(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, sync_1.default, options);
-    return utils.array.flatten(works);
-  }
-  FastGlob2.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);
-    return utils.stream.merge(works);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
   }
-  FastGlob2.stream = stream;
-  function generateTasks(source, options) {
-    assertPatternsInput(source);
+  (function(FastGlob2) {
+    function sync(source, options) {
+      assertPatternsInput(source);
+      const works = getWorks(source, sync_1.default, options);
+      return utils.array.flatten(works);
+    }
+    FastGlob2.sync = sync;
+    function stream(source, options) {
+      assertPatternsInput(source);
+      const works = getWorks(source, stream_1.default, options);
+      return utils.stream.merge(works);
+    }
+    FastGlob2.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);
+    }
+    FastGlob2.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+      assertPatternsInput(source);
+      const settings = new settings_1.default(options);
+      return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob2.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+      assertPatternsInput(source);
+      return utils.path.escape(source);
+    }
+    FastGlob2.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);
-  }
-  FastGlob2.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);
   }
-  FastGlob2.isDynamicPattern = isDynamicPattern;
-  function escapePath(source) {
-    assertPatternsInput(source);
-    return utils.path.escape(source);
-  }
-  FastGlob2.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/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/patterns.esnext

@@ -1,15 +1,21 @@
 import { __exports as patterns } from '../../../../../../../_virtual/patterns.esnext';
 
-Object.defineProperty(patterns, "__esModule", { value: true });
-patterns.removeDuplicateSlashes = patterns.transform = void 0;
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns2) {
-  return patterns2.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;
+  const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+  function transform(patterns2) {
+    return patterns2.map((pattern) => removeDuplicateSlashes(pattern));
+  }
+  patterns.transform = transform;
+  function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE, "/");
+  }
+  patterns.removeDuplicateSlashes = removeDuplicateSlashes;
+  return patterns;
 }
-patterns.transform = transform;
-function removeDuplicateSlashes(pattern) {
-  return pattern.replace(DOUBLE_SLASH_RE, "/");
-}
-patterns.removeDuplicateSlashes = removeDuplicateSlashes;
 
-export { patterns as default };
+export { requirePatterns as __require };

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

@@ -1,83 +1,88 @@
 import { __exports as tasks } from '../../../../../../../_virtual/tasks.esnext';
-import '../utils/index.esnext';
-import { __exports as utils$1 } from '../../../../../../../_virtual/index.esnext';
+import { __require as requireUtils } from '../utils/index.esnext';
 
-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;
-function convertPatternsToTasks(positive, negative, dynamic) {
-  const tasks2 = [];
-  const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
-  const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
-  const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-  const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-  tasks2.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-  if ("." in insideCurrentDirectoryGroup) {
-    tasks2.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
-  } else {
-    tasks2.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 tasks2;
-}
-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;
+  function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks2 = [];
+    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks2.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    if ("." in insideCurrentDirectoryGroup) {
+      tasks2.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
     } else {
-      collection[base] = [pattern];
+      tasks2.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 tasks2;
+  }
+  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/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/async.esnext

@@ -1,28 +1,34 @@
 import { __exports as async } from '../../../../../../../_virtual/async.esnext';
-import '../readers/async.esnext';
-import './provider.esnext';
-import { __exports as async$1 } from '../../../../../../../_virtual/async2.esnext';
-import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+import { __require as requireAsync$1 } from '../readers/async.esnext';
+import { __require as requireProvider } from './provider.esnext';
 
-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 };