@quilted/create 0.2.43 → 0.2.45

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/nodes/YAMLMap.mjs

@@ -1,8 +1,8 @@
 import { stringifyCollection } from '../stringify/stringifyCollection.mjs';
 import { addPairToJSMap } from './addPairToJSMap.mjs';
 import { Collection } from './Collection.mjs';
-import { isScalar, isPair, MAP } from './Node.mjs';
-import { Pair } from './Pair.mjs';
+import { MAP, isPair, isScalar } from './identity.mjs';
+import { Pair, createPair } from './Pair.mjs';
 import { isScalarValue } from './Scalar.mjs';
 
 function findPair(items, key) {
@@ -16,12 +16,36 @@ function findPair(items, key) {
   return undefined;
 }
 class YAMLMap extends Collection {
+  static get tagName() {
+    return 'tag:yaml.org,2002:map';
+  }
   constructor(schema) {
     super(MAP, schema);
     this.items = [];
   }
-  static get tagName() {
-    return 'tag:yaml.org,2002:map';
+  /**
+   * A generic collection parsing method that can be extended
+   * to other node classes that inherit from YAMLMap
+   */
+  static from(schema, obj, ctx) {
+    const {
+      keepUndefined,
+      replacer
+    } = ctx;
+    const map = new this(schema);
+    const add = (key, value) => {
+      if (typeof replacer === 'function') value = replacer.call(obj, key, value);else if (Array.isArray(replacer) && !replacer.includes(key)) return;
+      if (value !== undefined || keepUndefined) map.items.push(createPair(key, value, ctx));
+    };
+    if (obj instanceof Map) {
+      for (const [key, value] of obj) add(key, value);
+    } else if (obj && typeof obj === 'object') {
+      for (const key of Object.keys(obj)) add(key, obj[key]);
+    }
+    if (typeof schema.sortMapEntries === 'function') {
+      map.items.sort(schema.sortMapEntries);
+    }
+    return map;
   }
   /**
    * Adds a value to the collection.

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/nodes/YAMLSeq.mjs

@@ -1,17 +1,18 @@
+import { createNode } from '../doc/createNode.mjs';
 import { stringifyCollection } from '../stringify/stringifyCollection.mjs';
 import { Collection } from './Collection.mjs';
-import { SEQ, isScalar } from './Node.mjs';
+import { SEQ, isScalar } from './identity.mjs';
 import { isScalarValue } from './Scalar.mjs';
 import { toJS } from './toJS.mjs';
 
 class YAMLSeq extends Collection {
+  static get tagName() {
+    return 'tag:yaml.org,2002:seq';
+  }
   constructor(schema) {
     super(SEQ, schema);
     this.items = [];
   }
-  static get tagName() {
-    return 'tag:yaml.org,2002:seq';
-  }
   add(value) {
     this.items.push(value);
   }
@@ -78,6 +79,23 @@ class YAMLSeq extends Collection {
       onComment
     });
   }
+  static from(schema, obj, ctx) {
+    const {
+      replacer
+    } = ctx;
+    const seq = new this(schema);
+    if (obj && Symbol.iterator in Object(obj)) {
+      let i = 0;
+      for (let it of obj) {
+        if (typeof replacer === 'function') {
+          const key = obj instanceof Set ? it : String(i++);
+          it = replacer.call(obj, key, it);
+        }
+        seq.items.push(createNode(it, undefined, ctx));
+      }
+    }
+    return seq;
+  }
 }
 function asItemIndex(key) {
   let idx = isScalar(key) ? key.value : key;

package/build/esm/node_modules/.pnpm/yaml@2.7.0/node_modules/yaml/browser/dist/nodes/addPairToJSMap.mjs

@@ -0,0 +1,53 @@
+import { warn } from '../log.mjs';
+import { isMergeKey, addMergeToJSMap } from '../schema/yaml-1.1/merge.mjs';
+import { createStringifyContext } from '../stringify/stringify.mjs';
+import { isNode } from './identity.mjs';
+import { toJS } from './toJS.mjs';
+
+function addPairToJSMap(ctx, map, {
+  key,
+  value
+}) {
+  if (isNode(key) && key.addToJSMap) key.addToJSMap(ctx, map, value);
+  // TODO: Should drop this special case for bare << handling
+  else if (isMergeKey(ctx, key)) addMergeToJSMap(ctx, map, value);else {
+    const jsKey = toJS(key, '', ctx);
+    if (map instanceof Map) {
+      map.set(jsKey, toJS(value, jsKey, ctx));
+    } else if (map instanceof Set) {
+      map.add(jsKey);
+    } else {
+      const stringKey = stringifyKey(key, jsKey, ctx);
+      const jsValue = toJS(value, stringKey, ctx);
+      if (stringKey in map) Object.defineProperty(map, stringKey, {
+        value: jsValue,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });else map[stringKey] = jsValue;
+    }
+  }
+  return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+  if (jsKey === null) return '';
+  if (typeof jsKey !== 'object') return String(jsKey);
+  if (isNode(key) && ctx?.doc) {
+    const strCtx = createStringifyContext(ctx.doc, {});
+    strCtx.anchors = new Set();
+    for (const node of ctx.anchors.keys()) strCtx.anchors.add(node.anchor);
+    strCtx.inFlow = true;
+    strCtx.inStringifyKey = true;
+    const strKey = key.toString(strCtx);
+    if (!ctx.mapKeyWarned) {
+      let jsonStr = JSON.stringify(strKey);
+      if (jsonStr.length > 40) jsonStr = jsonStr.substring(0, 36) + '..."';
+      warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+      ctx.mapKeyWarned = true;
+    }
+    return strKey;
+  }
+  return JSON.stringify(jsKey);
+}
+
+export { addPairToJSMap };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Node.mjs → yaml@2.7.0/node_modules/yaml/browser/dist/nodes/identity.mjs}

@@ -30,18 +30,5 @@ function isNode(node) {
   return false;
 }
 const hasAnchor = node => (isScalar(node) || isCollection(node)) && !!node.anchor;
-class NodeBase {
-  constructor(type) {
-    Object.defineProperty(this, NODE_TYPE, {
-      value: type
-    });
-  }
-  /** Create a copy of this node.  */
-  clone() {
-    const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-    if (this.range) copy.range = this.range.slice();
-    return copy;
-  }
-}
 
-export { ALIAS, DOC, MAP, NODE_TYPE, NodeBase, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };
+export { ALIAS, DOC, MAP, NODE_TYPE, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/nodes/toJS.mjs

@@ -1,4 +1,4 @@
-import { hasAnchor } from './Node.mjs';
+import { hasAnchor } from './identity.mjs';
 
 /**
  * Recursively convert any node or its contents to native JavaScript

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/parse/cst.mjs

@@ -1,4 +1,5 @@
 import '../nodes/Scalar.mjs';
+import '../stringify/stringifyString.mjs';
 
 /** The byte order mark */
 const BOM = '\u{FEFF}';

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/parse/lexer.mjs

@@ -79,11 +79,11 @@ function isEmpty(ch) {
       return false;
   }
 }
-const hexDigits = '0123456789ABCDEFabcdef'.split('');
-const tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split('');
-const invalidFlowScalarChars = ',[]{}'.split('');
-const invalidAnchorChars = ' ,[]{}\n\r\t'.split('');
-const isNotAnchorChar = ch => !ch || invalidAnchorChars.includes(ch);
+const hexDigits = new Set('0123456789ABCDEFabcdef');
+const tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
+const flowIndicatorChars = new Set(',[]{}');
+const invalidAnchorChars = new Set(' ,[]{}\n\r\t');
+const isNotAnchorChar = ch => !ch || invalidAnchorChars.has(ch);
 /**
  * Splits an input string into lexical tokens, i.e. smaller strings that are
  * easily identifiable by `tokens.tokenType()`.
@@ -149,6 +149,7 @@ class Lexer {
    */
   *lex(source, incomplete = false) {
     if (source) {
+      if (typeof source !== 'string') throw TypeError('source is not a string');
       this.buffer = this.buffer ? this.buffer + source : source;
       this.lineEndPos = null;
     }
@@ -236,10 +237,15 @@ class Lexer {
     }
     if (line[0] === '%') {
       let dirEnd = line.length;
-      const cs = line.indexOf('#');
-      if (cs !== -1) {
+      let cs = line.indexOf('#');
+      while (cs !== -1) {
         const ch = line[cs - 1];
-        if (ch === ' ' || ch === '\t') dirEnd = cs - 1;
+        if (ch === ' ' || ch === '\t') {
+          dirEnd = cs - 1;
+          break;
+        } else {
+          cs = line.indexOf('#', cs + 1);
+        }
       }
       while (true) {
         const ch = line[dirEnd - 1];
@@ -265,14 +271,11 @@ class Lexer {
     if (ch === '-' || ch === '.') {
       if (!this.atEnd && !this.hasChars(4)) return this.setNext('line-start');
       const s = this.peek(3);
-      if (s === '---' && isEmpty(this.charAt(3))) {
+      if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
         yield* this.pushCount(3);
         this.indentValue = 0;
         this.indentNext = 0;
-        return 'doc';
-      } else if (s === '...' && isEmpty(this.charAt(3))) {
-        yield* this.pushCount(3);
-        return 'stream';
+        return s === '---' ? 'doc' : 'stream';
       }
     }
     this.indentValue = yield* this.pushSpaces(false);
@@ -476,7 +479,9 @@ class Lexer {
     }
     if (!ch && !this.atEnd) return this.setNext('block-scalar');
     if (indent >= this.indentNext) {
-      if (this.blockScalarIndent === -1) this.indentNext = indent;else this.indentNext += this.blockScalarIndent;
+      if (this.blockScalarIndent === -1) this.indentNext = indent;else {
+        this.indentNext = this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);
+      }
       do {
         const cs = this.continueScalar(nl + 1);
         if (cs === -1) break;
@@ -487,13 +492,21 @@ class Lexer {
         nl = this.buffer.length;
       }
     }
-    if (!this.blockScalarKeep) {
+    // Trailing insufficiently indented tabs are invalid.
+    // To catch that during parsing, we include them in the block scalar value.
+    let i = nl + 1;
+    ch = this.buffer[i];
+    while (ch === ' ') ch = this.buffer[++i];
+    if (ch === '\t') {
+      while (ch === '\t' || ch === ' ' || ch === '\r' || ch === '\n') ch = this.buffer[++i];
+      nl = i - 1;
+    } else if (!this.blockScalarKeep) {
       do {
         let i = nl - 1;
         let ch = this.buffer[i];
         if (ch === '\r') ch = this.buffer[--i];
         const lastChar = i; // Drop the line if last char not more indented
-        while (ch === ' ' || ch === '\t') ch = this.buffer[--i];
+        while (ch === ' ') ch = this.buffer[--i];
         if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar) nl = i;else break;
       } while (true);
     }
@@ -509,7 +522,7 @@ class Lexer {
     while (ch = this.buffer[++i]) {
       if (ch === ':') {
         const next = this.buffer[i + 1];
-        if (isEmpty(next) || inFlow && next === ',') break;
+        if (isEmpty(next) || inFlow && flowIndicatorChars.has(next)) break;
         end = i;
       } else if (isEmpty(ch)) {
         let next = this.buffer[i + 1];
@@ -520,14 +533,14 @@ class Lexer {
             next = this.buffer[i + 1];
           } else end = i;
         }
-        if (next === '#' || inFlow && invalidFlowScalarChars.includes(next)) break;
+        if (next === '#' || inFlow && flowIndicatorChars.has(next)) break;
         if (ch === '\n') {
           const cs = this.continueScalar(i + 1);
           if (cs === -1) break;
           i = Math.max(i, cs - 2); // to advance, but still account for ' #'
         }
       } else {
-        if (inFlow && invalidFlowScalarChars.includes(ch)) break;
+        if (inFlow && flowIndicatorChars.has(ch)) break;
         end = i;
       }
     }
@@ -565,7 +578,7 @@ class Lexer {
         {
           const inFlow = this.flowLevel > 0;
           const ch1 = this.charAt(1);
-          if (isEmpty(ch1) || inFlow && invalidFlowScalarChars.includes(ch1)) {
+          if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
             if (!inFlow) this.indentNext = this.indentValue + 1;else if (this.flowKey) this.flowKey = false;
             return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
           }
@@ -583,7 +596,7 @@ class Lexer {
       let i = this.pos + 1;
       let ch = this.buffer[i];
       while (ch) {
-        if (tagChars.includes(ch)) ch = this.buffer[++i];else if (ch === '%' && hexDigits.includes(this.buffer[i + 1]) && hexDigits.includes(this.buffer[i + 2])) {
+        if (tagChars.has(ch)) ch = this.buffer[++i];else if (ch === '%' && hexDigits.has(this.buffer[i + 1]) && hexDigits.has(this.buffer[i + 2])) {
           ch = this.buffer[i += 3];
         } else break;
       }

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/parse/parser.mjs

@@ -294,7 +294,7 @@ class Parser {
                 key: token,
                 sep: []
               });
-              this.onKeyLine = !includesToken(it.start, 'explicit-key-ind');
+              this.onKeyLine = !it.explicitKey;
               return;
             }
             break;
@@ -494,7 +494,8 @@ class Parser {
         return;
     }
     if (this.indent >= map.indent) {
-      const atNextItem = !this.onKeyLine && this.indent === map.indent && it.sep;
+      const atMapIndent = !this.onKeyLine && this.indent === map.indent;
+      const atNextItem = atMapIndent && (it.sep || it.explicitKey) && this.type !== 'seq-item-ind';
       // For empty nodes, assign newline-separated not indented empty tokens to following node
       let start = [];
       if (atNextItem && it.sep && !it.value) {
@@ -532,12 +533,14 @@ class Parser {
           }
           return;
         case 'explicit-key-ind':
-          if (!it.sep && !includesToken(it.start, 'explicit-key-ind')) {
+          if (!it.sep && !it.explicitKey) {
             it.start.push(this.sourceToken);
+            it.explicitKey = true;
           } else if (atNextItem || it.value) {
             start.push(this.sourceToken);
             map.items.push({
-              start
+              start,
+              explicitKey: true
             });
           } else {
             this.stack.push({
@@ -545,14 +548,15 @@ class Parser {
               offset: this.offset,
               indent: this.indent,
               items: [{
-                start: [this.sourceToken]
+                start: [this.sourceToken],
+                explicitKey: true
               }]
             });
           }
           this.onKeyLine = true;
           return;
         case 'map-value-ind':
-          if (includesToken(it.start, 'explicit-key-ind')) {
+          if (it.explicitKey) {
             if (!it.sep) {
               if (includesToken(it.start, 'newline')) {
                 Object.assign(it, {
@@ -595,7 +599,9 @@ class Parser {
               const sep = it.sep;
               sep.push(this.sourceToken);
               // @ts-expect-error type guard is wrong here
-              delete it.key, delete it.sep;
+              delete it.key;
+              // @ts-expect-error type guard is wrong here
+              delete it.sep;
               this.stack.push({
                 type: 'block-map',
                 offset: this.offset,
@@ -669,7 +675,7 @@ class Parser {
           {
             const bv = this.startBlockValue(map);
             if (bv) {
-              if (atNextItem && bv.type !== 'block-seq' && includesToken(it.start, 'explicit-key-ind')) {
+              if (atMapIndent && bv.type !== 'block-seq') {
                 map.items.push({
                   start
                 });
@@ -885,7 +891,8 @@ class Parser {
             offset: this.offset,
             indent: this.indent,
             items: [{
-              start
+              start,
+              explicitKey: true
             }]
           };
         }

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

@@ -2,6 +2,7 @@ import { Composer } from './compose/composer.mjs';
 import { Document } from './doc/Document.mjs';
 import { prettifyError, YAMLParseError } from './errors.mjs';
 import { warn } from './log.mjs';
+import { isDocument } from './nodes/identity.mjs';
 import { LineCounter } from './parse/line-counter.mjs';
 import { Parser } from './parse/parser.mjs';
 
@@ -74,6 +75,7 @@ function stringify(value, replacer, options) {
     } = options ?? replacer ?? {};
     if (!keepUndefined) return undefined;
   }
+  if (isDocument(value) && !_replacer) return value.toString(options);
   return new Document(value, _replacer, options).toString(options);
 }
 

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/Schema.mjs

@@ -1,4 +1,4 @@
-import { MAP, SCALAR, SEQ } from '../nodes/Node.mjs';
+import { MAP, SCALAR, SEQ } from '../nodes/identity.mjs';
 import { map } from './common/map.mjs';
 import { seq } from './common/seq.mjs';
 import { string } from './common/string.mjs';
@@ -16,10 +16,9 @@ class Schema {
     toStringDefaults
   }) {
     this.compat = Array.isArray(compat) ? getTags(compat, 'compat') : compat ? getTags(null, compat) : null;
-    this.merge = !!merge;
     this.name = typeof schema === 'string' && schema || 'core';
     this.knownTags = resolveKnownTags ? coreKnownTags : {};
-    this.tags = getTags(customTags, this.name);
+    this.tags = getTags(customTags, this.name, merge);
     this.toStringOptions = toStringDefaults ?? null;
     Object.defineProperty(this, MAP, {
       value: map

package/build/esm/node_modules/.pnpm/yaml@2.7.0/node_modules/yaml/browser/dist/schema/common/map.mjs

@@ -0,0 +1,16 @@
+import { isMap } from '../../nodes/identity.mjs';
+import { YAMLMap } from '../../nodes/YAMLMap.mjs';
+
+const map = {
+  collection: 'map',
+  default: true,
+  nodeClass: YAMLMap,
+  tag: 'tag:yaml.org,2002:map',
+  resolve(map, onError) {
+    if (!isMap(map)) onError('Expected a mapping for this tag');
+    return map;
+  },
+  createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
+};
+
+export { map };

package/build/esm/node_modules/.pnpm/yaml@2.7.0/node_modules/yaml/browser/dist/schema/common/seq.mjs

@@ -0,0 +1,16 @@
+import { isSeq } from '../../nodes/identity.mjs';
+import { YAMLSeq } from '../../nodes/YAMLSeq.mjs';
+
+const seq = {
+  collection: 'seq',
+  default: true,
+  nodeClass: YAMLSeq,
+  tag: 'tag:yaml.org,2002:seq',
+  resolve(seq, onError) {
+    if (!isSeq(seq)) onError('Expected a sequence for this tag');
+    return seq;
+  },
+  createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
+};
+
+export { seq };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/core/float.mjs

@@ -5,7 +5,7 @@ const floatNaN = {
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^(?:[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN))$/,
+  test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
   resolve: str => str.slice(-3).toLowerCase() === 'nan' ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
   stringify: stringifyNumber
 };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/json/schema.mjs

@@ -26,7 +26,7 @@ const jsonScalars = [{
   identify: value => typeof value === 'boolean',
   default: true,
   tag: 'tag:yaml.org,2002:bool',
-  test: /^true|false$/,
+  test: /^true$|^false$/,
   resolve: str => str === 'true',
   stringify: stringifyJSON
 }, {

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/tags.mjs

@@ -3,16 +3,17 @@ import { nullTag } from './common/null.mjs';
 import { seq } from './common/seq.mjs';
 import { string } from './common/string.mjs';
 import { boolTag } from './core/bool.mjs';
-import { float, floatExp, floatNaN } from './core/float.mjs';
-import { int, intHex, intOct } from './core/int.mjs';
+import { floatNaN, floatExp, float } from './core/float.mjs';
+import { intOct, intHex, int } from './core/int.mjs';
 import { schema } from './core/schema.mjs';
 import { schema as schema$1 } from './json/schema.mjs';
 import { binary } from './yaml-1.1/binary.mjs';
+import { merge } from './yaml-1.1/merge.mjs';
 import { omap } from './yaml-1.1/omap.mjs';
 import { pairs } from './yaml-1.1/pairs.mjs';
 import { schema as schema$2 } from './yaml-1.1/schema.mjs';
 import { set } from './yaml-1.1/set.mjs';
-import { timestamp, floatTime, intTime } from './yaml-1.1/timestamp.mjs';
+import { timestamp, intTime, floatTime } from './yaml-1.1/timestamp.mjs';
 
 const schemas = new Map([['core', schema], ['failsafe', [map, seq, string]], ['json', schema$1], ['yaml11', schema$2], ['yaml-1.1', schema$2]]);
 const tagsByName = {
@@ -27,6 +28,7 @@ const tagsByName = {
   intOct,
   intTime,
   map,
+  merge,
   null: nullTag,
   omap,
   pairs,
@@ -36,13 +38,18 @@ const tagsByName = {
 };
 const coreKnownTags = {
   'tag:yaml.org,2002:binary': binary,
+  'tag:yaml.org,2002:merge': merge,
   'tag:yaml.org,2002:omap': omap,
   'tag:yaml.org,2002:pairs': pairs,
   'tag:yaml.org,2002:set': set,
   'tag:yaml.org,2002:timestamp': timestamp
 };
-function getTags(customTags, schemaName) {
-  let tags = schemas.get(schemaName);
+function getTags(customTags, schemaName, addMergeTag) {
+  const schemaTags = schemas.get(schemaName);
+  if (schemaTags && !customTags) {
+    return addMergeTag && !schemaTags.includes(merge) ? schemaTags.concat(merge) : schemaTags.slice();
+  }
+  let tags = schemaTags;
   if (!tags) {
     if (Array.isArray(customTags)) tags = [];else {
       const keys = Array.from(schemas.keys()).filter(key => key !== 'yaml11').map(key => JSON.stringify(key)).join(', ');
@@ -54,13 +61,17 @@ function getTags(customTags, schemaName) {
   } else if (typeof customTags === 'function') {
     tags = customTags(tags.slice());
   }
-  return tags.map(tag => {
-    if (typeof tag !== 'string') return tag;
-    const tagObj = tagsByName[tag];
-    if (tagObj) return tagObj;
-    const keys = Object.keys(tagsByName).map(key => JSON.stringify(key)).join(', ');
-    throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
-  });
+  if (addMergeTag) tags = tags.concat(merge);
+  return tags.reduce((tags, tag) => {
+    const tagObj = typeof tag === 'string' ? tagsByName[tag] : tag;
+    if (!tagObj) {
+      const tagName = JSON.stringify(tag);
+      const keys = Object.keys(tagsByName).map(key => JSON.stringify(key)).join(', ');
+      throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
+    }
+    if (!tags.includes(tagObj)) tags.push(tagObj);
+    return tags;
+  }, []);
 }
 
 export { coreKnownTags, getTags };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/yaml-1.1/binary.mjs

@@ -3,6 +3,7 @@ import { stringifyString } from '../../stringify/stringifyString.mjs';
 
 const binary = {
   identify: value => value instanceof Uint8Array,
+  // Buffer inherits from Uint8Array
   default: false,
   tag: 'tag:yaml.org,2002:binary',
   /**
@@ -14,9 +15,7 @@ const binary = {
    *   document.querySelector('#photo').src = URL.createObjectURL(blob)
    */
   resolve(src, onError) {
-    if (typeof Buffer === 'function') {
-      return Buffer.from(src, 'base64');
-    } else if (typeof atob === 'function') {
+    if (typeof atob === 'function') {
       // On IE 11, atob() can't handle newlines
       const str = atob(src.replace(/[\n\r]/g, ''));
       const buffer = new Uint8Array(str.length);
@@ -34,9 +33,7 @@ const binary = {
   }, ctx, onComment, onChompKeep) {
     const buf = value; // checked earlier by binary.identify()
     let str;
-    if (typeof Buffer === 'function') {
-      str = buf instanceof Buffer ? buf.toString('base64') : Buffer.from(buf.buffer).toString('base64');
-    } else if (typeof btoa === 'function') {
+    if (typeof btoa === 'function') {
       let s = '';
       for (let i = 0; i < buf.length; ++i) s += String.fromCharCode(buf[i]);
       str = btoa(s);

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/yaml-1.1/bool.mjs

@@ -20,7 +20,7 @@ const falseTag = {
   identify: value => value === false,
   default: true,
   tag: 'tag:yaml.org,2002:bool',
-  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
+  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
   resolve: () => new Scalar(false),
   stringify: boolStringify
 };

package/build/esm/node_modules/.pnpm/{yaml@2.1.1 → yaml@2.7.0}/node_modules/yaml/browser/dist/schema/yaml-1.1/float.mjs

@@ -5,7 +5,7 @@ const floatNaN = {
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN)$/,
+  test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
   resolve: str => str.slice(-3).toLowerCase() === 'nan' ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
   stringify: stringifyNumber
 };