@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/index.esnext

@@ -46,7 +46,7 @@ function requireDist() {
   function _createForOfIteratorHelper(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
     if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
         if (it) o = it;
         var i = 0;
         var F = function F2() {

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/clear.esnext

@@ -9,7 +9,7 @@ function requireClear() {
   function _createForOfIteratorHelper(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
     if (!it) {
-      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
         if (it) o = it;
         var i = 0;
         var F = function F2() {

package/build/esnext/node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.esnext

@@ -1,17 +1,22 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.esnext';
 import { __require as requireDist } from './dist/index.esnext';
 import { __require as requireLib } from './lib/index.esnext';
 
-function isNodeLT(tar) {
-  tar = (Array.isArray(tar) ? tar : tar.split(".")).map(Number);
-  let i = 0, src = process.versions.node.split(".").map(Number);
-  for (; i < tar.length; i++) {
-    if (src[i] > tar[i]) return false;
-    if (tar[i] > src[i]) return true;
+var prompts;
+var hasRequiredPrompts;
+function requirePrompts() {
+  if (hasRequiredPrompts) return prompts;
+  hasRequiredPrompts = 1;
+  function isNodeLT(tar) {
+    tar = (Array.isArray(tar) ? tar : tar.split(".")).map(Number);
+    let i = 0, src = process.versions.node.split(".").map(Number);
+    for (; i < tar.length; i++) {
+      if (src[i] > tar[i]) return false;
+      if (tar[i] > src[i]) return true;
+    }
+    return false;
   }
-  return false;
+  prompts = isNodeLT("8.6.0") ? requireDist() : requireLib();
+  return prompts;
 }
-var prompts = isNodeLT("8.6.0") ? requireDist() : requireLib();
-const prompts$1 = /* @__PURE__ */ getDefaultExportFromCjs(prompts);
 
-export { prompts$1 as default };
+export { requirePrompts as __require };

package/build/esnext/node_modules/.pnpm/queue-microtask@1.2.3/node_modules/queue-microtask/index.esnext

@@ -1,8 +1,15 @@
 import { commonjsGlobal } from '../../../../../_virtual/_commonjsHelpers.esnext';
 
-let promise;
-var queueMicrotask_1 = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : commonjsGlobal) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
-  throw err;
-}, 0));
+var queueMicrotask_1;
+var hasRequiredQueueMicrotask;
+function requireQueueMicrotask() {
+  if (hasRequiredQueueMicrotask) return queueMicrotask_1;
+  hasRequiredQueueMicrotask = 1;
+  let promise;
+  queueMicrotask_1 = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : commonjsGlobal) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
+    throw err;
+  }, 0));
+  return queueMicrotask_1;
+}
 
-export { queueMicrotask_1 as q };
+export { requireQueueMicrotask as __require };

package/build/esnext/node_modules/.pnpm/reusify@1.0.4/node_modules/reusify/reusify.esnext

@@ -1,26 +1,33 @@
-function reusify(Constructor) {
-  var head = new Constructor();
-  var tail = head;
-  function get() {
-    var current = head;
-    if (current.next) {
-      head = current.next;
-    } else {
-      head = new Constructor();
-      tail = head;
+var reusify_1;
+var hasRequiredReusify;
+function requireReusify() {
+  if (hasRequiredReusify) return reusify_1;
+  hasRequiredReusify = 1;
+  function reusify(Constructor) {
+    var head = new Constructor();
+    var tail = head;
+    function get() {
+      var current = head;
+      if (current.next) {
+        head = current.next;
+      } else {
+        head = new Constructor();
+        tail = head;
+      }
+      current.next = null;
+      return current;
     }
-    current.next = null;
-    return current;
-  }
-  function release(obj) {
-    tail.next = obj;
-    tail = obj;
+    function release(obj) {
+      tail.next = obj;
+      tail = obj;
+    }
+    return {
+      get,
+      release
+    };
   }
-  return {
-    get,
-    release
-  };
+  reusify_1 = reusify;
+  return reusify_1;
 }
-var reusify_1 = reusify;
 
-export { reusify_1 as r };
+export { requireReusify as __require };

package/build/esnext/node_modules/.pnpm/run-parallel@1.2.0/node_modules/run-parallel/index.esnext

@@ -1,48 +1,55 @@
-import { q as queueMicrotask_1 } from '../../../queue-microtask@1.2.3/node_modules/queue-microtask/index.esnext';
+import { __require as requireQueueMicrotask } from '../../../queue-microtask@1.2.3/node_modules/queue-microtask/index.esnext';
 
-var runParallel_1 = runParallel;
-const queueMicrotask = queueMicrotask_1;
-function runParallel(tasks, cb) {
-  let results, pending, keys;
-  let isSync = true;
-  if (Array.isArray(tasks)) {
-    results = [];
-    pending = tasks.length;
-  } else {
-    keys = Object.keys(tasks);
-    results = {};
-    pending = keys.length;
-  }
-  function done(err) {
-    function end() {
-      if (cb) cb(err, results);
-      cb = null;
+var runParallel_1;
+var hasRequiredRunParallel;
+function requireRunParallel() {
+  if (hasRequiredRunParallel) return runParallel_1;
+  hasRequiredRunParallel = 1;
+  runParallel_1 = runParallel;
+  const queueMicrotask = requireQueueMicrotask();
+  function runParallel(tasks, cb) {
+    let results, pending, keys;
+    let isSync = true;
+    if (Array.isArray(tasks)) {
+      results = [];
+      pending = tasks.length;
+    } else {
+      keys = Object.keys(tasks);
+      results = {};
+      pending = keys.length;
     }
-    if (isSync) queueMicrotask(end);
-    else end();
-  }
-  function each(i, err, result) {
-    results[i] = result;
-    if (--pending === 0 || err) {
-      done(err);
+    function done(err) {
+      function end() {
+        if (cb) cb(err, results);
+        cb = null;
+      }
+      if (isSync) queueMicrotask(end);
+      else end();
     }
-  }
-  if (!pending) {
-    done(null);
-  } else if (keys) {
-    keys.forEach(function(key) {
-      tasks[key](function(err, result) {
-        each(key, err, result);
+    function each(i, err, result) {
+      results[i] = result;
+      if (--pending === 0 || err) {
+        done(err);
+      }
+    }
+    if (!pending) {
+      done(null);
+    } else if (keys) {
+      keys.forEach(function(key) {
+        tasks[key](function(err, result) {
+          each(key, err, result);
+        });
       });
-    });
-  } else {
-    tasks.forEach(function(task, i) {
-      task(function(err, result) {
-        each(i, err, result);
+    } else {
+      tasks.forEach(function(task, i) {
+        task(function(err, result) {
+          each(i, err, result);
+        });
       });
-    });
+    }
+    isSync = false;
   }
-  isSync = false;
+  return runParallel_1;
 }
 
-export { runParallel_1 as r };
+export { requireRunParallel as __require };

package/build/esnext/node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.esnext

@@ -1,208 +1,215 @@
-import { i as isNumber$1 } from '../../../is-number@7.0.0/node_modules/is-number/index.esnext';
+import { __require as requireIsNumber } from '../../../is-number@7.0.0/node_modules/is-number/index.esnext';
 
-const isNumber = isNumber$1;
-const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
-    throw new TypeError("toRegexRange: expected the first argument to be a number");
-  }
-  if (max === void 0 || min === max) {
-    return String(min);
-  }
-  if (isNumber(max) === false) {
-    throw new TypeError("toRegexRange: expected the second argument to be a number.");
-  }
-  let opts = { relaxZeros: true, ...options };
-  if (typeof opts.strictZeros === "boolean") {
-    opts.relaxZeros = opts.strictZeros === false;
-  }
-  let relax = String(opts.relaxZeros);
-  let shorthand = String(opts.shorthand);
-  let capture = String(opts.capture);
-  let wrap = String(opts.wrap);
-  let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
-  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
-    return toRegexRange.cache[cacheKey].result;
-  }
-  let a = Math.min(min, max);
-  let b = Math.max(min, max);
-  if (Math.abs(a - b) === 1) {
-    let result = min + "|" + max;
-    if (opts.capture) {
-      return `(${result})`;
+var toRegexRange_1;
+var hasRequiredToRegexRange;
+function requireToRegexRange() {
+  if (hasRequiredToRegexRange) return toRegexRange_1;
+  hasRequiredToRegexRange = 1;
+  const isNumber = requireIsNumber();
+  const toRegexRange = (min, max, options) => {
+    if (isNumber(min) === false) {
+      throw new TypeError("toRegexRange: expected the first argument to be a number");
     }
-    if (opts.wrap === false) {
-      return result;
+    if (max === void 0 || min === max) {
+      return String(min);
+    }
+    if (isNumber(max) === false) {
+      throw new TypeError("toRegexRange: expected the second argument to be a number.");
+    }
+    let opts = { relaxZeros: true, ...options };
+    if (typeof opts.strictZeros === "boolean") {
+      opts.relaxZeros = opts.strictZeros === false;
+    }
+    let relax = String(opts.relaxZeros);
+    let shorthand = String(opts.shorthand);
+    let capture = String(opts.capture);
+    let wrap = String(opts.wrap);
+    let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
+    if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+      return toRegexRange.cache[cacheKey].result;
+    }
+    let a = Math.min(min, max);
+    let b = Math.max(min, max);
+    if (Math.abs(a - b) === 1) {
+      let result = min + "|" + max;
+      if (opts.capture) {
+        return `(${result})`;
+      }
+      if (opts.wrap === false) {
+        return result;
+      }
+      return `(?:${result})`;
+    }
+    let isPadded = hasPadding(min) || hasPadding(max);
+    let state = { min, max, a, b };
+    let positives = [];
+    let negatives = [];
+    if (isPadded) {
+      state.isPadded = isPadded;
+      state.maxLen = String(state.max).length;
+    }
+    if (a < 0) {
+      let newMin = b < 0 ? Math.abs(b) : 1;
+      negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+      a = state.a = 0;
+    }
+    if (b >= 0) {
+      positives = splitToPatterns(a, b, state, opts);
+    }
+    state.negatives = negatives;
+    state.positives = positives;
+    state.result = collatePatterns(negatives, positives);
+    if (opts.capture === true) {
+      state.result = `(${state.result})`;
+    } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
+      state.result = `(?:${state.result})`;
+    }
+    toRegexRange.cache[cacheKey] = state;
+    return state.result;
+  };
+  function collatePatterns(neg, pos, options) {
+    let onlyNegative = filterPatterns(neg, pos, "-", false) || [];
+    let onlyPositive = filterPatterns(pos, neg, "", false) || [];
+    let intersected = filterPatterns(neg, pos, "-?", true) || [];
+    let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+    return subpatterns.join("|");
+  }
+  function splitToRanges(min, max) {
+    let nines = 1;
+    let zeros = 1;
+    let stop = countNines(min, nines);
+    let stops = /* @__PURE__ */ new Set([max]);
+    while (min <= stop && stop <= max) {
+      stops.add(stop);
+      nines += 1;
+      stop = countNines(min, nines);
     }
-    return `(?:${result})`;
-  }
-  let isPadded = hasPadding(min) || hasPadding(max);
-  let state = { min, max, a, b };
-  let positives = [];
-  let negatives = [];
-  if (isPadded) {
-    state.isPadded = isPadded;
-    state.maxLen = String(state.max).length;
-  }
-  if (a < 0) {
-    let newMin = b < 0 ? Math.abs(b) : 1;
-    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
-    a = state.a = 0;
-  }
-  if (b >= 0) {
-    positives = splitToPatterns(a, b, state, opts);
-  }
-  state.negatives = negatives;
-  state.positives = positives;
-  state.result = collatePatterns(negatives, positives);
-  if (opts.capture === true) {
-    state.result = `(${state.result})`;
-  } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
-    state.result = `(?:${state.result})`;
-  }
-  toRegexRange.cache[cacheKey] = state;
-  return state.result;
-};
-function collatePatterns(neg, pos, options) {
-  let onlyNegative = filterPatterns(neg, pos, "-", false) || [];
-  let onlyPositive = filterPatterns(pos, neg, "", false) || [];
-  let intersected = filterPatterns(neg, pos, "-?", true) || [];
-  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
-  return subpatterns.join("|");
-}
-function splitToRanges(min, max) {
-  let nines = 1;
-  let zeros = 1;
-  let stop = countNines(min, nines);
-  let stops = /* @__PURE__ */ new Set([max]);
-  while (min <= stop && stop <= max) {
-    stops.add(stop);
-    nines += 1;
-    stop = countNines(min, nines);
-  }
-  stop = countZeros(max + 1, zeros) - 1;
-  while (min < stop && stop <= max) {
-    stops.add(stop);
-    zeros += 1;
     stop = countZeros(max + 1, zeros) - 1;
-  }
-  stops = [...stops];
-  stops.sort(compare);
-  return stops;
-}
-function rangeToPattern(start, stop, options) {
-  if (start === stop) {
-    return { pattern: start, count: [], digits: 0 };
-  }
-  let zipped = zip(start, stop);
-  let digits = zipped.length;
-  let pattern = "";
-  let count = 0;
-  for (let i = 0; i < digits; i++) {
-    let [startDigit, stopDigit] = zipped[i];
-    if (startDigit === stopDigit) {
-      pattern += startDigit;
-    } else if (startDigit !== "0" || stopDigit !== "9") {
-      pattern += toCharacterClass(startDigit, stopDigit);
-    } else {
-      count++;
+    while (min < stop && stop <= max) {
+      stops.add(stop);
+      zeros += 1;
+      stop = countZeros(max + 1, zeros) - 1;
     }
+    stops = [...stops];
+    stops.sort(compare);
+    return stops;
   }
-  if (count) {
-    pattern += options.shorthand === true ? "\\d" : "[0-9]";
-  }
-  return { pattern, count: [count], digits };
-}
-function splitToPatterns(min, max, tok, options) {
-  let ranges = splitToRanges(min, max);
-  let tokens = [];
-  let start = min;
-  let prev;
-  for (let i = 0; i < ranges.length; i++) {
-    let max2 = ranges[i];
-    let obj = rangeToPattern(String(start), String(max2), options);
-    let zeros = "";
-    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
-      if (prev.count.length > 1) {
-        prev.count.pop();
+  function rangeToPattern(start, stop, options) {
+    if (start === stop) {
+      return { pattern: start, count: [], digits: 0 };
+    }
+    let zipped = zip(start, stop);
+    let digits = zipped.length;
+    let pattern = "";
+    let count = 0;
+    for (let i = 0; i < digits; i++) {
+      let [startDigit, stopDigit] = zipped[i];
+      if (startDigit === stopDigit) {
+        pattern += startDigit;
+      } else if (startDigit !== "0" || stopDigit !== "9") {
+        pattern += toCharacterClass(startDigit, stopDigit);
+      } else {
+        count++;
       }
-      prev.count.push(obj.count[0]);
-      prev.string = prev.pattern + toQuantifier(prev.count);
+    }
+    if (count) {
+      pattern += options.shorthand === true ? "\\d" : "[0-9]";
+    }
+    return { pattern, count: [count], digits };
+  }
+  function splitToPatterns(min, max, tok, options) {
+    let ranges = splitToRanges(min, max);
+    let tokens = [];
+    let start = min;
+    let prev;
+    for (let i = 0; i < ranges.length; i++) {
+      let max2 = ranges[i];
+      let obj = rangeToPattern(String(start), String(max2), options);
+      let zeros = "";
+      if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+        if (prev.count.length > 1) {
+          prev.count.pop();
+        }
+        prev.count.push(obj.count[0]);
+        prev.string = prev.pattern + toQuantifier(prev.count);
+        start = max2 + 1;
+        continue;
+      }
+      if (tok.isPadded) {
+        zeros = padZeros(max2, tok, options);
+      }
+      obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+      tokens.push(obj);
       start = max2 + 1;
-      continue;
+      prev = obj;
     }
-    if (tok.isPadded) {
-      zeros = padZeros(max2, tok, options);
+    return tokens;
+  }
+  function filterPatterns(arr, comparison, prefix, intersection, options) {
+    let result = [];
+    for (let ele of arr) {
+      let { string } = ele;
+      if (!intersection && !contains(comparison, "string", string)) {
+        result.push(prefix + string);
+      }
+      if (intersection && contains(comparison, "string", string)) {
+        result.push(prefix + string);
+      }
     }
-    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
-    tokens.push(obj);
-    start = max2 + 1;
-    prev = obj;
+    return result;
   }
-  return tokens;
-}
-function filterPatterns(arr, comparison, prefix, intersection, options) {
-  let result = [];
-  for (let ele of arr) {
-    let { string } = ele;
-    if (!intersection && !contains(comparison, "string", string)) {
-      result.push(prefix + string);
-    }
-    if (intersection && contains(comparison, "string", string)) {
-      result.push(prefix + string);
+  function zip(a, b) {
+    let arr = [];
+    for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+    return arr;
+  }
+  function compare(a, b) {
+    return a > b ? 1 : b > a ? -1 : 0;
+  }
+  function contains(arr, key, val) {
+    return arr.some((ele) => ele[key] === val);
+  }
+  function countNines(min, len) {
+    return Number(String(min).slice(0, -len) + "9".repeat(len));
+  }
+  function countZeros(integer, zeros) {
+    return integer - integer % Math.pow(10, zeros);
+  }
+  function toQuantifier(digits) {
+    let [start = 0, stop = ""] = digits;
+    if (stop || start > 1) {
+      return `{${start + (stop ? "," + stop : "")}}`;
     }
+    return "";
   }
-  return result;
-}
-function zip(a, b) {
-  let arr = [];
-  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
-  return arr;
-}
-function compare(a, b) {
-  return a > b ? 1 : b > a ? -1 : 0;
-}
-function contains(arr, key, val) {
-  return arr.some((ele) => ele[key] === val);
-}
-function countNines(min, len) {
-  return Number(String(min).slice(0, -len) + "9".repeat(len));
-}
-function countZeros(integer, zeros) {
-  return integer - integer % Math.pow(10, zeros);
-}
-function toQuantifier(digits) {
-  let [start = 0, stop = ""] = digits;
-  if (stop || start > 1) {
-    return `{${start + (stop ? "," + stop : "")}}`;
+  function toCharacterClass(a, b, options) {
+    return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
   }
-  return "";
-}
-function toCharacterClass(a, b, options) {
-  return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
-}
-function hasPadding(str) {
-  return /^-?(0+)\d/.test(str);
-}
-function padZeros(value, tok, options) {
-  if (!tok.isPadded) {
-    return value;
+  function hasPadding(str) {
+    return /^-?(0+)\d/.test(str);
   }
-  let diff = Math.abs(tok.maxLen - String(value).length);
-  let relax = options.relaxZeros !== false;
-  switch (diff) {
-    case 0:
-      return "";
-    case 1:
-      return relax ? "0?" : "0";
-    case 2:
-      return relax ? "0{0,2}" : "00";
-    default: {
-      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+  function padZeros(value, tok, options) {
+    if (!tok.isPadded) {
+      return value;
+    }
+    let diff = Math.abs(tok.maxLen - String(value).length);
+    let relax = options.relaxZeros !== false;
+    switch (diff) {
+      case 0:
+        return "";
+      case 1:
+        return relax ? "0?" : "0";
+      case 2:
+        return relax ? "0{0,2}" : "00";
+      default: {
+        return relax ? `0{0,${diff}}` : `0{${diff}}`;
+      }
     }
   }
+  toRegexRange.cache = {};
+  toRegexRange.clearCache = () => toRegexRange.cache = {};
+  toRegexRange_1 = toRegexRange;
+  return toRegexRange_1;
 }
-toRegexRange.cache = {};
-toRegexRange.clearCache = () => toRegexRange.cache = {};
-var toRegexRange_1 = toRegexRange;
 
-export { toRegexRange_1 as t };
+export { requireToRegexRange as __require };