@quilted/create 0.2.43 → 0.2.44

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

@@ -1,236 +1,243 @@
-import { s as stringify$1 } from './stringify.esnext';
-import { c as constants } from './constants.esnext';
+import { __require as requireStringify } from './stringify.esnext';
+import { __require as requireConstants } from './constants.esnext';
 
-const stringify = stringify$1;
-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
-} = constants;
-const parse = (input, options = {}) => {
-  if (typeof input !== "string") {
-    throw new TypeError("Expected a string");
-  }
-  let opts = options || {};
-  let 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})`);
-  }
-  let ast = { type: "root", input, nodes: [] };
-  let stack = [ast];
-  let block = ast;
-  let prev = ast;
-  let brackets = 0;
-  let 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";
+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");
     }
-    if (prev && prev.type === "text" && node.type === "text") {
-      prev.value += node.value;
-      return;
+    let opts = options || {};
+    let 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})`);
     }
-    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;
+    let ast = { type: "root", input, nodes: [] };
+    let stack = [ast];
+    let block = ast;
+    let prev = ast;
+    let brackets = 0;
+    let 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) {
-      let open = value;
-      let next;
-      if (options.keepQuotes !== true) {
-        value = "";
+      if (value === CHAR_LEFT_PARENTHESES) {
+        block = push({ type: "paren", nodes: [] });
+        stack.push(block);
+        push({ type: "text", value });
+        continue;
       }
-      while (index < length && (next = advance())) {
-        if (next === CHAR_BACKSLASH) {
-          value += next + advance();
+      if (value === CHAR_RIGHT_PARENTHESES) {
+        if (block.type !== "paren") {
+          push({ type: "text", value });
           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++;
-      let dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
-      let 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") {
+        block = stack.pop();
         push({ type: "text", value });
+        block = stack[stack.length - 1];
         continue;
       }
-      let 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;
-        let 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) {
-      let siblings = block.nodes;
-      if (depth === 0 || siblings.length === 0) {
+      if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+        let 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 (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";
+      if (value === CHAR_LEFT_CURLY_BRACE) {
+        depth++;
+        let dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
+        let 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;
         }
-        block.ranges++;
-        block.args = [];
+        let type = "close";
+        block = stack.pop();
+        block.close = true;
+        push({ type, value });
+        depth--;
+        block = stack[stack.length - 1];
         continue;
       }
-      if (prev.type === "range") {
-        siblings.pop();
-        let before = siblings[siblings.length - 1];
-        before.value += prev.value + value;
-        prev = before;
-        block.ranges--;
+      if (value === CHAR_COMMA && depth > 0) {
+        if (block.ranges > 0) {
+          block.ranges = 0;
+          let open = block.nodes.shift();
+          block.nodes = [open, { type: "text", value: stringify(block) }];
+        }
+        push({ type: "comma", value });
+        block.commas++;
         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;
+      if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+        let 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();
+          let before = siblings[siblings.length - 1];
+          before.value += prev.value + value;
+          prev = before;
+          block.ranges--;
+          continue;
         }
-      });
-      let parent = stack[stack.length - 1];
-      let index2 = parent.nodes.indexOf(block);
-      parent.nodes.splice(index2, 1, ...block.nodes);
+        push({ type: "dot", value });
+        continue;
+      }
+      push({ type: "text", value });
     }
-  } while (stack.length > 0);
-  push({ type: "eos" });
-  return ast;
-};
-var parse_1 = parse;
+    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;
+          }
+        });
+        let parent = stack[stack.length - 1];
+        let 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 { parse_1 as p };
+export { requireParse as __require };

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

@@ -1,29 +1,35 @@
-import './utils.esnext';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils2.esnext';
+import { __require as requireUtils } from './utils.esnext';
 
-const utils = utils$1;
-var stringify = (ast, options = {}) => {
-  let stringify2 = (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 stringify2 = (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 += stringify2(child);
+      if (node.value) {
+        return node.value;
       }
-    }
-    return output;
+      if (node.nodes) {
+        for (let child of node.nodes) {
+          output += stringify2(child);
+        }
+      }
+      return output;
+    };
+    return stringify2(ast);
   };
-  return stringify2(ast);
-};
+  return stringify;
+}
 
-export { stringify as s };
+export { requireStringify as __require };

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

@@ -1,73 +1,81 @@
 import { __exports as utils } from '../../../../../../_virtual/utils2.esnext';
 
-(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) => {
-    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);
       }
-    }
-  };
-  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++) {
-        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;
+    };
+    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) => {
+      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;
+        }
+      }
+    };
+    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++) {
+          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 };