@quilted/create 0.1.89 → 0.2.0

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/errors.mjs

@@ -0,0 +1,55 @@
+class YAMLError extends Error {
+  constructor(name, pos, code, message) {
+    super();
+    this.name = name;
+    this.code = code;
+    this.message = message;
+    this.pos = pos;
+  }
+}
+class YAMLParseError extends YAMLError {
+  constructor(pos, code, message) {
+    super('YAMLParseError', pos, code, message);
+  }
+}
+class YAMLWarning extends YAMLError {
+  constructor(pos, code, message) {
+    super('YAMLWarning', pos, code, message);
+  }
+}
+const prettifyError = (src, lc) => error => {
+  if (error.pos[0] === -1) return;
+  error.linePos = error.pos.map(pos => lc.linePos(pos));
+  const {
+    line,
+    col
+  } = error.linePos[0];
+  error.message += ` at line ${line}, column ${col}`;
+  let ci = col - 1;
+  let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, '');
+  // Trim to max 80 chars, keeping col position near the middle
+  if (ci >= 60 && lineStr.length > 80) {
+    const trimStart = Math.min(ci - 39, lineStr.length - 79);
+    lineStr = '…' + lineStr.substring(trimStart);
+    ci -= trimStart - 1;
+  }
+  if (lineStr.length > 80) lineStr = lineStr.substring(0, 79) + '…';
+  // Include previous line in context if pointing at line start
+  if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+    // Regexp won't match if start is trimmed
+    let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+    if (prev.length > 80) prev = prev.substring(0, 79) + '…\n';
+    lineStr = prev + lineStr;
+  }
+  if (/[^ ]/.test(lineStr)) {
+    let count = 1;
+    const end = error.linePos[1];
+    if (end && end.line === line && end.col > col) {
+      count = Math.min(end.col - col, 80 - ci);
+    }
+    const pointer = ' '.repeat(ci) + '^'.repeat(count);
+    error.message += `:\n\n${lineStr}\n${pointer}\n`;
+  }
+};
+
+export { YAMLError, YAMLParseError, YAMLWarning, prettifyError };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/log.mjs

@@ -0,0 +1,7 @@
+function warn(logLevel, warning) {
+  if (logLevel === 'debug' || logLevel === 'warn') {
+    if (typeof process !== 'undefined' && process.emitWarning) process.emitWarning(warning);else console.warn(warning);
+  }
+}
+
+export { warn };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Alias.mjs

@@ -0,0 +1,92 @@
+import { anchorIsValid } from '../doc/anchors.mjs';
+import { visit } from '../visit.mjs';
+import { NodeBase, ALIAS, isAlias, isCollection, isPair } from './Node.mjs';
+
+class Alias extends NodeBase {
+  constructor(source) {
+    super(ALIAS);
+    this.source = source;
+    Object.defineProperty(this, 'tag', {
+      set() {
+        throw new Error('Alias nodes cannot have tags');
+      }
+    });
+  }
+  /**
+   * Resolve the value of this alias within `doc`, finding the last
+   * instance of the `source` anchor before this node.
+   */
+  resolve(doc) {
+    let found = undefined;
+    visit(doc, {
+      Node: (_key, node) => {
+        if (node === this) return visit.BREAK;
+        if (node.anchor === this.source) found = node;
+      }
+    });
+    return found;
+  }
+  toJSON(_arg, ctx) {
+    if (!ctx) return {
+      source: this.source
+    };
+    const {
+      anchors,
+      doc,
+      maxAliasCount
+    } = ctx;
+    const source = this.resolve(doc);
+    if (!source) {
+      const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+      throw new ReferenceError(msg);
+    }
+    const data = anchors.get(source);
+    /* istanbul ignore if */
+    if (!data || data.res === undefined) {
+      const msg = 'This should not happen: Alias anchor was not resolved?';
+      throw new ReferenceError(msg);
+    }
+    if (maxAliasCount >= 0) {
+      data.count += 1;
+      if (data.aliasCount === 0) data.aliasCount = getAliasCount(doc, source, anchors);
+      if (data.count * data.aliasCount > maxAliasCount) {
+        const msg = 'Excessive alias count indicates a resource exhaustion attack';
+        throw new ReferenceError(msg);
+      }
+    }
+    return data.res;
+  }
+  toString(ctx, _onComment, _onChompKeep) {
+    const src = `*${this.source}`;
+    if (ctx) {
+      anchorIsValid(this.source);
+      if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+        const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+        throw new Error(msg);
+      }
+      if (ctx.implicitKey) return `${src} `;
+    }
+    return src;
+  }
+}
+function getAliasCount(doc, node, anchors) {
+  if (isAlias(node)) {
+    const source = node.resolve(doc);
+    const anchor = anchors && source && anchors.get(source);
+    return anchor ? anchor.count * anchor.aliasCount : 0;
+  } else if (isCollection(node)) {
+    let count = 0;
+    for (const item of node.items) {
+      const c = getAliasCount(doc, item, anchors);
+      if (c > count) count = c;
+    }
+    return count;
+  } else if (isPair(node)) {
+    const kc = getAliasCount(doc, node.key, anchors);
+    const vc = getAliasCount(doc, node.value, anchors);
+    return Math.max(kc, vc);
+  }
+  return 1;
+}
+
+export { Alias };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Collection.mjs

@@ -0,0 +1,115 @@
+import { createNode } from '../doc/createNode.mjs';
+import { NodeBase, isNode, isPair, isCollection, isScalar } from './Node.mjs';
+
+function collectionFromPath(schema, path, value) {
+  let v = value;
+  for (let i = path.length - 1; i >= 0; --i) {
+    const k = path[i];
+    if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+      const a = [];
+      a[k] = v;
+      v = a;
+    } else {
+      v = new Map([[k, v]]);
+    }
+  }
+  return createNode(v, undefined, {
+    aliasDuplicateObjects: false,
+    keepUndefined: false,
+    onAnchor: () => {
+      throw new Error('This should not happen, please report a bug.');
+    },
+    schema,
+    sourceObjects: new Map()
+  });
+}
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
+const isEmptyPath = path => path == null || typeof path === 'object' && !!path[Symbol.iterator]().next().done;
+class Collection extends NodeBase {
+  constructor(type, schema) {
+    super(type);
+    Object.defineProperty(this, 'schema', {
+      value: schema,
+      configurable: true,
+      enumerable: false,
+      writable: true
+    });
+  }
+  /**
+   * Create a copy of this collection.
+   *
+   * @param schema - If defined, overwrites the original's schema
+   */
+  clone(schema) {
+    const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+    if (schema) copy.schema = schema;
+    copy.items = copy.items.map(it => isNode(it) || isPair(it) ? it.clone(schema) : it);
+    if (this.range) copy.range = this.range.slice();
+    return copy;
+  }
+  /**
+   * Adds a value to the collection. For `!!map` and `!!omap` the value must
+   * be a Pair instance or a `{ key, value }` object, which may not have a key
+   * that already exists in the map.
+   */
+  addIn(path, value) {
+    if (isEmptyPath(path)) this.add(value);else {
+      const [key, ...rest] = path;
+      const node = this.get(key, true);
+      if (isCollection(node)) node.addIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+  }
+  /**
+   * Removes a value from the collection.
+   * @returns `true` if the item was found and removed.
+   */
+  deleteIn(path) {
+    const [key, ...rest] = path;
+    if (rest.length === 0) return this.delete(key);
+    const node = this.get(key, true);
+    if (isCollection(node)) return node.deleteIn(rest);else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+  }
+  /**
+   * Returns item at `key`, or `undefined` if not found. By default unwraps
+   * scalar values from their surrounding node; to disable set `keepScalar` to
+   * `true` (collections are always returned intact).
+   */
+  getIn(path, keepScalar) {
+    const [key, ...rest] = path;
+    const node = this.get(key, true);
+    if (rest.length === 0) return !keepScalar && isScalar(node) ? node.value : node;else return isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+  }
+  hasAllNullValues(allowScalar) {
+    return this.items.every(node => {
+      if (!isPair(node)) return false;
+      const n = node.value;
+      return n == null || allowScalar && isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
+    });
+  }
+  /**
+   * Checks if the collection includes a value with the key `key`.
+   */
+  hasIn(path) {
+    const [key, ...rest] = path;
+    if (rest.length === 0) return this.has(key);
+    const node = this.get(key, true);
+    return isCollection(node) ? node.hasIn(rest) : false;
+  }
+  /**
+   * Sets a value in this collection. For `!!set`, `value` needs to be a
+   * boolean to add/remove the item from the set.
+   */
+  setIn(path, value) {
+    const [key, ...rest] = path;
+    if (rest.length === 0) {
+      this.set(key, value);
+    } else {
+      const node = this.get(key, true);
+      if (isCollection(node)) node.setIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+  }
+}
+Collection.maxFlowStringSingleLineLength = 60;
+
+export { Collection, collectionFromPath, isEmptyPath };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Node.mjs

@@ -0,0 +1,47 @@
+const ALIAS = Symbol.for('yaml.alias');
+const DOC = Symbol.for('yaml.document');
+const MAP = Symbol.for('yaml.map');
+const PAIR = Symbol.for('yaml.pair');
+const SCALAR = Symbol.for('yaml.scalar');
+const SEQ = Symbol.for('yaml.seq');
+const NODE_TYPE = Symbol.for('yaml.node.type');
+const isAlias = node => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;
+const isDocument = node => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;
+const isMap = node => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;
+const isPair = node => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;
+const isScalar = node => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR;
+const isSeq = node => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
+function isCollection(node) {
+  if (node && typeof node === 'object') switch (node[NODE_TYPE]) {
+    case MAP:
+    case SEQ:
+      return true;
+  }
+  return false;
+}
+function isNode(node) {
+  if (node && typeof node === 'object') switch (node[NODE_TYPE]) {
+    case ALIAS:
+    case MAP:
+    case SCALAR:
+    case SEQ:
+      return true;
+  }
+  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 };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Pair.mjs

@@ -0,0 +1,37 @@
+import { createNode } from '../doc/createNode.mjs';
+import { stringifyPair } from '../stringify/stringifyPair.mjs';
+import { addPairToJSMap } from './addPairToJSMap.mjs';
+import { NODE_TYPE, PAIR, isNode } from './Node.mjs';
+
+function createPair(key, value, ctx) {
+  const k = createNode(key, undefined, ctx);
+  const v = createNode(value, undefined, ctx);
+  return new Pair(k, v);
+}
+class Pair {
+  constructor(key, value = null) {
+    Object.defineProperty(this, NODE_TYPE, {
+      value: PAIR
+    });
+    this.key = key;
+    this.value = value;
+  }
+  clone(schema) {
+    let {
+      key,
+      value
+    } = this;
+    if (isNode(key)) key = key.clone(schema);
+    if (isNode(value)) value = value.clone(schema);
+    return new Pair(key, value);
+  }
+  toJSON(_, ctx) {
+    const pair = ctx?.mapAsMap ? new Map() : {};
+    return addPairToJSMap(ctx, pair, this);
+  }
+  toString(ctx, onComment, onChompKeep) {
+    return ctx?.doc ? stringifyPair(this, ctx, onComment, onChompKeep) : JSON.stringify(this);
+  }
+}
+
+export { Pair, createPair };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/Scalar.mjs

@@ -0,0 +1,23 @@
+import { NodeBase, SCALAR } from './Node.mjs';
+import { toJS } from './toJS.mjs';
+
+const isScalarValue = value => !value || typeof value !== 'function' && typeof value !== 'object';
+class Scalar extends NodeBase {
+  constructor(value) {
+    super(SCALAR);
+    this.value = value;
+  }
+  toJSON(arg, ctx) {
+    return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+  }
+  toString() {
+    return String(this.value);
+  }
+}
+Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar.PLAIN = 'PLAIN';
+Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+export { Scalar, isScalarValue };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/YAMLMap.mjs

@@ -0,0 +1,100 @@
+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 { isScalarValue } from './Scalar.mjs';
+
+function findPair(items, key) {
+  const k = isScalar(key) ? key.value : key;
+  for (const it of items) {
+    if (isPair(it)) {
+      if (it.key === key || it.key === k) return it;
+      if (isScalar(it.key) && it.key.value === k) return it;
+    }
+  }
+  return undefined;
+}
+class YAMLMap extends Collection {
+  constructor(schema) {
+    super(MAP, schema);
+    this.items = [];
+  }
+  static get tagName() {
+    return 'tag:yaml.org,2002:map';
+  }
+  /**
+   * Adds a value to the collection.
+   *
+   * @param overwrite - If not set `true`, using a key that is already in the
+   *   collection will throw. Otherwise, overwrites the previous value.
+   */
+  add(pair, overwrite) {
+    let _pair;
+    if (isPair(pair)) _pair = pair;else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
+      // In TypeScript, this never happens.
+      _pair = new Pair(pair, pair?.value);
+    } else _pair = new Pair(pair.key, pair.value);
+    const prev = findPair(this.items, _pair.key);
+    const sortEntries = this.schema?.sortMapEntries;
+    if (prev) {
+      if (!overwrite) throw new Error(`Key ${_pair.key} already set`);
+      // For scalars, keep the old node & its comments and anchors
+      if (isScalar(prev.value) && isScalarValue(_pair.value)) prev.value.value = _pair.value;else prev.value = _pair.value;
+    } else if (sortEntries) {
+      const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);
+      if (i === -1) this.items.push(_pair);else this.items.splice(i, 0, _pair);
+    } else {
+      this.items.push(_pair);
+    }
+  }
+  delete(key) {
+    const it = findPair(this.items, key);
+    if (!it) return false;
+    const del = this.items.splice(this.items.indexOf(it), 1);
+    return del.length > 0;
+  }
+  get(key, keepScalar) {
+    const it = findPair(this.items, key);
+    const node = it?.value;
+    return (!keepScalar && isScalar(node) ? node.value : node) ?? undefined;
+  }
+  has(key) {
+    return !!findPair(this.items, key);
+  }
+  set(key, value) {
+    this.add(new Pair(key, value), true);
+  }
+  /**
+   * @param ctx - Conversion context, originally set in Document#toJS()
+   * @param {Class} Type - If set, forces the returned collection type
+   * @returns Instance of Type, Map, or Object
+   */
+  toJSON(_, ctx, Type) {
+    const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+    if (ctx?.onCreate) ctx.onCreate(map);
+    for (const item of this.items) addPairToJSMap(ctx, map, item);
+    return map;
+  }
+  toString(ctx, onComment, onChompKeep) {
+    if (!ctx) return JSON.stringify(this);
+    for (const item of this.items) {
+      if (!isPair(item)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+    }
+    if (!ctx.allNullValues && this.hasAllNullValues(false)) ctx = Object.assign({}, ctx, {
+      allNullValues: true
+    });
+    return stringifyCollection(this, ctx, {
+      blockItemPrefix: '',
+      flowChars: {
+        start: '{',
+        end: '}'
+      },
+      itemIndent: ctx.indent || '',
+      onChompKeep,
+      onComment
+    });
+  }
+}
+
+export { YAMLMap, findPair };

package/build/esm/node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/dist/nodes/YAMLSeq.mjs

@@ -0,0 +1,88 @@
+import { stringifyCollection } from '../stringify/stringifyCollection.mjs';
+import { Collection } from './Collection.mjs';
+import { SEQ, isScalar } from './Node.mjs';
+import { isScalarValue } from './Scalar.mjs';
+import { toJS } from './toJS.mjs';
+
+class YAMLSeq extends Collection {
+  constructor(schema) {
+    super(SEQ, schema);
+    this.items = [];
+  }
+  static get tagName() {
+    return 'tag:yaml.org,2002:seq';
+  }
+  add(value) {
+    this.items.push(value);
+  }
+  /**
+   * Removes a value from the collection.
+   *
+   * `key` must contain a representation of an integer for this to succeed.
+   * It may be wrapped in a `Scalar`.
+   *
+   * @returns `true` if the item was found and removed.
+   */
+  delete(key) {
+    const idx = asItemIndex(key);
+    if (typeof idx !== 'number') return false;
+    const del = this.items.splice(idx, 1);
+    return del.length > 0;
+  }
+  get(key, keepScalar) {
+    const idx = asItemIndex(key);
+    if (typeof idx !== 'number') return undefined;
+    const it = this.items[idx];
+    return !keepScalar && isScalar(it) ? it.value : it;
+  }
+  /**
+   * Checks if the collection includes a value with the key `key`.
+   *
+   * `key` must contain a representation of an integer for this to succeed.
+   * It may be wrapped in a `Scalar`.
+   */
+  has(key) {
+    const idx = asItemIndex(key);
+    return typeof idx === 'number' && idx < this.items.length;
+  }
+  /**
+   * Sets a value in this collection. For `!!set`, `value` needs to be a
+   * boolean to add/remove the item from the set.
+   *
+   * If `key` does not contain a representation of an integer, this will throw.
+   * It may be wrapped in a `Scalar`.
+   */
+  set(key, value) {
+    const idx = asItemIndex(key);
+    if (typeof idx !== 'number') throw new Error(`Expected a valid index, not ${key}.`);
+    const prev = this.items[idx];
+    if (isScalar(prev) && isScalarValue(value)) prev.value = value;else this.items[idx] = value;
+  }
+  toJSON(_, ctx) {
+    const seq = [];
+    if (ctx?.onCreate) ctx.onCreate(seq);
+    let i = 0;
+    for (const item of this.items) seq.push(toJS(item, String(i++), ctx));
+    return seq;
+  }
+  toString(ctx, onComment, onChompKeep) {
+    if (!ctx) return JSON.stringify(this);
+    return stringifyCollection(this, ctx, {
+      blockItemPrefix: '- ',
+      flowChars: {
+        start: '[',
+        end: ']'
+      },
+      itemIndent: (ctx.indent || '') + '  ',
+      onChompKeep,
+      onComment
+    });
+  }
+}
+function asItemIndex(key) {
+  let idx = isScalar(key) ? key.value : key;
+  if (idx && typeof idx === 'string') idx = Number(idx);
+  return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0 ? idx : null;
+}
+
+export { YAMLSeq };

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

@@ -0,0 +1,83 @@
+import { warn } from '../log.mjs';
+import { createStringifyContext } from '../stringify/stringify.mjs';
+import { isAlias, isSeq, isScalar, isMap, isNode } from './Node.mjs';
+import { Scalar } from './Scalar.mjs';
+import { toJS } from './toJS.mjs';
+
+const MERGE_KEY = '<<';
+function addPairToJSMap(ctx, map, {
+  key,
+  value
+}) {
+  if (ctx?.doc.schema.merge && isMergeKey(key)) {
+    value = isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (isSeq(value)) for (const it of value.items) mergeToJSMap(ctx, map, it);else if (Array.isArray(value)) for (const it of value) mergeToJSMap(ctx, map, it);else mergeToJSMap(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;
+}
+const isMergeKey = key => key === MERGE_KEY || isScalar(key) && key.value === MERGE_KEY && (!key.type || key.type === Scalar.PLAIN);
+// If the value associated with a merge key is a single mapping node, each of
+// its key/value pairs is inserted into the current mapping, unless the key
+// already exists in it. If the value associated with the merge key is a
+// sequence, then this sequence is expected to contain mapping nodes and each
+// of these nodes is merged in turn according to its order in the sequence.
+// Keys in mapping nodes earlier in the sequence override keys specified in
+// later mapping nodes. -- http://yaml.org/type/merge.html
+function mergeToJSMap(ctx, map, value) {
+  const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+  if (!isMap(source)) throw new Error('Merge sources must be maps or map aliases');
+  const srcMap = source.toJSON(null, ctx, Map);
+  for (const [key, value] of srcMap) {
+    if (map instanceof Map) {
+      if (!map.has(key)) map.set(key, value);
+    } else if (map instanceof Set) {
+      map.add(key);
+    } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+      Object.defineProperty(map, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+  if (jsKey === null) return '';
+  if (typeof jsKey !== 'object') return String(jsKey);
+  if (isNode(key) && ctx && 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/toJS.mjs

@@ -0,0 +1,37 @@
+import { hasAnchor } from './Node.mjs';
+
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx));
+  if (value && typeof value.toJSON === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    if (!ctx || !hasAnchor(value)) return value.toJSON(arg, ctx);
+    const data = {
+      aliasCount: 0,
+      count: 1,
+      res: undefined
+    };
+    ctx.anchors.set(value, data);
+    ctx.onCreate = res => {
+      data.res = res;
+      delete ctx.onCreate;
+    };
+    const res = value.toJSON(arg, ctx);
+    if (ctx.onCreate) ctx.onCreate(res);
+    return res;
+  }
+  if (typeof value === 'bigint' && !ctx?.keep) return Number(value);
+  return value;
+}
+
+export { toJS };