@quilted/create 0.1.56 → 0.1.58

package/build/esnext/node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.esnext

@@ -0,0 +1,67 @@
+var src;
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+
+	const ESC = '\x1B';
+	const CSI = `${ESC}[`;
+	const beep = '\u0007';
+
+	const cursor = {
+	  to(x, y) {
+	    if (!y) return `${CSI}${x + 1}G`;
+	    return `${CSI}${y + 1};${x + 1}H`;
+	  },
+	  move(x, y) {
+	    let ret = '';
+
+	    if (x < 0) ret += `${CSI}${-x}D`;
+	    else if (x > 0) ret += `${CSI}${x}C`;
+
+	    if (y < 0) ret += `${CSI}${-y}A`;
+	    else if (y > 0) ret += `${CSI}${y}B`;
+
+	    return ret;
+	  },
+	  up: (count = 1) => `${CSI}${count}A`,
+	  down: (count = 1) => `${CSI}${count}B`,
+	  forward: (count = 1) => `${CSI}${count}C`,
+	  backward: (count = 1) => `${CSI}${count}D`,
+	  nextLine: (count = 1) => `${CSI}E`.repeat(count),
+	  prevLine: (count = 1) => `${CSI}F`.repeat(count),
+	  left: `${CSI}G`,
+	  hide: `${CSI}?25l`,
+	  show: `${CSI}?25h`,
+	  save: `${ESC}7`,
+	  restore: `${ESC}8`
+	};
+
+	const scroll = {
+	  up: (count = 1) => `${CSI}S`.repeat(count),
+	  down: (count = 1) => `${CSI}T`.repeat(count)
+	};
+
+	const erase = {
+	  screen: `${CSI}2J`,
+	  up: (count = 1) => `${CSI}1J`.repeat(count),
+	  down: (count = 1) => `${CSI}J`.repeat(count),
+	  line: `${CSI}2K`,
+	  lineEnd: `${CSI}K`,
+	  lineStart: `${CSI}1K`,
+	  lines(count) {
+	    let clear = '';
+	    for (let i = 0; i < count; i++)
+	      clear += this.line + (i < count - 1 ? cursor.up() : '');
+	    if (count)
+	      clear += cursor.left;
+	    return clear;
+	  }
+	};
+
+	src = { cursor, scroll, erase, beep };
+	return src;
+}
+
+export { requireSrc as __require };

package/build/esnext/node_modules/.pnpm/slash@4.0.0/node_modules/slash/index.esnext

@@ -0,0 +1,12 @@
+function slash(path) {
+	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, '/');
+}
+
+export { slash as default };

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

@@ -0,0 +1,290 @@
+import 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');
+  }
+
+  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 };
+  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) {
+      return `(${result})`;
+    }
+    if (opts.wrap === false) {
+      return result;
+    }
+    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) {
+    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 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;
+}
+
+/**
+ * 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 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 };
+}
+
+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;
+
+    // only push if _both_ are negative...
+    if (!intersection && !contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+
+    // or _both_ are positive
+    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]]);
+  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));
+}
+
+function toQuantifier(digits) {
+  let [start = 0, stop = ''] = digits;
+  if (stop || start > 1) {
+    return `{${start + (stop ? ',' + stop : '')}}`;
+  }
+  return '';
+}
+
+function toCharacterClass(a, b, options) {
+  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 '';
+    case 1:
+      return relax ? '0?' : '0';
+    case 2:
+      return relax ? '0{0,2}' : '00';
+    default: {
+      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+    }
+  }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange.cache = {};
+toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+var toRegexRange_1 = toRegexRange;
+
+export { toRegexRange_1 as default };

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

@@ -0,0 +1,72 @@
+import { __exports as composeCollection$1 } from '../../../../../../../_virtual/compose-collection.esnext';
+export { __exports as default } from '../../../../../../../_virtual/compose-collection.esnext';
+import '../nodes/Node.esnext';
+import '../nodes/Scalar.esnext';
+import './resolve-block-map.esnext';
+import './resolve-block-seq.esnext';
+import './resolve-flow-collection.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.esnext';
+import { __exports as resolveBlockMap$1 } from '../../../../../../../_virtual/resolve-block-map.esnext';
+import { __exports as resolveBlockSeq$1 } from '../../../../../../../_virtual/resolve-block-seq.esnext';
+import { __exports as resolveFlowCollection$1 } from '../../../../../../../_virtual/resolve-flow-collection.esnext';
+
+var Node = Node$1;
+var Scalar = Scalar$1;
+var resolveBlockMap = resolveBlockMap$1;
+var resolveBlockSeq = resolveBlockSeq$1;
+var resolveFlowCollection = resolveFlowCollection$1;
+
+function composeCollection(CN, ctx, token, tagToken, onError) {
+    let coll;
+    switch (token.type) {
+        case 'block-map': {
+            coll = resolveBlockMap.resolveBlockMap(CN, ctx, token, onError);
+            break;
+        }
+        case 'block-seq': {
+            coll = resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError);
+            break;
+        }
+        case 'flow-collection': {
+            coll = resolveFlowCollection.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 = Node.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 = Node.isNode(res)
+        ? res
+        : new Scalar.Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+composeCollection$1.composeCollection = composeCollection;

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

@@ -0,0 +1,51 @@
+import { __exports as composeDoc$1 } from '../../../../../../../_virtual/compose-doc.esnext';
+export { __exports as default } from '../../../../../../../_virtual/compose-doc.esnext';
+import '../doc/Document.esnext';
+import './compose-node.esnext';
+import './resolve-end.esnext';
+import './resolve-props.esnext';
+import { __exports as Document$1 } from '../../../../../../../_virtual/Document.esnext';
+import { __exports as composeNode$1 } from '../../../../../../../_virtual/compose-node.esnext';
+import { __exports as resolveEnd$1 } from '../../../../../../../_virtual/resolve-end.esnext';
+import { __exports as resolveProps$1 } from '../../../../../../../_virtual/resolve-props.esnext';
+
+var Document = Document$1;
+var composeNode = composeNode$1;
+var resolveEnd = resolveEnd$1;
+var resolveProps = resolveProps$1;
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document.Document(undefined, opts);
+    const ctx = {
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps.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.composeNode(ctx, value, props, onError)
+        : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd.resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+composeDoc$1.composeDoc = composeDoc;

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

@@ -0,0 +1,104 @@
+import { __exports as composeNode$1 } from '../../../../../../../_virtual/compose-node.esnext';
+export { __exports as default } from '../../../../../../../_virtual/compose-node.esnext';
+import '../nodes/Alias.esnext';
+import './compose-collection.esnext';
+import './compose-scalar.esnext';
+import './resolve-end.esnext';
+import './util-empty-scalar-position.esnext';
+import { __exports as Alias$1 } from '../../../../../../../_virtual/Alias.esnext';
+import { __exports as composeCollection$1 } from '../../../../../../../_virtual/compose-collection.esnext';
+import { __exports as composeScalar$1 } from '../../../../../../../_virtual/compose-scalar.esnext';
+import { __exports as resolveEnd$1 } from '../../../../../../../_virtual/resolve-end.esnext';
+import { __exports as utilEmptyScalarPosition$1 } from '../../../../../../../_virtual/util-empty-scalar-position.esnext';
+
+var Alias = Alias$1;
+var composeCollection = composeCollection$1;
+var composeScalar = composeScalar$1;
+var resolveEnd = resolveEnd$1;
+var utilEmptyScalarPosition = utilEmptyScalarPosition$1;
+
+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.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.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: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar.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.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.resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+composeNode$1.composeEmptyNode = composeEmptyNode;
+composeNode$1.composeNode = composeNode;

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

@@ -0,0 +1,91 @@
+import { __exports as composeScalar$1 } from '../../../../../../../_virtual/compose-scalar.esnext';
+export { __exports as default } from '../../../../../../../_virtual/compose-scalar.esnext';
+import '../nodes/Node.esnext';
+import '../nodes/Scalar.esnext';
+import './resolve-block-scalar.esnext';
+import './resolve-flow-scalar.esnext';
+import { __exports as Node$1 } from '../../../../../../../_virtual/Node.esnext';
+import { __exports as Scalar$1 } from '../../../../../../../_virtual/Scalar.esnext';
+import { __exports as resolveBlockScalar$1 } from '../../../../../../../_virtual/resolve-block-scalar.esnext';
+import { __exports as resolveFlowScalar$1 } from '../../../../../../../_virtual/resolve-flow-scalar.esnext';
+
+var Node = Node$1;
+var Scalar = Scalar$1;
+var resolveBlockScalar = resolveBlockScalar$1;
+var resolveFlowScalar = resolveFlowScalar$1;
+
+function composeScalar(ctx, token, tagToken, onError) {
+    const { value, type, comment, range } = token.type === 'block-scalar'
+        ? resolveBlockScalar.resolveBlockScalar(token, ctx.options.strict, onError)
+        : resolveFlowScalar.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[Node.SCALAR];
+    let scalar;
+    try {
+        const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+        scalar = Node.isScalar(res) ? res : new Scalar.Scalar(res);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg);
+        scalar = new Scalar.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[Node.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[Node.SCALAR];
+}
+function findScalarTagByTest({ directives, schema }, value, token, onError) {
+    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[Node.SCALAR];
+    if (schema.compat) {
+        const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
+            schema[Node.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;
+}
+
+composeScalar$1.composeScalar = composeScalar;