@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.esnext

@@ -0,0 +1,243 @@
+import { __require as requireStringify } from './stringify.esnext';
+import { __require as requireConstants } from './constants.esnext';
+
+var parse_1;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse_1;
+  hasRequiredParse = 1;
+  const stringify = requireStringify();
+  const {
+    MAX_LENGTH,
+    CHAR_BACKSLASH,
+    /* \ */
+    CHAR_BACKTICK,
+    /* ` */
+    CHAR_COMMA,
+    /* , */
+    CHAR_DOT,
+    /* . */
+    CHAR_LEFT_PARENTHESES,
+    /* ( */
+    CHAR_RIGHT_PARENTHESES,
+    /* ) */
+    CHAR_LEFT_CURLY_BRACE,
+    /* { */
+    CHAR_RIGHT_CURLY_BRACE,
+    /* } */
+    CHAR_LEFT_SQUARE_BRACKET,
+    /* [ */
+    CHAR_RIGHT_SQUARE_BRACKET,
+    /* ] */
+    CHAR_DOUBLE_QUOTE,
+    /* " */
+    CHAR_SINGLE_QUOTE,
+    /* ' */
+    CHAR_NO_BREAK_SPACE,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE
+  } = requireConstants();
+  const parse = (input, options = {}) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected a string");
+    }
+    const opts = options || {};
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    if (input.length > max) {
+      throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+    }
+    const ast = { type: "root", input, nodes: [] };
+    const stack = [ast];
+    let block = ast;
+    let prev = ast;
+    let brackets = 0;
+    const length = input.length;
+    let index = 0;
+    let depth = 0;
+    let value;
+    const advance = () => input[index++];
+    const push = (node) => {
+      if (node.type === "text" && prev.type === "dot") {
+        prev.type = "text";
+      }
+      if (prev && prev.type === "text" && node.type === "text") {
+        prev.value += node.value;
+        return;
+      }
+      block.nodes.push(node);
+      node.parent = block;
+      node.prev = prev;
+      prev = node;
+      return node;
+    };
+    push({ type: "bos" });
+    while (index < length) {
+      block = stack[stack.length - 1];
+      value = advance();
+      if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+        continue;
+      }
+      if (value === CHAR_BACKSLASH) {
+        push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
+        continue;
+      }
+      if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+        push({ type: "text", value: "\\" + value });
+        continue;
+      }
+      if (value === CHAR_LEFT_SQUARE_BRACKET) {
+        brackets++;
+        let next;
+        while (index < length && (next = advance())) {
+          value += next;
+          if (next === CHAR_LEFT_SQUARE_BRACKET) {
+            brackets++;
+            continue;
+          }
+          if (next === CHAR_BACKSLASH) {
+            value += advance();
+            continue;
+          }
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            brackets--;
+            if (brackets === 0) {
+              break;
+            }
+          }
+        }
+        push({ type: "text", value });
+        continue;
+      }
+      if (value === CHAR_LEFT_PARENTHESES) {
+        block = push({ type: "paren", nodes: [] });
+        stack.push(block);
+        push({ type: "text", value });
+        continue;
+      }
+      if (value === CHAR_RIGHT_PARENTHESES) {
+        if (block.type !== "paren") {
+          push({ type: "text", value });
+          continue;
+        }
+        block = stack.pop();
+        push({ type: "text", value });
+        block = stack[stack.length - 1];
+        continue;
+      }
+      if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+        const open = value;
+        let next;
+        if (options.keepQuotes !== true) {
+          value = "";
+        }
+        while (index < length && (next = advance())) {
+          if (next === CHAR_BACKSLASH) {
+            value += next + advance();
+            continue;
+          }
+          if (next === open) {
+            if (options.keepQuotes === true) value += next;
+            break;
+          }
+          value += next;
+        }
+        push({ type: "text", value });
+        continue;
+      }
+      if (value === CHAR_LEFT_CURLY_BRACE) {
+        depth++;
+        const dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
+        const brace = {
+          type: "brace",
+          open: true,
+          close: false,
+          dollar,
+          depth,
+          commas: 0,
+          ranges: 0,
+          nodes: []
+        };
+        block = push(brace);
+        stack.push(block);
+        push({ type: "open", value });
+        continue;
+      }
+      if (value === CHAR_RIGHT_CURLY_BRACE) {
+        if (block.type !== "brace") {
+          push({ type: "text", value });
+          continue;
+        }
+        const type = "close";
+        block = stack.pop();
+        block.close = true;
+        push({ type, value });
+        depth--;
+        block = stack[stack.length - 1];
+        continue;
+      }
+      if (value === CHAR_COMMA && depth > 0) {
+        if (block.ranges > 0) {
+          block.ranges = 0;
+          const open = block.nodes.shift();
+          block.nodes = [open, { type: "text", value: stringify(block) }];
+        }
+        push({ type: "comma", value });
+        block.commas++;
+        continue;
+      }
+      if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+        const siblings = block.nodes;
+        if (depth === 0 || siblings.length === 0) {
+          push({ type: "text", value });
+          continue;
+        }
+        if (prev.type === "dot") {
+          block.range = [];
+          prev.value += value;
+          prev.type = "range";
+          if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+            block.invalid = true;
+            block.ranges = 0;
+            prev.type = "text";
+            continue;
+          }
+          block.ranges++;
+          block.args = [];
+          continue;
+        }
+        if (prev.type === "range") {
+          siblings.pop();
+          const before = siblings[siblings.length - 1];
+          before.value += prev.value + value;
+          prev = before;
+          block.ranges--;
+          continue;
+        }
+        push({ type: "dot", value });
+        continue;
+      }
+      push({ type: "text", value });
+    }
+    do {
+      block = stack.pop();
+      if (block.type !== "root") {
+        block.nodes.forEach((node) => {
+          if (!node.nodes) {
+            if (node.type === "open") node.isOpen = true;
+            if (node.type === "close") node.isClose = true;
+            if (!node.nodes) node.type = "text";
+            node.invalid = true;
+          }
+        });
+        const parent = stack[stack.length - 1];
+        const index2 = parent.nodes.indexOf(block);
+        parent.nodes.splice(index2, 1, ...block.nodes);
+      }
+    } while (stack.length > 0);
+    push({ type: "eos" });
+    return ast;
+  };
+  parse_1 = parse;
+  return parse_1;
+}
+
+export { requireParse as __require };

package/build/esnext/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.esnext

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

package/build/esnext/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.esnext

@@ -0,0 +1,87 @@
+import { __exports as utils } from '../../../../../../_virtual/utils2.esnext';
+
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (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;
+    };
+    exports.find = (node, type) => node.nodes.find((node2) => node2.type === 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;
+    };
+    exports.escapeNode = (block, n = 0, type) => {
+      const 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;
+        }
+      }
+    };
+    exports.encloseBrace = (node) => {
+      if (node.type !== "brace") return false;
+      if (node.commas >> 0 + node.ranges >> 0 === 0) {
+        node.invalid = true;
+        return true;
+      }
+      return false;
+    };
+    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;
+    };
+    exports.isOpenOrClose = (node) => {
+      if (node.type === "open" || node.type === "close") {
+        return true;
+      }
+      return node.open === true || node.close === true;
+    };
+    exports.reduce = (nodes) => nodes.reduce((acc, node) => {
+      if (node.type === "text") acc.push(node.value);
+      if (node.type === "range") node.type = "text";
+      return acc;
+    }, []);
+    exports.flatten = (...args) => {
+      const result = [];
+      const flat = (arr) => {
+        for (let i = 0; i < arr.length; i++) {
+          const ele = arr[i];
+          if (Array.isArray(ele)) {
+            flat(ele);
+            continue;
+          }
+          if (ele !== void 0) {
+            result.push(ele);
+          }
+        }
+        return result;
+      };
+      flat(args);
+      return result;
+    };
+  })(utils);
+  return utils;
+}
+
+export { requireUtils as __require };

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.3.3/node_modules/fast-glob/out/index.esnext

@@ -0,0 +1,108 @@
+import { __require as requireTasks } from './managers/tasks.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';
+
+var out;
+var hasRequiredOut;
+function requireOut() {
+  if (hasRequiredOut) return out;
+  hasRequiredOut = 1;
+  const taskManager = requireTasks();
+  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, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
+  }
+  (function(FastGlob2) {
+    FastGlob2.glob = FastGlob2;
+    FastGlob2.globSync = sync;
+    FastGlob2.globStream = stream;
+    FastGlob2.async = 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 = [].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;
+    function convertPathToPattern(source) {
+      assertPatternsInput(source);
+      return utils.path.convertPathToPattern(source);
+    }
+    FastGlob2.convertPathToPattern = convertPathToPattern;
+    (function(posix2) {
+      function escapePath2(source) {
+        assertPatternsInput(source);
+        return utils.path.escapePosixPath(source);
+      }
+      posix2.escapePath = escapePath2;
+      function convertPathToPattern2(source) {
+        assertPatternsInput(source);
+        return utils.path.convertPosixPathToPattern(source);
+      }
+      posix2.convertPathToPattern = convertPathToPattern2;
+    })(FastGlob2.posix || (FastGlob2.posix = {}));
+    (function(win322) {
+      function escapePath2(source) {
+        assertPatternsInput(source);
+        return utils.path.escapeWindowsPath(source);
+      }
+      win322.escapePath = escapePath2;
+      function convertPathToPattern2(source) {
+        assertPatternsInput(source);
+        return utils.path.convertWindowsPathToPattern(source);
+      }
+      win322.convertPathToPattern = convertPathToPattern2;
+    })(FastGlob2.win32 || (FastGlob2.win32 = {}));
+  })(FastGlob || (FastGlob = {}));
+  function getWorks(source, _Provider, options) {
+    const patterns = [].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");
+    }
+  }
+  out = FastGlob;
+  return out;
+}
+
+export { requireOut as __require };