@quilted/create 0.2.43 → 0.2.45

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

@@ -0,0 +1,100 @@
+import { __require as requireFillRange } from '../../../../fill-range@7.1.1/node_modules/fill-range/index.mjs';
+import { __require as requireStringify } from './stringify.mjs';
+import { __require as requireUtils } from './utils.mjs';
+
+var expand_1;
+var hasRequiredExpand;
+function requireExpand() {
+  if (hasRequiredExpand) return expand_1;
+  hasRequiredExpand = 1;
+  const fill = requireFillRange();
+  const stringify = requireStringify();
+  const utils = requireUtils();
+  const append = (queue = '', stash = '', enclose = false) => {
+    const 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 (const item of queue) {
+      if (Array.isArray(item)) {
+        for (const 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 = {}) => {
+    const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
+    const 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) {
+        const 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;
+      }
+      const 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++) {
+        const 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));
+  };
+  expand_1 = expand;
+  return expand_1;
+}
+
+export { requireExpand as __require };

package/build/esm/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.mjs

@@ -0,0 +1,374 @@
+import { __require as requireStringify } from './stringify.mjs';
+import { __require as requireConstants } from './constants.mjs';
+
+var parse_1;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse_1;
+  hasRequiredParse = 1;
+  const stringify = requireStringify();
+
+  /**
+   * 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_NO_BREAK_SPACE,
+    CHAR_ZERO_WIDTH_NOBREAK_SPACE
+  } = requireConstants();
+
+  /**
+   * parse
+   */
+
+  const parse = (input, options = {}) => {
+    if (typeof input !== 'string') {
+      throw new TypeError('Expected a string');
+    }
+    const opts = options || {};
+    const 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})`);
+    }
+    const ast = {
+      type: 'root',
+      input,
+      nodes: []
+    };
+    const stack = [ast];
+    let block = ast;
+    let prev = ast;
+    let brackets = 0;
+    const length = input.length;
+    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';
+      }
+      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();
+
+      /**
+       * 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()
+        });
+        continue;
+      }
+
+      /**
+       * Right square bracket (literal): ']'
+       */
+
+      if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+        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
+        });
+        continue;
+      }
+
+      /**
+       * Parentheses
+       */
+
+      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;
+      }
+
+      /**
+       * Quotes: '|"|`
+       */
+
+      if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+        const 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;
+      }
+
+      /**
+       * Left curly brace: '{'
+       */
+
+      if (value === CHAR_LEFT_CURLY_BRACE) {
+        depth++;
+        const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+        const 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;
+      }
+
+      /**
+       * Right curly brace: '}'
+       */
+
+      if (value === CHAR_RIGHT_CURLY_BRACE) {
+        if (block.type !== 'brace') {
+          push({
+            type: 'text',
+            value
+          });
+          continue;
+        }
+        const 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;
+          const open = block.nodes.shift();
+          block.nodes = [open, {
+            type: 'text',
+            value: stringify(block)
+          }];
+        }
+        push({
+          type: 'comma',
+          value
+        });
+        block.commas++;
+        continue;
+      }
+
+      /**
+       * Dot: '.'
+       */
+
+      if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+        const 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();
+          const before = siblings[siblings.length - 1];
+          before.value += prev.value + value;
+          prev = before;
+          block.ranges--;
+          continue;
+        }
+        push({
+          type: 'dot',
+          value
+        });
+        continue;
+      }
+
+      /**
+       * Text
+       */
+
+      push({
+        type: 'text',
+        value
+      });
+    }
+
+    // Mark imbalanced braces and brackets as invalid
+    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;
+          }
+        });
+
+        // get the location of the block on parent.nodes (block's siblings)
+        const parent = stack[stack.length - 1];
+        const index = parent.nodes.indexOf(block);
+        // replace the (invalid) block with it's nodes
+        parent.nodes.splice(index, 1, ...block.nodes);
+      }
+    } while (stack.length > 0);
+    push({
+      type: 'eos'
+    });
+    return ast;
+  };
+  parse_1 = parse;
+  return parse_1;
+}
+
+export { requireParse as __require };

package/build/esm/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.mjs

@@ -0,0 +1,35 @@
+import { __require as requireUtils } from './utils.mjs';
+
+var stringify;
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify;
+  hasRequiredStringify = 1;
+  const utils = requireUtils();
+  stringify = (ast, options = {}) => {
+    const stringify = (node, parent = {}) => {
+      const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+      const invalidNode = node.invalid === true && options.escapeInvalid === true;
+      let output = '';
+      if (node.value) {
+        if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+          return '\\' + node.value;
+        }
+        return node.value;
+      }
+      if (node.value) {
+        return node.value;
+      }
+      if (node.nodes) {
+        for (const child of node.nodes) {
+          output += stringify(child);
+        }
+      }
+      return output;
+    };
+    return stringify(ast);
+  };
+  return stringify;
+}
+
+export { requireStringify as __require };

package/build/esm/node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.mjs

@@ -0,0 +1,128 @@
+import { __exports as utils } from '../../../../../../_virtual/utils2.mjs';
+
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (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) => {
+      const 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++) {
+          const ele = arr[i];
+          if (Array.isArray(ele)) {
+            flat(ele);
+            continue;
+          }
+          if (ele !== undefined) {
+            result.push(ele);
+          }
+        }
+        return result;
+      };
+      flat(args);
+      return result;
+    };
+  })(utils);
+  return utils;
+}
+
+export { requireUtils as __require };

package/build/esm/node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/splitStringTransformer/splitStringTransformer.mjs

@@ -1,12 +1,10 @@
 var splitStringTransformer = function splitStringTransformer(splitBy) {
   return {
     onSubstitution: function onSubstitution(substitution, resultSoFar) {
-      if (splitBy != null && typeof splitBy === 'string') {
+      {
         if (typeof substitution === 'string' && substitution.includes(splitBy)) {
           substitution = substitution.split(splitBy);
         }
-      } else {
-        throw new Error('You need to specify a string character to split by.');
       }
       return substitution;
     }