@quilted/create 0.1.90 → 0.2.0

package/build/esnext/node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.esnext

@@ -1,47 +1,32 @@
 import { i as isNumber$1 } from '../../../is-number@7.0.0/node_modules/is-number/index.esnext';
 
-/*!
- * to-regex-range <https://github.com/micromatch/to-regex-range>
- *
- * Copyright (c) 2015-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-
 const isNumber = isNumber$1;
-
 const toRegexRange = (min, max, options) => {
   if (isNumber(min) === false) {
-    throw new TypeError('toRegexRange: expected the first argument to be a number');
+    throw new TypeError("toRegexRange: expected the first argument to be a number");
   }
-
   if (max === void 0 || min === max) {
     return String(min);
   }
-
   if (isNumber(max) === false) {
-    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+    throw new TypeError("toRegexRange: expected the second argument to be a number.");
   }
-
   let opts = { relaxZeros: true, ...options };
-  if (typeof opts.strictZeros === 'boolean') {
+  if (typeof opts.strictZeros === "boolean") {
     opts.relaxZeros = opts.strictZeros === false;
   }
-
   let relax = String(opts.relaxZeros);
   let shorthand = String(opts.shorthand);
   let capture = String(opts.capture);
   let wrap = String(opts.wrap);
-  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
-
+  let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
   if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
     return toRegexRange.cache[cacheKey].result;
   }
-
   let a = Math.min(min, max);
   let b = Math.max(min, max);
-
   if (Math.abs(a - b) === 1) {
-    let result = min + '|' + max;
+    let result = min + "|" + max;
     if (opts.capture) {
       return `(${result})`;
     }
@@ -50,241 +35,175 @@ const toRegexRange = (min, max, options) => {
     }
     return `(?:${result})`;
   }
-
   let isPadded = hasPadding(min) || hasPadding(max);
   let state = { min, max, a, b };
   let positives = [];
   let negatives = [];
-
   if (isPadded) {
     state.isPadded = isPadded;
     state.maxLen = String(state.max).length;
   }
-
   if (a < 0) {
     let newMin = b < 0 ? Math.abs(b) : 1;
     negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
     a = state.a = 0;
   }
-
   if (b >= 0) {
     positives = splitToPatterns(a, b, state, opts);
   }
-
   state.negatives = negatives;
   state.positives = positives;
   state.result = collatePatterns(negatives, positives);
-
   if (opts.capture === true) {
     state.result = `(${state.result})`;
-  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+  } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
     state.result = `(?:${state.result})`;
   }
-
   toRegexRange.cache[cacheKey] = state;
   return state.result;
 };
-
 function collatePatterns(neg, pos, options) {
-  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
-  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
-  let intersected = filterPatterns(neg, pos, '-?', true) || [];
+  let onlyNegative = filterPatterns(neg, pos, "-", false) || [];
+  let onlyPositive = filterPatterns(pos, neg, "", false) || [];
+  let intersected = filterPatterns(neg, pos, "-?", true) || [];
   let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
-  return subpatterns.join('|');
+  return subpatterns.join("|");
 }
-
 function splitToRanges(min, max) {
   let nines = 1;
   let zeros = 1;
-
   let stop = countNines(min, nines);
-  let stops = new Set([max]);
-
+  let stops = /* @__PURE__ */ new Set([max]);
   while (min <= stop && stop <= max) {
     stops.add(stop);
     nines += 1;
     stop = countNines(min, nines);
   }
-
   stop = countZeros(max + 1, zeros) - 1;
-
   while (min < stop && stop <= max) {
     stops.add(stop);
     zeros += 1;
     stop = countZeros(max + 1, zeros) - 1;
   }
-
   stops = [...stops];
   stops.sort(compare);
   return stops;
 }
-
-/**
- * Convert a range to a regex pattern
- * @param {Number} `start`
- * @param {Number} `stop`
- * @return {String}
- */
-
 function rangeToPattern(start, stop, options) {
   if (start === stop) {
     return { pattern: start, count: [], digits: 0 };
   }
-
   let zipped = zip(start, stop);
   let digits = zipped.length;
-  let pattern = '';
+  let pattern = "";
   let count = 0;
-
   for (let i = 0; i < digits; i++) {
     let [startDigit, stopDigit] = zipped[i];
-
     if (startDigit === stopDigit) {
       pattern += startDigit;
-
-    } else if (startDigit !== '0' || stopDigit !== '9') {
+    } else if (startDigit !== "0" || stopDigit !== "9") {
       pattern += toCharacterClass(startDigit, stopDigit);
-
     } else {
       count++;
     }
   }
-
   if (count) {
-    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+    pattern += options.shorthand === true ? "\\d" : "[0-9]";
   }
-
   return { pattern, count: [count], digits };
 }
-
 function splitToPatterns(min, max, tok, options) {
   let ranges = splitToRanges(min, max);
   let tokens = [];
   let start = min;
   let prev;
-
   for (let i = 0; i < ranges.length; i++) {
-    let max = ranges[i];
-    let obj = rangeToPattern(String(start), String(max), options);
-    let zeros = '';
-
+    let max2 = ranges[i];
+    let obj = rangeToPattern(String(start), String(max2), options);
+    let zeros = "";
     if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
       if (prev.count.length > 1) {
         prev.count.pop();
       }
-
       prev.count.push(obj.count[0]);
       prev.string = prev.pattern + toQuantifier(prev.count);
-      start = max + 1;
+      start = max2 + 1;
       continue;
     }
-
     if (tok.isPadded) {
-      zeros = padZeros(max, tok, options);
+      zeros = padZeros(max2, tok, options);
     }
-
     obj.string = zeros + obj.pattern + toQuantifier(obj.count);
     tokens.push(obj);
-    start = max + 1;
+    start = max2 + 1;
     prev = obj;
   }
-
   return tokens;
 }
-
 function filterPatterns(arr, comparison, prefix, intersection, options) {
   let result = [];
-
   for (let ele of arr) {
     let { string } = ele;
-
-    // only push if _both_ are negative...
-    if (!intersection && !contains(comparison, 'string', string)) {
+    if (!intersection && !contains(comparison, "string", string)) {
       result.push(prefix + string);
     }
-
-    // or _both_ are positive
-    if (intersection && contains(comparison, 'string', string)) {
+    if (intersection && contains(comparison, "string", string)) {
       result.push(prefix + string);
     }
   }
   return result;
 }
-
-/**
- * Zip strings
- */
-
 function zip(a, b) {
   let arr = [];
-  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+  for (let i = 0; i < a.length; i++)
+    arr.push([a[i], b[i]]);
   return arr;
 }
-
 function compare(a, b) {
   return a > b ? 1 : b > a ? -1 : 0;
 }
-
 function contains(arr, key, val) {
-  return arr.some(ele => ele[key] === val);
+  return arr.some((ele) => ele[key] === val);
 }
-
 function countNines(min, len) {
-  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+  return Number(String(min).slice(0, -len) + "9".repeat(len));
 }
-
 function countZeros(integer, zeros) {
-  return integer - (integer % Math.pow(10, zeros));
+  return integer - integer % Math.pow(10, zeros);
 }
-
 function toQuantifier(digits) {
-  let [start = 0, stop = ''] = digits;
+  let [start = 0, stop = ""] = digits;
   if (stop || start > 1) {
-    return `{${start + (stop ? ',' + stop : '')}}`;
+    return `{${start + (stop ? "," + stop : "")}}`;
   }
-  return '';
+  return "";
 }
-
 function toCharacterClass(a, b, options) {
-  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+  return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
 }
-
 function hasPadding(str) {
   return /^-?(0+)\d/.test(str);
 }
-
 function padZeros(value, tok, options) {
   if (!tok.isPadded) {
     return value;
   }
-
   let diff = Math.abs(tok.maxLen - String(value).length);
   let relax = options.relaxZeros !== false;
-
   switch (diff) {
     case 0:
-      return '';
+      return "";
     case 1:
-      return relax ? '0?' : '0';
+      return relax ? "0?" : "0";
     case 2:
-      return relax ? '0{0,2}' : '00';
+      return relax ? "0{0,2}" : "00";
     default: {
       return relax ? `0{0,${diff}}` : `0{${diff}}`;
     }
   }
 }
-
-/**
- * Cache
- */
-
 toRegexRange.cache = {};
-toRegexRange.clearCache = () => (toRegexRange.cache = {});
-
-/**
- * Expose `toRegexRange`
- */
-
+toRegexRange.clearCache = () => toRegexRange.cache = {};
 var toRegexRange_1 = toRegexRange;
 
 export { toRegexRange_1 as t };

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-collection.esnext

@@ -0,0 +1,55 @@
+import { isMap, isNode } from '../nodes/Node.esnext';
+import { Scalar } from '../nodes/Scalar.esnext';
+import { resolveBlockMap } from './resolve-block-map.esnext';
+import { resolveBlockSeq } from './resolve-block-seq.esnext';
+import { resolveFlowCollection } from './resolve-flow-collection.esnext';
+
+function composeCollection(CN, ctx, token, tagToken, onError) {
+  let coll;
+  switch (token.type) {
+    case "block-map": {
+      coll = resolveBlockMap(CN, ctx, token, onError);
+      break;
+    }
+    case "block-seq": {
+      coll = resolveBlockSeq(CN, ctx, token, onError);
+      break;
+    }
+    case "flow-collection": {
+      coll = resolveFlowCollection(CN, ctx, token, onError);
+      break;
+    }
+  }
+  if (!tagToken)
+    return coll;
+  const tagName = ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg));
+  if (!tagName)
+    return coll;
+  const Coll = coll.constructor;
+  if (tagName === "!" || tagName === Coll.tagName) {
+    coll.tag = Coll.tagName;
+    return coll;
+  }
+  const expType = isMap(coll) ? "map" : "seq";
+  let tag = ctx.schema.tags.find((t) => t.collection === expType && t.tag === tagName);
+  if (!tag) {
+    const kt = ctx.schema.knownTags[tagName];
+    if (kt && kt.collection === expType) {
+      ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+      tag = kt;
+    } else {
+      onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, true);
+      coll.tag = tagName;
+      return coll;
+    }
+  }
+  const res = tag.resolve(coll, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg), ctx.options);
+  const node = isNode(res) ? res : new Scalar(res);
+  node.range = coll.range;
+  node.tag = tagName;
+  if (tag?.format)
+    node.format = tag.format;
+  return node;
+}
+
+export { composeCollection };

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-doc.esnext

@@ -0,0 +1,36 @@
+import { Document } from '../doc/Document.esnext';
+import { composeNode, composeEmptyNode } from './compose-node.esnext';
+import { resolveEnd } from './resolve-end.esnext';
+import { resolveProps } from './resolve-props.esnext';
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+  const opts = Object.assign({ _directives: directives }, options);
+  const doc = new Document(void 0, opts);
+  const ctx = {
+    atRoot: true,
+    directives: doc.directives,
+    options: doc.options,
+    schema: doc.schema
+  };
+  const props = resolveProps(start, {
+    indicator: "doc-start",
+    next: value ?? end?.[0],
+    offset,
+    onError,
+    startOnNewline: true
+  });
+  if (props.found) {
+    doc.directives.docStart = true;
+    if (value && (value.type === "block-map" || value.type === "block-seq") && !props.hasNewline)
+      onError(props.end, "MISSING_CHAR", "Block collection cannot start on same line with directives-end marker");
+  }
+  doc.contents = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+  const contentEnd = doc.contents.range[2];
+  const re = resolveEnd(end, contentEnd, false, onError);
+  if (re.comment)
+    doc.comment = re.comment;
+  doc.range = [offset, contentEnd, re.offset];
+  return doc;
+}
+
+export { composeDoc };

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-node.esnext

@@ -0,0 +1,87 @@
+import { Alias } from '../nodes/Alias.esnext';
+import { composeCollection } from './compose-collection.esnext';
+import { composeScalar } from './compose-scalar.esnext';
+import { resolveEnd } from './resolve-end.esnext';
+import { emptyScalarPosition } from './util-empty-scalar-position.esnext';
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+  const { spaceBefore, comment, anchor, tag } = props;
+  let node;
+  let isSrcToken = true;
+  switch (token.type) {
+    case "alias":
+      node = composeAlias(ctx, token, onError);
+      if (anchor || tag)
+        onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
+      break;
+    case "scalar":
+    case "single-quoted-scalar":
+    case "double-quoted-scalar":
+    case "block-scalar":
+      node = composeScalar(ctx, token, tag, onError);
+      if (anchor)
+        node.anchor = anchor.source.substring(1);
+      break;
+    case "block-map":
+    case "block-seq":
+    case "flow-collection":
+      node = composeCollection(CN, ctx, token, tag, onError);
+      if (anchor)
+        node.anchor = anchor.source.substring(1);
+      break;
+    default: {
+      const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
+      onError(token, "UNEXPECTED_TOKEN", message);
+      node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
+      isSrcToken = false;
+    }
+  }
+  if (anchor && node.anchor === "")
+    onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+  if (spaceBefore)
+    node.spaceBefore = true;
+  if (comment) {
+    if (token.type === "scalar" && token.source === "")
+      node.comment = comment;
+    else
+      node.commentBefore = comment;
+  }
+  if (ctx.options.keepSourceTokens && isSrcToken)
+    node.srcToken = token;
+  return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
+  const token = {
+    type: "scalar",
+    offset: emptyScalarPosition(offset, before, pos),
+    indent: -1,
+    source: ""
+  };
+  const node = composeScalar(ctx, token, tag, onError);
+  if (anchor) {
+    node.anchor = anchor.source.substring(1);
+    if (node.anchor === "")
+      onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+  }
+  if (spaceBefore)
+    node.spaceBefore = true;
+  if (comment)
+    node.comment = comment;
+  return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+  const alias = new Alias(source.substring(1));
+  if (alias.source === "")
+    onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
+  if (alias.source.endsWith(":"))
+    onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
+  const valueEnd = offset + source.length;
+  const re = resolveEnd(end, valueEnd, options.strict, onError);
+  alias.range = [offset, valueEnd, re.offset];
+  if (re.comment)
+    alias.comment = re.comment;
+  return alias;
+}
+
+export { composeEmptyNode, composeNode };

package/build/esnext/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-scalar.esnext

@@ -0,0 +1,68 @@
+import { SCALAR, isScalar } from '../nodes/Node.esnext';
+import { Scalar } from '../nodes/Scalar.esnext';
+import { resolveBlockScalar } from './resolve-block-scalar.esnext';
+import { resolveFlowScalar } from './resolve-flow-scalar.esnext';
+
+function composeScalar(ctx, token, tagToken, onError) {
+  const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(token, ctx.options.strict, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
+  const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
+  const tag = tagToken && tagName ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError) : token.type === "scalar" ? findScalarTagByTest(ctx, value, token, onError) : ctx.schema[SCALAR];
+  let scalar;
+  try {
+    const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+    scalar = isScalar(res) ? res : new Scalar(res);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
+    scalar = new Scalar(value);
+  }
+  scalar.range = range;
+  scalar.source = value;
+  if (type)
+    scalar.type = type;
+  if (tagName)
+    scalar.tag = tagName;
+  if (tag.format)
+    scalar.format = tag.format;
+  if (comment)
+    scalar.comment = comment;
+  return scalar;
+}
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+  if (tagName === "!")
+    return schema[SCALAR];
+  const matchWithTest = [];
+  for (const tag of schema.tags) {
+    if (!tag.collection && tag.tag === tagName) {
+      if (tag.default && tag.test)
+        matchWithTest.push(tag);
+      else
+        return tag;
+    }
+  }
+  for (const tag of matchWithTest)
+    if (tag.test?.test(value))
+      return tag;
+  const kt = schema.knownTags[tagName];
+  if (kt && !kt.collection) {
+    schema.tags.push(Object.assign({}, kt, { default: false, test: void 0 }));
+    return kt;
+  }
+  onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
+  return schema[SCALAR];
+}
+function findScalarTagByTest({ directives, schema }, value, token, onError) {
+  const tag = schema.tags.find((tag2) => tag2.default && tag2.test?.test(value)) || schema[SCALAR];
+  if (schema.compat) {
+    const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema[SCALAR];
+    if (tag.tag !== compat.tag) {
+      const ts = directives.tagString(tag.tag);
+      const cs = directives.tagString(compat.tag);
+      const msg = `Value may be parsed as either ${ts} or ${cs}`;
+      onError(token, "TAG_RESOLVE_FAILED", msg, true);
+    }
+  }
+  return tag;
+}
+
+export { composeScalar };