@quilted/create 0.2.43 → 0.2.45

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/index.mjs

@@ -1,168 +0,0 @@
-import { stringify as stringify$1 } from './lib/stringify.mjs';
-import { compile_1 } from './lib/compile.mjs';
-import { expand_1 } from './lib/expand.mjs';
-import { parse_1 } from './lib/parse.mjs';
-
-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);
-      if (Array.isArray(result)) {
-        output.push(...result);
-      } else {
-        output.push(result);
-      }
-    }
-  } 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') {
-    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') {
-    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') {
-    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) {
-    return [input];
-  }
-  return options.expand !== true ? braces.compile(input, options) : braces.expand(input, options);
-};
-
-/**
- * Expose "braces"
- */
-
-var braces_1 = braces;
-
-export { braces_1 };

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/compile.mjs

@@ -1,54 +0,0 @@
-import { fillRange } from '../../../../fill-range@7.0.1/node_modules/fill-range/index.mjs';
-import './utils.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils2.mjs';
-
-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 = '';
-    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 === 'close') {
-      return invalid ? prefix + 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);
-      }
-    }
-    return output;
-  };
-  return walk(ast);
-};
-var compile_1 = compile;
-
-export { compile_1 };

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/constants.mjs

@@ -1,99 +0,0 @@
-var constants = {
-  MAX_LENGTH: 1024 * 64,
-  // Digits
-  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: '*',
-  /* * */
-
-  // 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 */
-};
-
-export { constants };

package/build/esm/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/expand.mjs

@@ -1,94 +0,0 @@
-import { fillRange } from '../../../../fill-range@7.0.1/node_modules/fill-range/index.mjs';
-import { stringify as stringify$1 } from './stringify.mjs';
-import './utils.mjs';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils2.mjs';
-
-const fill = fillRange;
-const stringify = stringify$1;
-const utils = utils$1;
-const append = (queue = '', stash = '', enclose = false) => {
-  let result = [];
-  queue = [].concat(queue);
-  stash = [].concat(stash);
-  if (!stash.length) return queue;
-  if (!queue.length) {
-    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
-  }
-  for (let item of queue) {
-    if (Array.isArray(item)) {
-      for (let value of item) {
-        result.push(append(value, stash, enclose));
-      }
-    } else {
-      for (let ele of stash) {
-        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
-        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
-      }
-    }
-  }
-  return utils.flatten(result);
-};
-const expand = (ast, options = {}) => {
-  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
-  let walk = (node, parent = {}) => {
-    node.queue = [];
-    let p = parent;
-    let q = parent.queue;
-    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
-      p = p.parent;
-      q = p.queue;
-    }
-    if (node.invalid || node.dollar) {
-      q.push(append(q.pop(), stringify(node, options)));
-      return;
-    }
-    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
-      q.push(append(q.pop(), ['{}']));
-      return;
-    }
-    if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
-      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
-        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
-      }
-      let range = fill(...args, options);
-      if (range.length === 0) {
-        range = stringify(node, options);
-      }
-      q.push(append(q.pop(), range));
-      node.nodes = [];
-      return;
-    }
-    let enclose = utils.encloseBrace(node);
-    let queue = node.queue;
-    let block = node;
-    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
-      block = block.parent;
-      queue = block.queue;
-    }
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i];
-      if (child.type === 'comma' && node.type === 'brace') {
-        if (i === 1) queue.push('');
-        queue.push('');
-        continue;
-      }
-      if (child.type === 'close') {
-        q.push(append(q.pop(), queue, enclose));
-        continue;
-      }
-      if (child.value && child.type !== 'open') {
-        queue.push(append(queue.pop(), child.value));
-        continue;
-      }
-      if (child.nodes) {
-        walk(child, node);
-      }
-    }
-    return queue;
-  };
-  return utils.flatten(walk(ast));
-};
-var expand_1 = expand;
-
-export { expand_1 };