@quilted/create 0.2.43 → 0.2.45

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

@@ -1,144 +0,0 @@
-import { __exports as pattern } from '../../../../../../../_virtual/pattern.esnext';
-import path__default from 'node:path';
-import { g as globParent$1 } from '../../../../../glob-parent@5.1.2/node_modules/glob-parent/index.esnext';
-import { m as micromatch_1 } from '../../../../../micromatch@4.0.5/node_modules/micromatch/index.esnext';
-
-Object.defineProperty(pattern, "__esModule", { value: true });
-pattern.matchAny = pattern.convertPatternsToRe = pattern.makeRe = pattern.getPatternParts = pattern.expandBraceExpansion = pattern.expandPatternsWithBraceExpansion = pattern.isAffectDepthOfReadingPattern = pattern.endsWithSlashGlobStar = pattern.hasGlobStar = pattern.getBaseDirectory = pattern.isPatternRelatedToParentDirectory = pattern.getPatternsOutsideCurrentDirectory = pattern.getPatternsInsideCurrentDirectory = pattern.getPositivePatterns = pattern.getNegativePatterns = pattern.isPositivePattern = pattern.isNegativePattern = pattern.convertToNegativePattern = pattern.convertToPositivePattern = pattern.isDynamicPattern = pattern.isStaticPattern = void 0;
-const path = path__default;
-const globParent = globParent$1;
-const micromatch = micromatch_1;
-const GLOBSTAR = "**";
-const ESCAPE_SYMBOL = "\\";
-const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
-const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
-const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
-const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
-const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
-function isStaticPattern(pattern2, options = {}) {
-  return !isDynamicPattern(pattern2, options);
-}
-pattern.isStaticPattern = isStaticPattern;
-function isDynamicPattern(pattern2, options = {}) {
-  if (pattern2 === "") {
-    return false;
-  }
-  if (options.caseSensitiveMatch === false || pattern2.includes(ESCAPE_SYMBOL)) {
-    return true;
-  }
-  if (COMMON_GLOB_SYMBOLS_RE.test(pattern2) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern2) || REGEX_GROUP_SYMBOLS_RE.test(pattern2)) {
-    return true;
-  }
-  if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern2)) {
-    return true;
-  }
-  if (options.braceExpansion !== false && hasBraceExpansion(pattern2)) {
-    return true;
-  }
-  return false;
-}
-pattern.isDynamicPattern = isDynamicPattern;
-function hasBraceExpansion(pattern2) {
-  const openingBraceIndex = pattern2.indexOf("{");
-  if (openingBraceIndex === -1) {
-    return false;
-  }
-  const closingBraceIndex = pattern2.indexOf("}", openingBraceIndex + 1);
-  if (closingBraceIndex === -1) {
-    return false;
-  }
-  const braceContent = pattern2.slice(openingBraceIndex, closingBraceIndex);
-  return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
-}
-function convertToPositivePattern(pattern2) {
-  return isNegativePattern(pattern2) ? pattern2.slice(1) : pattern2;
-}
-pattern.convertToPositivePattern = convertToPositivePattern;
-function convertToNegativePattern(pattern2) {
-  return "!" + pattern2;
-}
-pattern.convertToNegativePattern = convertToNegativePattern;
-function isNegativePattern(pattern2) {
-  return pattern2.startsWith("!") && pattern2[1] !== "(";
-}
-pattern.isNegativePattern = isNegativePattern;
-function isPositivePattern(pattern2) {
-  return !isNegativePattern(pattern2);
-}
-pattern.isPositivePattern = isPositivePattern;
-function getNegativePatterns(patterns) {
-  return patterns.filter(isNegativePattern);
-}
-pattern.getNegativePatterns = getNegativePatterns;
-function getPositivePatterns(patterns) {
-  return patterns.filter(isPositivePattern);
-}
-pattern.getPositivePatterns = getPositivePatterns;
-function getPatternsInsideCurrentDirectory(patterns) {
-  return patterns.filter((pattern2) => !isPatternRelatedToParentDirectory(pattern2));
-}
-pattern.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
-function getPatternsOutsideCurrentDirectory(patterns) {
-  return patterns.filter(isPatternRelatedToParentDirectory);
-}
-pattern.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
-function isPatternRelatedToParentDirectory(pattern2) {
-  return pattern2.startsWith("..") || pattern2.startsWith("./..");
-}
-pattern.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
-function getBaseDirectory(pattern2) {
-  return globParent(pattern2, { flipBackslashes: false });
-}
-pattern.getBaseDirectory = getBaseDirectory;
-function hasGlobStar(pattern2) {
-  return pattern2.includes(GLOBSTAR);
-}
-pattern.hasGlobStar = hasGlobStar;
-function endsWithSlashGlobStar(pattern2) {
-  return pattern2.endsWith("/" + GLOBSTAR);
-}
-pattern.endsWithSlashGlobStar = endsWithSlashGlobStar;
-function isAffectDepthOfReadingPattern(pattern2) {
-  const basename = path.basename(pattern2);
-  return endsWithSlashGlobStar(pattern2) || isStaticPattern(basename);
-}
-pattern.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
-function expandPatternsWithBraceExpansion(patterns) {
-  return patterns.reduce((collection, pattern2) => {
-    return collection.concat(expandBraceExpansion(pattern2));
-  }, []);
-}
-pattern.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
-function expandBraceExpansion(pattern2) {
-  return micromatch.braces(pattern2, {
-    expand: true,
-    nodupes: true
-  });
-}
-pattern.expandBraceExpansion = expandBraceExpansion;
-function getPatternParts(pattern2, options) {
-  let { parts } = micromatch.scan(pattern2, Object.assign(Object.assign({}, options), { parts: true }));
-  if (parts.length === 0) {
-    parts = [pattern2];
-  }
-  if (parts[0].startsWith("/")) {
-    parts[0] = parts[0].slice(1);
-    parts.unshift("");
-  }
-  return parts;
-}
-pattern.getPatternParts = getPatternParts;
-function makeRe(pattern2, options) {
-  return micromatch.makeRe(pattern2, options);
-}
-pattern.makeRe = makeRe;
-function convertPatternsToRe(patterns, options) {
-  return patterns.map((pattern2) => makeRe(pattern2, options));
-}
-pattern.convertPatternsToRe = convertPatternsToRe;
-function matchAny(entry, patternsRe) {
-  return patternsRe.some((patternRe) => patternRe.test(entry));
-}
-pattern.matchAny = matchAny;
-
-export { pattern as default };

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

@@ -1,21 +0,0 @@
-import { __exports as stream } from '../../../../../../../_virtual/stream3.esnext';
-import { m as merge2_1 } from '../../../../../merge2@1.4.1/node_modules/merge2/index.esnext';
-
-Object.defineProperty(stream, "__esModule", { value: true });
-stream.merge = void 0;
-const merge2 = merge2_1;
-function merge(streams) {
-  const mergedStream = merge2(streams);
-  streams.forEach((stream2) => {
-    stream2.once("error", (error) => mergedStream.emit("error", error));
-  });
-  mergedStream.once("close", () => propagateCloseEventToSources(streams));
-  mergedStream.once("end", () => propagateCloseEventToSources(streams));
-  return mergedStream;
-}
-stream.merge = merge;
-function propagateCloseEventToSources(streams) {
-  streams.forEach((stream2) => stream2.emit("close"));
-}
-
-export { stream as default };

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

@@ -1,14 +0,0 @@
-import { __exports as string } from '../../../../../../../_virtual/string.esnext';
-
-Object.defineProperty(string, "__esModule", { value: true });
-string.isEmpty = string.isString = void 0;
-function isString(input) {
-  return typeof input === "string";
-}
-string.isString = isString;
-function isEmpty(input) {
-  return input === "";
-}
-string.isEmpty = isEmpty;
-
-export { string as default };

package/build/esnext/node_modules/.pnpm/fill-range@7.0.1/node_modules/fill-range/index.esnext

@@ -1,192 +0,0 @@
-import require$$0 from 'node:util';
-import { t as toRegexRange_1 } from '../../../to-regex-range@5.0.1/node_modules/to-regex-range/index.esnext';
-
-const util = require$$0;
-const toRegexRange = toRegexRange_1;
-const isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-const transform = (toNumber) => {
-  return (value) => toNumber === true ? Number(value) : String(value);
-};
-const isValidValue = (value) => {
-  return typeof value === "number" || typeof value === "string" && value !== "";
-};
-const isNumber = (num) => Number.isInteger(+num);
-const zeros = (input) => {
-  let value = `${input}`;
-  let index = -1;
-  if (value[0] === "-") value = value.slice(1);
-  if (value === "0") return false;
-  while (value[++index] === "0") ;
-  return index > 0;
-};
-const stringify = (start, end, options) => {
-  if (typeof start === "string" || typeof end === "string") {
-    return true;
-  }
-  return options.stringify === true;
-};
-const pad = (input, maxLength, toNumber) => {
-  if (maxLength > 0) {
-    let dash = input[0] === "-" ? "-" : "";
-    if (dash) input = input.slice(1);
-    input = dash + input.padStart(dash ? maxLength - 1 : maxLength, "0");
-  }
-  if (toNumber === false) {
-    return String(input);
-  }
-  return input;
-};
-const toMaxLen = (input, maxLength) => {
-  let negative = input[0] === "-" ? "-" : "";
-  if (negative) {
-    input = input.slice(1);
-    maxLength--;
-  }
-  while (input.length < maxLength) input = "0" + input;
-  return negative ? "-" + input : input;
-};
-const toSequence = (parts, options) => {
-  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  let prefix = options.capture ? "" : "?:";
-  let positives = "";
-  let negatives = "";
-  let result;
-  if (parts.positives.length) {
-    positives = parts.positives.join("|");
-  }
-  if (parts.negatives.length) {
-    negatives = `-(${prefix}${parts.negatives.join("|")})`;
-  }
-  if (positives && negatives) {
-    result = `${positives}|${negatives}`;
-  } else {
-    result = positives || negatives;
-  }
-  if (options.wrap) {
-    return `(${prefix}${result})`;
-  }
-  return result;
-};
-const toRange = (a, b, isNumbers, options) => {
-  if (isNumbers) {
-    return toRegexRange(a, b, { wrap: false, ...options });
-  }
-  let start = String.fromCharCode(a);
-  if (a === b) return start;
-  let stop = String.fromCharCode(b);
-  return `[${start}-${stop}]`;
-};
-const toRegex = (start, end, options) => {
-  if (Array.isArray(start)) {
-    let wrap = options.wrap === true;
-    let prefix = options.capture ? "" : "?:";
-    return wrap ? `(${prefix}${start.join("|")})` : start.join("|");
-  }
-  return toRegexRange(start, end, options);
-};
-const rangeError = (...args) => {
-  return new RangeError("Invalid range arguments: " + util.inspect(...args));
-};
-const invalidRange = (start, end, options) => {
-  if (options.strictRanges === true) throw rangeError([start, end]);
-  return [];
-};
-const invalidStep = (step, options) => {
-  if (options.strictRanges === true) {
-    throw new TypeError(`Expected step "${step}" to be a number`);
-  }
-  return [];
-};
-const fillNumbers = (start, end, step = 1, options = {}) => {
-  let a = Number(start);
-  let b = Number(end);
-  if (!Number.isInteger(a) || !Number.isInteger(b)) {
-    if (options.strictRanges === true) throw rangeError([start, end]);
-    return [];
-  }
-  if (a === 0) a = 0;
-  if (b === 0) b = 0;
-  let descending = a > b;
-  let startString = String(start);
-  let endString = String(end);
-  let stepString = String(step);
-  step = Math.max(Math.abs(step), 1);
-  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
-  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
-  let toNumber = padded === false && stringify(start, end, options) === false;
-  let format = options.transform || transform(toNumber);
-  if (options.toRegex && step === 1) {
-    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
-  }
-  let parts = { negatives: [], positives: [] };
-  let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
-  let range = [];
-  let index = 0;
-  while (descending ? a >= b : a <= b) {
-    if (options.toRegex === true && step > 1) {
-      push(a);
-    } else {
-      range.push(pad(format(a, index), maxLen, toNumber));
-    }
-    a = descending ? a - step : a + step;
-    index++;
-  }
-  if (options.toRegex === true) {
-    return step > 1 ? toSequence(parts, options) : toRegex(range, null, { wrap: false, ...options });
-  }
-  return range;
-};
-const fillLetters = (start, end, step = 1, options = {}) => {
-  if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) {
-    return invalidRange(start, end, options);
-  }
-  let format = options.transform || ((val) => String.fromCharCode(val));
-  let a = `${start}`.charCodeAt(0);
-  let b = `${end}`.charCodeAt(0);
-  let descending = a > b;
-  let min = Math.min(a, b);
-  let max = Math.max(a, b);
-  if (options.toRegex && step === 1) {
-    return toRange(min, max, false, options);
-  }
-  let range = [];
-  let index = 0;
-  while (descending ? a >= b : a <= b) {
-    range.push(format(a, index));
-    a = descending ? a - step : a + step;
-    index++;
-  }
-  if (options.toRegex === true) {
-    return toRegex(range, null, { wrap: false, options });
-  }
-  return range;
-};
-const fill = (start, end, step, options = {}) => {
-  if (end == null && isValidValue(start)) {
-    return [start];
-  }
-  if (!isValidValue(start) || !isValidValue(end)) {
-    return invalidRange(start, end, options);
-  }
-  if (typeof step === "function") {
-    return fill(start, end, 1, { transform: step });
-  }
-  if (isObject(step)) {
-    return fill(start, end, 0, step);
-  }
-  let opts = { ...options };
-  if (opts.capture === true) opts.wrap = true;
-  step = step || opts.step || 1;
-  if (!isNumber(step)) {
-    if (step != null && !isObject(step)) return invalidStep(step, opts);
-    return fill(start, end, 1, step);
-  }
-  if (isNumber(start) && isNumber(end)) {
-    return fillNumbers(start, end, step, opts);
-  }
-  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
-};
-var fillRange = fill;
-
-export { fillRange as f };

package/build/esnext/node_modules/.pnpm/micromatch@4.0.5/node_modules/micromatch/index.esnext

@@ -1,157 +0,0 @@
-import require$$0 from 'node:util';
-import { b as braces_1 } from '../../../braces@3.0.2/node_modules/braces/index.esnext';
-import { p as picomatch$1 } from '../../../picomatch@2.3.1/node_modules/picomatch/index.esnext';
-import '../../../picomatch@2.3.1/node_modules/picomatch/lib/utils.esnext';
-import { __exports as utils$1 } from '../../../../../_virtual/utils.esnext';
-
-const util = require$$0;
-const braces = braces_1;
-const picomatch = picomatch$1;
-const utils = utils$1;
-const isEmptyString = (val) => val === "" || val === "./";
-const micromatch = (list, patterns, options) => {
-  patterns = [].concat(patterns);
-  list = [].concat(list);
-  let omit = /* @__PURE__ */ new Set();
-  let keep = /* @__PURE__ */ new Set();
-  let items = /* @__PURE__ */ new Set();
-  let negatives = 0;
-  let onResult = (state) => {
-    items.add(state.output);
-    if (options && options.onResult) {
-      options.onResult(state);
-    }
-  };
-  for (let i = 0; i < patterns.length; i++) {
-    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
-    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
-    if (negated) negatives++;
-    for (let item of list) {
-      let matched = isMatch(item, true);
-      let match = negated ? !matched.isMatch : matched.isMatch;
-      if (!match) continue;
-      if (negated) {
-        omit.add(matched.output);
-      } else {
-        omit.delete(matched.output);
-        keep.add(matched.output);
-      }
-    }
-  }
-  let result = negatives === patterns.length ? [...items] : [...keep];
-  let matches = result.filter((item) => !omit.has(item));
-  if (options && matches.length === 0) {
-    if (options.failglob === true) {
-      throw new Error(`No matches found for "${patterns.join(", ")}"`);
-    }
-    if (options.nonull === true || options.nullglob === true) {
-      return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
-    }
-  }
-  return matches;
-};
-micromatch.match = micromatch;
-micromatch.matcher = (pattern, options) => picomatch(pattern, options);
-micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
-micromatch.any = micromatch.isMatch;
-micromatch.not = (list, patterns, options = {}) => {
-  patterns = [].concat(patterns).map(String);
-  let result = /* @__PURE__ */ new Set();
-  let items = [];
-  let onResult = (state) => {
-    if (options.onResult) options.onResult(state);
-    items.push(state.output);
-  };
-  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
-  for (let item of items) {
-    if (!matches.has(item)) {
-      result.add(item);
-    }
-  }
-  return [...result];
-};
-micromatch.contains = (str, pattern, options) => {
-  if (typeof str !== "string") {
-    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
-  }
-  if (Array.isArray(pattern)) {
-    return pattern.some((p) => micromatch.contains(str, p, options));
-  }
-  if (typeof pattern === "string") {
-    if (isEmptyString(str) || isEmptyString(pattern)) {
-      return false;
-    }
-    if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
-      return true;
-    }
-  }
-  return micromatch.isMatch(str, pattern, { ...options, contains: true });
-};
-micromatch.matchKeys = (obj, patterns, options) => {
-  if (!utils.isObject(obj)) {
-    throw new TypeError("Expected the first argument to be an object");
-  }
-  let keys = micromatch(Object.keys(obj), patterns, options);
-  let res = {};
-  for (let key of keys) res[key] = obj[key];
-  return res;
-};
-micromatch.some = (list, patterns, options) => {
-  let items = [].concat(list);
-  for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch(String(pattern), options);
-    if (items.some((item) => isMatch(item))) {
-      return true;
-    }
-  }
-  return false;
-};
-micromatch.every = (list, patterns, options) => {
-  let items = [].concat(list);
-  for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch(String(pattern), options);
-    if (!items.every((item) => isMatch(item))) {
-      return false;
-    }
-  }
-  return true;
-};
-micromatch.all = (str, patterns, options) => {
-  if (typeof str !== "string") {
-    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
-  }
-  return [].concat(patterns).every((p) => picomatch(p, options)(str));
-};
-micromatch.capture = (glob, input, options) => {
-  let posix = utils.isWindows(options);
-  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
-  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
-  if (match) {
-    return match.slice(1).map((v) => v === void 0 ? "" : v);
-  }
-};
-micromatch.makeRe = (...args) => picomatch.makeRe(...args);
-micromatch.scan = (...args) => picomatch.scan(...args);
-micromatch.parse = (patterns, options) => {
-  let res = [];
-  for (let pattern of [].concat(patterns || [])) {
-    for (let str of braces(String(pattern), options)) {
-      res.push(picomatch.parse(str, options));
-    }
-  }
-  return res;
-};
-micromatch.braces = (pattern, options) => {
-  if (typeof pattern !== "string") throw new TypeError("Expected a string");
-  if (options && options.nobrace === true || !/\{.*\}/.test(pattern)) {
-    return [pattern];
-  }
-  return braces(pattern, options);
-};
-micromatch.braceExpand = (pattern, options) => {
-  if (typeof pattern !== "string") throw new TypeError("Expected a string");
-  return micromatch.braces(pattern, { ...options, expand: true });
-};
-var micromatch_1 = micromatch;
-
-export { micromatch_1 as m };