@quilted/create 0.1.56 → 0.1.57

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

@@ -0,0 +1,337 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var stringify$1 = require('./stringify.cjs');
+var constants = require('./constants.cjs');
+
+const stringify = stringify$1["default"];
+
+/**
+ * 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
+} = constants["default"];
+
+/**
+ * parse
+ */
+
+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;
+
+  /**
+   * 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) {
+      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;
+    }
+
+    /**
+     * Left curly brace: '{'
+     */
+
+    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;
+    }
+
+    /**
+     * Right curly brace: '}'
+     */
+
+    if (value === CHAR_RIGHT_CURLY_BRACE) {
+      if (block.type !== 'brace') {
+        push({ type: 'text', value });
+        continue;
+      }
+
+      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) }];
+      }
+
+      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 });
+        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;
+      }
+
+      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)
+      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);
+    }
+  } while (stack.length > 0);
+
+  push({ type: 'eos' });
+  return ast;
+};
+
+var parse_1 = parse;
+
+exports["default"] = parse_1;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./utils.cjs');
+var utils$1 = require('../../../../../../_virtual/utils2.cjs');
+
+const utils = utils$1.__exports;
+
+var stringify = (ast, options = {}) => {
+  let stringify = (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;
+    }
+
+    if (node.value) {
+      return node.value;
+    }
+
+    if (node.nodes) {
+      for (let child of node.nodes) {
+        output += stringify(child);
+      }
+    }
+    return output;
+  };
+
+  return stringify(ast);
+};
+
+exports["default"] = stringify;

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

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('../../../../../../_virtual/utils2.cjs');
+
+(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.__exports));
+
+exports["default"] = utils.__exports;

package/build/cjs/node_modules/.pnpm/colorette@2.0.16/node_modules/colorette/index.cjs

@@ -0,0 +1,227 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../../../../../_virtual/index.cjs');
+var require$$0 = require('node:tty');
+
+Object.defineProperty(index.__exports, '__esModule', { value: true });
+
+var tty = require$$0;
+
+function _interopNamespace$1(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var tty__namespace = /*#__PURE__*/_interopNamespace$1(tty);
+
+const env = process.env || {};
+const argv = process.argv || [];
+
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = process.platform === "win32";
+
+const isCompatibleTerminal =
+  tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && env.TERM !== "dumb";
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled && (isForced || isWindows || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
+
+const none = (any) => any;
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: none }),
+        {}
+      );
+
+const {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright,
+} = createColors();
+
+index.__exports.bgBlack = bgBlack;
+index.__exports.bgBlackBright = bgBlackBright;
+index.__exports.bgBlue = bgBlue;
+index.__exports.bgBlueBright = bgBlueBright;
+index.__exports.bgCyan = bgCyan;
+index.__exports.bgCyanBright = bgCyanBright;
+index.__exports.bgGreen = bgGreen;
+index.__exports.bgGreenBright = bgGreenBright;
+index.__exports.bgMagenta = bgMagenta;
+index.__exports.bgMagentaBright = bgMagentaBright;
+index.__exports.bgRed = bgRed;
+index.__exports.bgRedBright = bgRedBright;
+index.__exports.bgWhite = bgWhite;
+index.__exports.bgWhiteBright = bgWhiteBright;
+index.__exports.bgYellow = bgYellow;
+index.__exports.bgYellowBright = bgYellowBright;
+index.__exports.black = black;
+index.__exports.blackBright = blackBright;
+index.__exports.blue = blue;
+index.__exports.blueBright = blueBright;
+var bold_1 = index.__exports.bold = bold;
+index.__exports.createColors = createColors;
+var cyan_1 = index.__exports.cyan = cyan;
+index.__exports.cyanBright = cyanBright;
+var dim_1 = index.__exports.dim = dim;
+index.__exports.gray = gray;
+index.__exports.green = green;
+index.__exports.greenBright = greenBright;
+index.__exports.hidden = hidden;
+index.__exports.inverse = inverse;
+index.__exports.isColorSupported = isColorSupported;
+index.__exports.italic = italic;
+var magenta_1 = index.__exports.magenta = magenta;
+index.__exports.magentaBright = magentaBright;
+index.__exports.red = red;
+index.__exports.redBright = redBright;
+index.__exports.reset = reset;
+index.__exports.strikethrough = strikethrough;
+var underline_1 = index.__exports.underline = underline;
+index.__exports.white = white;
+index.__exports.whiteBright = whiteBright;
+index.__exports.yellow = yellow;
+index.__exports.yellowBright = yellowBright;
+
+exports["default"] = index.__exports;
+exports.bold = bold_1;
+exports.cyan = cyan_1;
+exports.dim = dim_1;
+exports.magenta = magenta_1;
+exports.underline = underline_1;