@quilted/create 0.1.90 → 0.2.1

package/build/esm/node_modules/.pnpm/slash@4.0.0/node_modules/slash/index.mjs

@@ -1,12 +1,11 @@
 function slash(path) {
-	const isExtendedLengthPath = /^\\\\\?\\/.test(path);
-	const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+  const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
 
-	if (isExtendedLengthPath || hasNonAscii) {
-		return path;
-	}
-
-	return path.replace(/\\/g, '/');
+  if (isExtendedLengthPath || hasNonAscii) {
+    return path;
+  }
+  return path.replace(/\\/g, '/');
 }
 
 export { slash as default };

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

@@ -6,40 +6,34 @@ import { i as isNumber$1 } from '../../../is-number@7.0.0/node_modules/is-number
  * 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');
   }
-
   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.');
   }
-
-  let opts = { relaxZeros: true, ...options };
+  let opts = {
+    relaxZeros: true,
+    ...options
+  };
   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;
-
   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;
     if (opts.capture) {
@@ -50,41 +44,38 @@ const toRegexRange = (min, max, options) => {
     }
     return `(?:${result})`;
   }
-
   let isPadded = hasPadding(min) || hasPadding(max);
-  let state = { min, max, a, b };
+  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) || [];
@@ -92,28 +83,22 @@ function collatePatterns(neg, pos, options) {
   let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
   return subpatterns.join('|');
 }
-
 function splitToRanges(min, max) {
   let nines = 1;
   let zeros = 1;
-
   let stop = countNines(min, nines);
   let stops = 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;
@@ -128,75 +113,69 @@ function splitToRanges(min, max) {
 
 function rangeToPattern(start, stop, options) {
   if (start === stop) {
-    return { pattern: start, count: [], digits: 0 };
+    return {
+      pattern: start,
+      count: [],
+      digits: 0
+    };
   }
-
   let zipped = zip(start, stop);
   let digits = zipped.length;
   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') {
       pattern += toCharacterClass(startDigit, stopDigit);
-
     } else {
       count++;
     }
   }
-
   if (count) {
     pattern += options.shorthand === true ? '\\d' : '[0-9]';
   }
-
-  return { pattern, count: [count], digits };
+  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 = '';
-
     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;
       continue;
     }
-
     if (tok.isPadded) {
       zeros = padZeros(max, tok, options);
     }
-
     obj.string = zeros + obj.pattern + toQuantifier(obj.count);
     tokens.push(obj);
     start = max + 1;
     prev = obj;
   }
-
   return tokens;
 }
-
 function filterPatterns(arr, comparison, prefix, intersection, options) {
   let result = [];
-
   for (let ele of arr) {
-    let { string } = ele;
+    let {
+      string
+    } = ele;
 
     // only push if _both_ are negative...
     if (!intersection && !contains(comparison, 'string', string)) {
@@ -220,23 +199,18 @@ function zip(a, b) {
   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);
 }
-
 function countNines(min, 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;
   if (stop || start > 1) {
@@ -244,23 +218,18 @@ function toQuantifier(digits) {
   }
   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 '';
@@ -268,9 +237,10 @@ function padZeros(value, tok, options) {
       return relax ? '0?' : '0';
     case 2:
       return relax ? '0{0,2}' : '00';
-    default: {
-      return relax ? `0{0,${diff}}` : `0{${diff}}`;
-    }
+    default:
+      {
+        return relax ? `0{0,${diff}}` : `0{${diff}}`;
+      }
   }
 }
 
@@ -279,7 +249,7 @@ function padZeros(value, tok, options) {
  */
 
 toRegexRange.cache = {};
-toRegexRange.clearCache = () => (toRegexRange.cache = {});
+toRegexRange.clearCache = () => toRegexRange.cache = {};
 
 /**
  * Expose `toRegexRange`

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

@@ -0,0 +1,58 @@
+import { isMap, isNode } from '../nodes/Node.mjs';
+import { Scalar } from '../nodes/Scalar.mjs';
+import { resolveBlockMap } from './resolve-block-map.mjs';
+import { resolveBlockSeq } from './resolve-block-seq.mjs';
+import { resolveFlowCollection } from './resolve-flow-collection.mjs';
+
+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;
+  // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
+  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/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-doc.mjs

@@ -0,0 +1,41 @@
+import { Document } from '../doc/Document.mjs';
+import { composeNode, composeEmptyNode } from './compose-node.mjs';
+import { resolveEnd } from './resolve-end.mjs';
+import { resolveProps } from './resolve-props.mjs';
+
+function composeDoc(options, directives, {
+  offset,
+  start,
+  value,
+  end
+}, onError) {
+  const opts = Object.assign({
+    _directives: directives
+  }, options);
+  const doc = new Document(undefined, 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/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-node.mjs

@@ -0,0 +1,93 @@
+import { Alias } from '../nodes/Alias.mjs';
+import { composeCollection } from './compose-collection.mjs';
+import { composeScalar } from './compose-scalar.mjs';
+import { resolveEnd } from './resolve-end.mjs';
+import { emptyScalarPosition } from './util-empty-scalar-position.mjs';
+
+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, undefined, 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;
+  }
+  // @ts-expect-error Type checking misses meaning of isSrcToken
+  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/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/compose/compose-scalar.mjs

@@ -0,0 +1,71 @@
+import { SCALAR, isScalar } from '../nodes/Node.mjs';
+import { Scalar } from '../nodes/Scalar.mjs';
+import { resolveBlockScalar } from './resolve-block-scalar.mjs';
+import { resolveFlowScalar } from './resolve-flow-scalar.mjs';
+
+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]; // non-specific tag
+  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) {
+    // Ensure that the known tag is available for stringifying,
+    // but does not get used by default.
+    schema.tags.push(Object.assign({}, kt, {
+      default: false,
+      test: undefined
+    }));
+    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(tag => tag.default && tag.test?.test(value)) || schema[SCALAR];
+  if (schema.compat) {
+    const compat = schema.compat.find(tag => tag.default && tag.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 };