@quilted/create 0.2.43 → 0.2.45

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

@@ -1,4 +1,4 @@
-import { isNumber as isNumber$1 } from '../../../is-number@7.0.0/node_modules/is-number/index.mjs';
+import { __require as requireIsNumber } from '../../../is-number@7.0.0/node_modules/is-number/index.mjs';
 
 /*!
  * to-regex-range <https://github.com/micromatch/to-regex-range>
@@ -6,255 +6,262 @@ import { isNumber as isNumber$1 } from '../../../is-number@7.0.0/node_modules/is
  * 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})`;
+var toRegexRange_1;
+var hasRequiredToRegexRange;
+function requireToRegexRange() {
+  if (hasRequiredToRegexRange) return toRegexRange_1;
+  hasRequiredToRegexRange = 1;
+  const isNumber = requireIsNumber();
+  const toRegexRange = (min, max, options) => {
+    if (isNumber(min) === false) {
+      throw new TypeError('toRegexRange: expected the first argument to be a number');
     }
-    if (opts.wrap === false) {
-      return result;
+    if (max === void 0 || min === max) {
+      return String(min);
     }
-    return `(?:${result})`;
-  }
-  let isPadded = hasPadding(min) || hasPadding(max);
-  let state = {
-    min,
-    max,
-    a,
-    b
+    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;
   };
-  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})`;
+  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('|');
   }
-  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;
+  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;
   }
-  stops = [...stops];
-  stops.sort(compare);
-  return stops;
-}
 
-/**
- * Convert a range to a regex pattern
- * @param {Number} `start`
- * @param {Number} `stop`
- * @return {String}
- */
+  /**
+   * Convert a range to a regex pattern
+   * @param {Number} `start`
+   * @param {Number} `stop`
+   * @return {String}
+   */
 
-function rangeToPattern(start, stop, options) {
-  if (start === stop) {
+  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: start,
-      count: [],
-      digits: 0
+      pattern,
+      count: [count],
+      digits
     };
   }
-  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();
+  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;
       }
-      prev.count.push(obj.count[0]);
-      prev.string = prev.pattern + toQuantifier(prev.count);
+      if (tok.isPadded) {
+        zeros = padZeros(max, tok, options);
+      }
+      obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+      tokens.push(obj);
       start = max + 1;
-      continue;
-    }
-    if (tok.isPadded) {
-      zeros = padZeros(max, tok, options);
+      prev = obj;
     }
-    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
-    tokens.push(obj);
-    start = max + 1;
-    prev = obj;
+    return tokens;
   }
-  return tokens;
-}
-function filterPatterns(arr, comparison, prefix, intersection, options) {
-  let result = [];
-  for (let ele of arr) {
-    let {
-      string
-    } = ele;
+  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);
-    }
+      // 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);
+      // or _both_ are positive
+      if (intersection && contains(comparison, 'string', string)) {
+        result.push(prefix + string);
+      }
     }
+    return result;
   }
-  return result;
-}
 
-/**
- * Zip strings
- */
+  /**
+   * 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 : '')}}`;
+  function zip(a, b) {
+    let arr = [];
+    for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+    return arr;
   }
-  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;
+  function compare(a, b) {
+    return a > b ? 1 : b > a ? -1 : 0;
   }
-  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}}`;
-      }
+  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
- */
+  /**
+   * Cache
+   */
 
-toRegexRange.cache = {};
-toRegexRange.clearCache = () => toRegexRange.cache = {};
+  toRegexRange.cache = {};
+  toRegexRange.clearCache = () => toRegexRange.cache = {};
 
-/**
- * Expose `toRegexRange`
- */
+  /**
+   * Expose `toRegexRange`
+   */
 
-var toRegexRange_1 = toRegexRange;
+  toRegexRange_1 = toRegexRange;
+  return toRegexRange_1;
+}
 
-export { toRegexRange_1 };
+export { requireToRegexRange as __require };

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

@@ -0,0 +1,67 @@
+import { isNode } from '../nodes/identity.mjs';
+import { Scalar } from '../nodes/Scalar.mjs';
+import { YAMLMap } from '../nodes/YAMLMap.mjs';
+import { YAMLSeq } from '../nodes/YAMLSeq.mjs';
+import { resolveBlockMap } from './resolve-block-map.mjs';
+import { resolveBlockSeq } from './resolve-block-seq.mjs';
+import { resolveFlowCollection } from './resolve-flow-collection.mjs';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+  const coll = token.type === 'block-map' ? resolveBlockMap(CN, ctx, token, onError, tag) : token.type === 'block-seq' ? resolveBlockSeq(CN, ctx, token, onError, tag) : resolveFlowCollection(CN, ctx, token, onError, tag);
+  const Coll = coll.constructor;
+  // If we got a tagName matching the class, or the tag name is '!',
+  // then use the tagName from the node class used to create it.
+  if (tagName === '!' || tagName === Coll.tagName) {
+    coll.tag = Coll.tagName;
+    return coll;
+  }
+  if (tagName) coll.tag = tagName;
+  return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+  const tagToken = props.tag;
+  const tagName = !tagToken ? null : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+  if (token.type === 'block-seq') {
+    const {
+      anchor,
+      newlineAfterProp: nl
+    } = props;
+    const lastProp = anchor && tagToken ? anchor.offset > tagToken.offset ? anchor : tagToken : anchor ?? tagToken;
+    if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+      const message = 'Missing newline after block sequence props';
+      onError(lastProp, 'MISSING_CHAR', message);
+    }
+  }
+  const expType = token.type === 'block-map' ? 'map' : token.type === 'block-seq' ? 'seq' : token.start.source === '{' ? 'map' : 'seq';
+  // shortcut: check if it's a generic YAMLMap or YAMLSeq
+  // before jumping into the custom tag logic.
+  if (!tagToken || !tagName || tagName === '!' || tagName === YAMLMap.tagName && expType === 'map' || tagName === YAMLSeq.tagName && expType === 'seq') {
+    return resolveCollection(CN, ctx, token, onError, tagName);
+  }
+  let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+  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 {
+      if (kt?.collection) {
+        onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+      } else {
+        onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+      }
+      return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+  }
+  const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+  const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+  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 → yaml@2.7.0}/node_modules/yaml/browser/dist/compose/compose-doc.mjs

@@ -14,6 +14,7 @@ function composeDoc(options, directives, {
   }, options);
   const doc = new Document(undefined, opts);
   const ctx = {
+    atKey: false,
     atRoot: true,
     directives: doc.directives,
     options: doc.options,
@@ -24,12 +25,14 @@ function composeDoc(options, directives, {
     next: value ?? end?.[0],
     offset,
     onError,
+    parentIndent: 0,
     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');
   }
+  // @ts-expect-error If Contents is set, let's trust the user
   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);

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/compose/compose-node.mjs

@@ -1,4 +1,5 @@
 import { Alias } from '../nodes/Alias.mjs';
+import { isScalar } from '../nodes/identity.mjs';
 import { composeCollection } from './compose-collection.mjs';
 import { composeScalar } from './compose-scalar.mjs';
 import { resolveEnd } from './resolve-end.mjs';
@@ -9,6 +10,7 @@ const CN = {
   composeEmptyNode
 };
 function composeNode(ctx, token, props, onError) {
+  const atKey = ctx.atKey;
   const {
     spaceBefore,
     comment,
@@ -32,7 +34,7 @@ function composeNode(ctx, token, props, onError) {
     case 'block-map':
     case 'block-seq':
     case 'flow-collection':
-      node = composeCollection(CN, ctx, token, tag, onError);
+      node = composeCollection(CN, ctx, token, props, onError);
       if (anchor) node.anchor = anchor.source.substring(1);
       break;
     default:
@@ -44,6 +46,10 @@ function composeNode(ctx, token, props, onError) {
       }
   }
   if (anchor && node.anchor === '') onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+  if (atKey && ctx.options.stringKeys && (!isScalar(node) || typeof node.value !== 'string' || node.tag && node.tag !== 'tag:yaml.org,2002:str')) {
+    const msg = 'With stringKeys, all keys must be strings';
+    onError(tag ?? token, 'NON_STRING_KEY', msg);
+  }
   if (spaceBefore) node.spaceBefore = true;
   if (comment) {
     if (token.type === 'scalar' && token.source === '') node.comment = comment;else node.commentBefore = comment;
@@ -56,7 +62,8 @@ function composeEmptyNode(ctx, offset, before, pos, {
   spaceBefore,
   comment,
   anchor,
-  tag
+  tag,
+  end
 }, onError) {
   const token = {
     type: 'scalar',
@@ -70,7 +77,10 @@ function composeEmptyNode(ctx, offset, before, pos, {
     if (node.anchor === '') onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
   }
   if (spaceBefore) node.spaceBefore = true;
-  if (comment) node.comment = comment;
+  if (comment) {
+    node.comment = comment;
+    node.range[2] = end;
+  }
   return node;
 }
 function composeAlias({

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/compose/compose-scalar.mjs

@@ -1,4 +1,4 @@
-import { SCALAR, isScalar } from '../nodes/Node.mjs';
+import { SCALAR, isScalar } from '../nodes/identity.mjs';
 import { Scalar } from '../nodes/Scalar.mjs';
 import { resolveBlockScalar } from './resolve-block-scalar.mjs';
 import { resolveFlowScalar } from './resolve-flow-scalar.mjs';
@@ -9,9 +9,12 @@ function composeScalar(ctx, token, tagToken, onError) {
     type,
     comment,
     range
-  } = token.type === 'block-scalar' ? resolveBlockScalar(token, ctx.options.strict, onError) : resolveFlowScalar(token, ctx.options.strict, onError);
+  } = token.type === 'block-scalar' ? resolveBlockScalar(ctx, token, 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 tag;
+  if (ctx.options.stringKeys && ctx.atKey) {
+    tag = ctx.schema[SCALAR];
+  } else if (tagName) tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);else if (token.type === 'scalar') tag = findScalarTagByTest(ctx, value, token, onError);else tag = ctx.schema[SCALAR];
   let scalar;
   try {
     const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
@@ -52,10 +55,11 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
   return schema[SCALAR];
 }
 function findScalarTagByTest({
+  atKey,
   directives,
   schema
 }, value, token, onError) {
-  const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[SCALAR];
+  const tag = schema.tags.find(tag => (tag.default === true || atKey && tag.default === 'key') && 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) {