@quilted/create 0.1.90 → 0.2.1

package/build/esnext/node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.esnext

@@ -1,137 +1,91 @@
 import { b as balancedMatch } from '../../../balanced-match@1.0.2/node_modules/balanced-match/index.esnext';
 
 var balanced = balancedMatch;
-
 var braceExpansion = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
 function numeric(str) {
-  return parseInt(str, 10) == str
-    ? parseInt(str, 10)
-    : str.charCodeAt(0);
+  return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
 }
-
 function escapeBraces(str) {
-  return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
+  return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
 }
-
 function unescapeBraces(str) {
-  return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
+  return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
 }
-
-
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
 function parseCommaParts(str) {
   if (!str)
-    return [''];
-
+    return [""];
   var parts = [];
-  var m = balanced('{', '}', str);
-
+  var m = balanced("{", "}", str);
   if (!m)
-    return str.split(',');
-
+    return str.split(",");
   var pre = m.pre;
   var body = m.body;
   var post = m.post;
-  var p = pre.split(',');
-
-  p[p.length-1] += '{' + body + '}';
+  var p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
   var postParts = parseCommaParts(post);
   if (post.length) {
-    p[p.length-1] += postParts.shift();
+    p[p.length - 1] += postParts.shift();
     p.push.apply(p, postParts);
   }
-
   parts.push.apply(parts, p);
-
   return parts;
 }
-
 function expandTop(str) {
   if (!str)
     return [];
-
-  // I don't know why Bash 4.3 does this, but it does.
-  // Anything starting with {} will have the first two bytes preserved
-  // but *only* at the top level, so {},a}b will not expand to anything,
-  // but a{},b}c will be expanded to [a}c,abc].
-  // One could argue that this is a bug in Bash, but since the goal of
-  // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
+  if (str.substr(0, 2) === "{}") {
+    str = "\\{\\}" + str.substr(2);
   }
-
   return expand(escapeBraces(str), true).map(unescapeBraces);
 }
-
 function embrace(str) {
-  return '{' + str + '}';
+  return "{" + str + "}";
 }
 function isPadded(el) {
   return /^-?0\d/.test(el);
 }
-
 function lte(i, y) {
   return i <= y;
 }
 function gte(i, y) {
   return i >= y;
 }
-
 function expand(str, isTop) {
   var expansions = [];
-
-  var m = balanced('{', '}', str);
-  if (!m) return [str];
-
-  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var m = balanced("{", "}", str);
+  if (!m)
+    return [str];
   var pre = m.pre;
-  var post = m.post.length
-    ? expand(m.post, false)
-    : [''];
-
-  if (/\$$/.test(m.pre)) {    
+  var post = m.post.length ? expand(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
     for (var k = 0; k < post.length; k++) {
-      var expansion = pre+ '{' + m.body + '}' + post[k];
+      var expansion = pre + "{" + m.body + "}" + post[k];
       expansions.push(expansion);
     }
   } else {
     var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
     var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
     var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(',') >= 0;
+    var isOptions = m.body.indexOf(",") >= 0;
     if (!isSequence && !isOptions) {
-      // {a},b}
       if (m.post.match(/,.*\}/)) {
-        str = m.pre + '{' + m.body + escClose + m.post;
+        str = m.pre + "{" + m.body + escClose + m.post;
         return expand(str);
       }
       return [str];
     }
-
     var n;
     if (isSequence) {
       n = m.body.split(/\.\./);
     } else {
       n = parseCommaParts(m.body);
       if (n.length === 1) {
-        // x{{a,b}}y ==> x{a}y x{b}y
         n = expand(n[0], false).map(embrace);
         if (n.length === 1) {
           return post.map(function(p) {
@@ -140,18 +94,12 @@ function expand(str, isTop) {
         }
       }
     }
-
-    // at this point, n is the parts, and we know it's not a comma set
-    // with a single entry.
     var N;
-
     if (isSequence) {
       var x = numeric(n[0]);
       var y = numeric(n[1]);
       var width = Math.max(n[0].length, n[1].length);
-      var incr = n.length == 3
-        ? Math.abs(numeric(n[2]))
-        : 1;
+      var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
       var test = lte;
       var reverse = y < x;
       if (reverse) {
@@ -159,23 +107,21 @@ function expand(str, isTop) {
         test = gte;
       }
       var pad = n.some(isPadded);
-
       N = [];
-
       for (var i = x; test(i, y); i += incr) {
         var c;
         if (isAlphaSequence) {
           c = String.fromCharCode(i);
-          if (c === '\\')
-            c = '';
+          if (c === "\\")
+            c = "";
         } else {
           c = String(i);
           if (pad) {
             var need = width - c.length;
             if (need > 0) {
-              var z = new Array(need + 1).join('0');
+              var z = new Array(need + 1).join("0");
               if (i < 0)
-                c = '-' + z + c.slice(1);
+                c = "-" + z + c.slice(1);
               else
                 c = z + c;
             }
@@ -185,12 +131,10 @@ function expand(str, isTop) {
       }
     } else {
       N = [];
-
       for (var j = 0; j < n.length; j++) {
         N.push.apply(N, expand(n[j], false));
       }
     }
-
     for (var j = 0; j < N.length; j++) {
       for (var k = 0; k < post.length; k++) {
         var expansion = pre + N[j] + post[k];
@@ -199,7 +143,6 @@ function expand(str, isTop) {
       }
     }
   }
-
   return expansions;
 }
 

package/build/esnext/node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.esnext

@@ -7,24 +7,8 @@ const stringify = stringify$1;
 const compile = compile_1;
 const expand = expand_1;
 const parse = parse_1;
-
-/**
- * Expand the given pattern or create a regex-compatible string.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
- * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
- * ```
- * @param {String} `str`
- * @param {Object} `options`
- * @return {String}
- * @api public
- */
-
 const braces = (input, options = {}) => {
   let output = [];
-
   if (Array.isArray(input)) {
     for (let pattern of input) {
       let result = braces.create(pattern, options);
@@ -37,139 +21,43 @@ const braces = (input, options = {}) => {
   } else {
     output = [].concat(braces.create(input, options));
   }
-
   if (options && options.expand === true && options.nodupes === true) {
     output = [...new Set(output)];
   }
   return output;
 };
-
-/**
- * Parse the given `str` with the given `options`.
- *
- * ```js
- * // braces.parse(pattern, [, options]);
- * const ast = braces.parse('a/{b,c}/d');
- * console.log(ast);
- * ```
- * @param {String} pattern Brace pattern to parse
- * @param {Object} options
- * @return {Object} Returns an AST
- * @api public
- */
-
 braces.parse = (input, options = {}) => parse(input, options);
-
-/**
- * Creates a braces string from an AST, or an AST node.
- *
- * ```js
- * const braces = require('braces');
- * let ast = braces.parse('foo/{a,b}/bar');
- * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
 braces.stringify = (input, options = {}) => {
-  if (typeof input === 'string') {
+  if (typeof input === "string") {
     return stringify(braces.parse(input, options), options);
   }
   return stringify(input, options);
 };
-
-/**
- * Compiles a brace pattern into a regex-compatible, optimized string.
- * This method is called by the main [braces](#braces) function by default.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.compile('a/{b,c}/d'));
- * //=> ['a/(b|c)/d']
- * ```
- * @param {String} `input` Brace pattern or AST.
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
 braces.compile = (input, options = {}) => {
-  if (typeof input === 'string') {
+  if (typeof input === "string") {
     input = braces.parse(input, options);
   }
   return compile(input, options);
 };
-
-/**
- * Expands a brace pattern into an array. This method is called by the
- * main [braces](#braces) function when `options.expand` is true. Before
- * using this method it's recommended that you read the [performance notes](#performance))
- * and advantages of using [.compile](#compile) instead.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.expand('a/{b,c}/d'));
- * //=> ['a/b/d', 'a/c/d'];
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
 braces.expand = (input, options = {}) => {
-  if (typeof input === 'string') {
+  if (typeof input === "string") {
     input = braces.parse(input, options);
   }
-
   let result = expand(input, options);
-
-  // filter out empty strings if specified
   if (options.noempty === true) {
     result = result.filter(Boolean);
   }
-
-  // filter out duplicates if specified
   if (options.nodupes === true) {
     result = [...new Set(result)];
   }
-
   return result;
 };
-
-/**
- * Processes a brace pattern and returns either an expanded array
- * (if `options.expand` is true), a highly optimized regex-compatible string.
- * This method is called by the main [braces](#braces) function.
- *
- * ```js
- * const braces = require('braces');
- * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
- * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
- * ```
- * @param {String} `pattern` Brace pattern
- * @param {Object} `options`
- * @return {Array} Returns an array of expanded values.
- * @api public
- */
-
 braces.create = (input, options = {}) => {
-  if (input === '' || input.length < 3) {
+  if (input === "" || input.length < 3) {
     return [input];
   }
-
- return options.expand !== true
-    ? braces.compile(input, options)
-    : braces.expand(input, options);
+  return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
 };
-
-/**
- * Expose "braces"
- */
-
 var braces_1 = braces;
 
 export { braces_1 as b };

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

@@ -4,47 +4,38 @@ import { __exports as utils$1 } from '../../../../../../_virtual/utils2.esnext';
 
 const fill = fillRange;
 const utils = utils$1;
-
 const compile = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
     let invalidBlock = utils.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let invalid = invalidBlock === true || invalidNode === true;
-    let prefix = options.escapeInvalid === true ? '\\' : '';
-    let output = '';
-
+    let prefix = options.escapeInvalid === true ? "\\" : "";
+    let output = "";
     if (node.isOpen === true) {
       return prefix + node.value;
     }
     if (node.isClose === true) {
       return prefix + node.value;
     }
-
-    if (node.type === 'open') {
-      return invalid ? (prefix + node.value) : '(';
+    if (node.type === "open") {
+      return invalid ? prefix + node.value : "(";
     }
-
-    if (node.type === 'close') {
-      return invalid ? (prefix + node.value) : ')';
+    if (node.type === "close") {
+      return invalid ? prefix + node.value : ")";
     }
-
-    if (node.type === 'comma') {
-      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
+    if (node.type === "comma") {
+      return node.prev.type === "comma" ? "" : invalid ? node.value : "|";
     }
-
     if (node.value) {
       return node.value;
     }
-
     if (node.nodes && node.ranges > 0) {
       let args = utils.reduce(node.nodes);
       let range = fill(...args, { ...options, wrap: false, toRegex: true });
-
       if (range.length !== 0) {
         return args.length > 1 && range.length > 1 ? `(${range})` : range;
       }
     }
-
     if (node.nodes) {
       for (let child of node.nodes) {
         output += walk(child, node);
@@ -52,10 +43,8 @@ const compile = (ast, options = {}) => {
     }
     return output;
   };
-
   return walk(ast);
 };
-
 var compile_1 = compile;
 
 export { compile_1 as c };

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

@@ -1,57 +1,96 @@
 var constants = {
   MAX_LENGTH: 1024 * 64,
-
   // Digits
-  CHAR_0: '0', /* 0 */
-  CHAR_9: '9', /* 9 */
-
+  CHAR_0: "0",
+  /* 0 */
+  CHAR_9: "9",
+  /* 9 */
   // Alphabet chars.
-  CHAR_UPPERCASE_A: 'A', /* A */
-  CHAR_LOWERCASE_A: 'a', /* a */
-  CHAR_UPPERCASE_Z: 'Z', /* Z */
-  CHAR_LOWERCASE_Z: 'z', /* z */
-
-  CHAR_LEFT_PARENTHESES: '(', /* ( */
-  CHAR_RIGHT_PARENTHESES: ')', /* ) */
-
-  CHAR_ASTERISK: '*', /* * */
-
+  CHAR_UPPERCASE_A: "A",
+  /* A */
+  CHAR_LOWERCASE_A: "a",
+  /* a */
+  CHAR_UPPERCASE_Z: "Z",
+  /* Z */
+  CHAR_LOWERCASE_Z: "z",
+  /* z */
+  CHAR_LEFT_PARENTHESES: "(",
+  /* ( */
+  CHAR_RIGHT_PARENTHESES: ")",
+  /* ) */
+  CHAR_ASTERISK: "*",
+  /* * */
   // Non-alphabetic chars.
-  CHAR_AMPERSAND: '&', /* & */
-  CHAR_AT: '@', /* @ */
-  CHAR_BACKSLASH: '\\', /* \ */
-  CHAR_BACKTICK: '`', /* ` */
-  CHAR_CARRIAGE_RETURN: '\r', /* \r */
-  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
-  CHAR_COLON: ':', /* : */
-  CHAR_COMMA: ',', /* , */
-  CHAR_DOLLAR: '$', /* . */
-  CHAR_DOT: '.', /* . */
-  CHAR_DOUBLE_QUOTE: '"', /* " */
-  CHAR_EQUAL: '=', /* = */
-  CHAR_EXCLAMATION_MARK: '!', /* ! */
-  CHAR_FORM_FEED: '\f', /* \f */
-  CHAR_FORWARD_SLASH: '/', /* / */
-  CHAR_HASH: '#', /* # */
-  CHAR_HYPHEN_MINUS: '-', /* - */
-  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
-  CHAR_LEFT_CURLY_BRACE: '{', /* { */
-  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
-  CHAR_LINE_FEED: '\n', /* \n */
-  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
-  CHAR_PERCENT: '%', /* % */
-  CHAR_PLUS: '+', /* + */
-  CHAR_QUESTION_MARK: '?', /* ? */
-  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
-  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
-  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
-  CHAR_SEMICOLON: ';', /* ; */
-  CHAR_SINGLE_QUOTE: '\'', /* ' */
-  CHAR_SPACE: ' ', /*   */
-  CHAR_TAB: '\t', /* \t */
-  CHAR_UNDERSCORE: '_', /* _ */
-  CHAR_VERTICAL_LINE: '|', /* | */
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+  CHAR_AMPERSAND: "&",
+  /* & */
+  CHAR_AT: "@",
+  /* @ */
+  CHAR_BACKSLASH: "\\",
+  /* \ */
+  CHAR_BACKTICK: "`",
+  /* ` */
+  CHAR_CARRIAGE_RETURN: "\r",
+  /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: "^",
+  /* ^ */
+  CHAR_COLON: ":",
+  /* : */
+  CHAR_COMMA: ",",
+  /* , */
+  CHAR_DOLLAR: "$",
+  /* . */
+  CHAR_DOT: ".",
+  /* . */
+  CHAR_DOUBLE_QUOTE: '"',
+  /* " */
+  CHAR_EQUAL: "=",
+  /* = */
+  CHAR_EXCLAMATION_MARK: "!",
+  /* ! */
+  CHAR_FORM_FEED: "\f",
+  /* \f */
+  CHAR_FORWARD_SLASH: "/",
+  /* / */
+  CHAR_HASH: "#",
+  /* # */
+  CHAR_HYPHEN_MINUS: "-",
+  /* - */
+  CHAR_LEFT_ANGLE_BRACKET: "<",
+  /* < */
+  CHAR_LEFT_CURLY_BRACE: "{",
+  /* { */
+  CHAR_LEFT_SQUARE_BRACKET: "[",
+  /* [ */
+  CHAR_LINE_FEED: "\n",
+  /* \n */
+  CHAR_NO_BREAK_SPACE: "\xA0",
+  /* \u00A0 */
+  CHAR_PERCENT: "%",
+  /* % */
+  CHAR_PLUS: "+",
+  /* + */
+  CHAR_QUESTION_MARK: "?",
+  /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: ">",
+  /* > */
+  CHAR_RIGHT_CURLY_BRACE: "}",
+  /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: "]",
+  /* ] */
+  CHAR_SEMICOLON: ";",
+  /* ; */
+  CHAR_SINGLE_QUOTE: "'",
+  /* ' */
+  CHAR_SPACE: " ",
+  /*   */
+  CHAR_TAB: "	",
+  /* \t */
+  CHAR_UNDERSCORE: "_",
+  /* _ */
+  CHAR_VERTICAL_LINE: "|",
+  /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: "\uFEFF"
+  /* \uFEFF */
 };
 
 export { constants as c };