@quilted/create 0.1.89 → 0.2.0

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

@@ -2,45 +2,45 @@ import { s as stringify$1 } from './stringify.esnext';
 import { c as constants } from './constants.esnext';
 
 const stringify = stringify$1;
-
-/**
- * Constants
- */
-
 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_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;
-
-/**
- * parse
- */
-
 const parse = (input, options = {}) => {
-  if (typeof input !== 'string') {
-    throw new TypeError('Expected a string');
+  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;
+  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 ast = { type: "root", input, nodes: [] };
   let stack = [ast];
   let block = ast;
   let prev = ast;
@@ -49,157 +49,101 @@ const parse = (input, options = {}) => {
   let index = 0;
   let depth = 0;
   let value;
-
-  /**
-   * Helpers
-   */
-
   const advance = () => input[index++];
-  const push = node => {
-    if (node.type === 'text' && prev.type === 'dot') {
-      prev.type = 'text';
+  const push = (node) => {
+    if (node.type === "text" && prev.type === "dot") {
+      prev.type = "text";
     }
-
-    if (prev && prev.type === 'text' && node.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' });
-
+  push({ type: "bos" });
   while (index < length) {
     block = stack[stack.length - 1];
     value = advance();
-
-    /**
-     * Invalid chars
-     */
-
     if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
       continue;
     }
-
-    /**
-     * Escaped chars
-     */
-
     if (value === CHAR_BACKSLASH) {
-      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+      push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
       continue;
     }
-
-    /**
-     * Right square bracket (literal): ']'
-     */
-
     if (value === CHAR_RIGHT_SQUARE_BRACKET) {
-      push({ type: 'text', value: '\\' + value });
+      push({ type: "text", value: "\\" + value });
       continue;
     }
-
-    /**
-     * Left square bracket: '['
-     */
-
     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 });
+      push({ type: "text", value });
       continue;
     }
-
-    /**
-     * Parentheses
-     */
-
     if (value === CHAR_LEFT_PARENTHESES) {
-      block = push({ type: 'paren', nodes: [] });
+      block = push({ type: "paren", nodes: [] });
       stack.push(block);
-      push({ type: 'text', value });
+      push({ type: "text", value });
       continue;
     }
-
     if (value === CHAR_RIGHT_PARENTHESES) {
-      if (block.type !== 'paren') {
-        push({ type: 'text', value });
+      if (block.type !== "paren") {
+        push({ type: "text", value });
         continue;
       }
       block = stack.pop();
-      push({ type: 'text', value });
+      push({ type: "text", value });
       block = stack[stack.length - 1];
       continue;
     }
-
-    /**
-     * Quotes: '|"|`
-     */
-
     if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
       let open = value;
       let next;
-
       if (options.keepQuotes !== true) {
-        value = '';
+        value = "";
       }
-
       while (index < length && (next = advance())) {
         if (next === CHAR_BACKSLASH) {
           value += next + advance();
           continue;
         }
-
         if (next === open) {
-          if (options.keepQuotes === true) value += next;
+          if (options.keepQuotes === true)
+            value += next;
           break;
         }
-
         value += next;
       }
-
-      push({ type: 'text', value });
+      push({ type: "text", value });
       continue;
     }
-
-    /**
-     * Left curly brace: '{'
-     */
-
     if (value === CHAR_LEFT_CURLY_BRACE) {
       depth++;
-
-      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      let dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
       let brace = {
-        type: 'brace',
+        type: "brace",
         open: true,
         close: false,
         dollar,
@@ -208,126 +152,89 @@ const parse = (input, options = {}) => {
         ranges: 0,
         nodes: []
       };
-
       block = push(brace);
       stack.push(block);
-      push({ type: 'open', value });
+      push({ type: "open", value });
       continue;
     }
-
-    /**
-     * Right curly brace: '}'
-     */
-
     if (value === CHAR_RIGHT_CURLY_BRACE) {
-      if (block.type !== 'brace') {
-        push({ type: 'text', value });
+      if (block.type !== "brace") {
+        push({ type: "text", value });
         continue;
       }
-
-      let type = 'close';
+      let type = "close";
       block = stack.pop();
       block.close = true;
-
       push({ type, value });
       depth--;
-
       block = stack[stack.length - 1];
       continue;
     }
-
-    /**
-     * Comma: ','
-     */
-
     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) }];
+        block.nodes = [open, { type: "text", value: stringify(block) }];
       }
-
-      push({ type: 'comma', value });
+      push({ type: "comma", value });
       block.commas++;
       continue;
     }
-
-    /**
-     * Dot: '.'
-     */
-
     if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
       let siblings = block.nodes;
-
       if (depth === 0 || siblings.length === 0) {
-        push({ type: 'text', value });
+        push({ type: "text", value });
         continue;
       }
-
-      if (prev.type === 'dot') {
+      if (prev.type === "dot") {
         block.range = [];
         prev.value += value;
-        prev.type = 'range';
-
+        prev.type = "range";
         if (block.nodes.length !== 3 && block.nodes.length !== 5) {
           block.invalid = true;
           block.ranges = 0;
-          prev.type = 'text';
+          prev.type = "text";
           continue;
         }
-
         block.ranges++;
         block.args = [];
         continue;
       }
-
-      if (prev.type === 'range') {
+      if (prev.type === "range") {
         siblings.pop();
-
         let before = siblings[siblings.length - 1];
         before.value += prev.value + value;
         prev = before;
         block.ranges--;
         continue;
       }
-
-      push({ type: 'dot', value });
+      push({ type: "dot", value });
       continue;
     }
-
-    /**
-     * Text
-     */
-
-    push({ type: 'text', value });
+    push({ type: "text", value });
   }
-
-  // Mark imbalanced braces and brackets as invalid
   do {
     block = stack.pop();
-
-    if (block.type !== 'root') {
-      block.nodes.forEach(node => {
+    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';
+          if (node.type === "open")
+            node.isOpen = true;
+          if (node.type === "close")
+            node.isClose = true;
+          if (!node.nodes)
+            node.type = "text";
           node.invalid = true;
         }
       });
-
-      // get the location of the block on parent.nodes (block's siblings)
       let parent = stack[stack.length - 1];
-      let index = parent.nodes.indexOf(block);
-      // replace the (invalid) block with it's nodes
-      parent.nodes.splice(index, 1, ...block.nodes);
+      let index2 = parent.nodes.indexOf(block);
+      parent.nodes.splice(index2, 1, ...block.nodes);
     }
   } while (stack.length > 0);
-
-  push({ type: 'eos' });
+  push({ type: "eos" });
   return ast;
 };
-
 var parse_1 = parse;
 
 export { parse_1 as p };

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

@@ -2,33 +2,28 @@ import './utils.esnext';
 import { __exports as utils$1 } from '../../../../../../_virtual/utils2.esnext';
 
 const utils = utils$1;
-
 var stringify = (ast, options = {}) => {
-  let stringify = (node, parent = {}) => {
+  let stringify2 = (node, parent = {}) => {
     let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let output = '';
-
+    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 += stringify(child);
+        output += stringify2(child);
       }
     }
     return output;
   };
-
-  return stringify(ast);
+  return stringify2(ast);
 };
 
 export { stringify as s };

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

@@ -1,115 +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;
-	};
-
-	/**
-	 * Find a node of the given type
-	 */
-
-	exports.find = (node, type) => node.nodes.find(node => node.type === type);
-
-	/**
-	 * Find a node of the given 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;
-	};
-
-	/**
-	 * Escape the given node with '\\' before node.value
-	 */
-
-	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;
-	    }
-	  }
-	};
-
-	/**
-	 * Returns true if the given brace node should be enclosed in literal braces
-	 */
-
-	exports.encloseBrace = node => {
-	  if (node.type !== 'brace') return false;
-	  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
-	    node.invalid = true;
-	    return true;
-	  }
-	  return false;
-	};
-
-	/**
-	 * Returns true if a brace node is invalid.
-	 */
-
-	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;
-	};
-
-	/**
-	 * Returns true if a node is an open or close node
-	 */
-
-	exports.isOpenOrClose = node => {
-	  if (node.type === 'open' || node.type === 'close') {
-	    return true;
-	  }
-	  return node.open === true || node.close === true;
-	};
-
-	/**
-	 * Reduce an array of text nodes.
-	 */
-
-	exports.reduce = nodes => nodes.reduce((acc, node) => {
-	  if (node.type === 'text') acc.push(node.value);
-	  if (node.type === 'range') node.type = 'text';
-	  return acc;
-	}, []);
-
-	/**
-	 * Flatten an array
-	 */
-
-	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;
-	}; 
-} (utils));
+(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;
+      }
+    }
+  };
+  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;
+  };
+})(utils);