@quilted/create 0.1.21 → 0.1.22

package/build/cjs/index3.cjs

@@ -1,5 +1,28 @@
 'use strict';
 
+function _mergeNamespaces(n, m) {
+    m.forEach(function (e) {
+        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+            if (k !== 'default' && !(k in n)) {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    });
+    return Object.freeze(n);
+}
+
+var dist = {};
+
+var composer$2 = {};
+
+var directives$2 = {};
+
+var Node$t = {};
+
 const ALIAS = Symbol.for('yaml.alias');
 const DOC = Symbol.for('yaml.document');
 const MAP = Symbol.for('yaml.map');
@@ -7,13 +30,13 @@ const PAIR = Symbol.for('yaml.pair');
 const SCALAR$1 = 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$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR$1;
-const isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
-function isCollection$1(node) {
+const isAlias$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;
+const isDocument$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;
+const isMap$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;
+const isPair$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;
+const isScalar$2 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR$1;
+const isSeq$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
+function isCollection$2(node) {
     if (node && typeof node === 'object')
         switch (node[NODE_TYPE]) {
             case MAP:
@@ -22,7 +45,7 @@ function isCollection$1(node) {
         }
     return false;
 }
-function isNode(node) {
+function isNode$1(node) {
     if (node && typeof node === 'object')
         switch (node[NODE_TYPE]) {
             case ALIAS:
@@ -33,7 +56,7 @@ function isNode(node) {
         }
     return false;
 }
-const hasAnchor = (node) => (isScalar$1(node) || isCollection$1(node)) && !!node.anchor;
+const hasAnchor = (node) => (isScalar$2(node) || isCollection$2(node)) && !!node.anchor;
 class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
@@ -47,6 +70,28 @@ class NodeBase {
     }
 }
 
+Node$t.ALIAS = ALIAS;
+Node$t.DOC = DOC;
+Node$t.MAP = MAP;
+Node$t.NODE_TYPE = NODE_TYPE;
+Node$t.NodeBase = NodeBase;
+Node$t.PAIR = PAIR;
+Node$t.SCALAR = SCALAR$1;
+Node$t.SEQ = SEQ;
+Node$t.hasAnchor = hasAnchor;
+Node$t.isAlias = isAlias$1;
+Node$t.isCollection = isCollection$2;
+Node$t.isDocument = isDocument$1;
+Node$t.isMap = isMap$1;
+Node$t.isNode = isNode$1;
+Node$t.isPair = isPair$1;
+Node$t.isScalar = isScalar$2;
+Node$t.isSeq = isSeq$1;
+
+var visit$6 = {};
+
+var Node$s = Node$t;
+
 const BREAK$1 = Symbol('break visit');
 const SKIP$1 = Symbol('skip children');
 const REMOVE$1 = Symbol('remove node');
@@ -80,9 +125,9 @@ const REMOVE$1 = Symbol('remove node');
  * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
  * specific defined one will be used for each node.
  */
-function visit$1(node, visitor) {
+function visit$5(node, visitor) {
     const visitor_ = initVisitor(visitor);
-    if (isDocument(node)) {
+    if (Node$s.isDocument(node)) {
         const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
         if (cd === REMOVE$1)
             node.contents = null;
@@ -94,19 +139,19 @@ function visit$1(node, visitor) {
 // namespace using `var`, but then complains about that because
 // `unique symbol` must be `const`.
 /** Terminate visit traversal completely */
-visit$1.BREAK = BREAK$1;
+visit$5.BREAK = BREAK$1;
 /** Do not visit the children of the current node */
-visit$1.SKIP = SKIP$1;
+visit$5.SKIP = SKIP$1;
 /** Remove the current node */
-visit$1.REMOVE = REMOVE$1;
+visit$5.REMOVE = REMOVE$1;
 function visit_(key, node, visitor, path) {
     const ctrl = callVisitor(key, node, visitor, path);
-    if (isNode(ctrl) || isPair(ctrl)) {
+    if (Node$s.isNode(ctrl) || Node$s.isPair(ctrl)) {
         replaceNode(key, path, ctrl);
         return visit_(key, ctrl, visitor, path);
     }
     if (typeof ctrl !== 'symbol') {
-        if (isCollection$1(node)) {
+        if (Node$s.isCollection(node)) {
             path = Object.freeze(path.concat(node));
             for (let i = 0; i < node.items.length; ++i) {
                 const ci = visit_(i, node.items[i], visitor, path);
@@ -120,7 +165,7 @@ function visit_(key, node, visitor, path) {
                 }
             }
         }
-        else if (isPair(node)) {
+        else if (Node$s.isPair(node)) {
             path = Object.freeze(path.concat(node));
             const ck = visit_('key', node.key, visitor, path);
             if (ck === BREAK$1)
@@ -167,9 +212,9 @@ function visit_(key, node, visitor, path) {
  * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
  * specific defined one will be used for each node.
  */
-async function visitAsync(node, visitor) {
+async function visitAsync$1(node, visitor) {
     const visitor_ = initVisitor(visitor);
-    if (isDocument(node)) {
+    if (Node$s.isDocument(node)) {
         const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));
         if (cd === REMOVE$1)
             node.contents = null;
@@ -181,19 +226,19 @@ async function visitAsync(node, visitor) {
 // namespace using `var`, but then complains about that because
 // `unique symbol` must be `const`.
 /** Terminate visit traversal completely */
-visitAsync.BREAK = BREAK$1;
+visitAsync$1.BREAK = BREAK$1;
 /** Do not visit the children of the current node */
-visitAsync.SKIP = SKIP$1;
+visitAsync$1.SKIP = SKIP$1;
 /** Remove the current node */
-visitAsync.REMOVE = REMOVE$1;
+visitAsync$1.REMOVE = REMOVE$1;
 async function visitAsync_(key, node, visitor, path) {
     const ctrl = await callVisitor(key, node, visitor, path);
-    if (isNode(ctrl) || isPair(ctrl)) {
+    if (Node$s.isNode(ctrl) || Node$s.isPair(ctrl)) {
         replaceNode(key, path, ctrl);
         return visitAsync_(key, ctrl, visitor, path);
     }
     if (typeof ctrl !== 'symbol') {
-        if (isCollection$1(node)) {
+        if (Node$s.isCollection(node)) {
             path = Object.freeze(path.concat(node));
             for (let i = 0; i < node.items.length; ++i) {
                 const ci = await visitAsync_(i, node.items[i], visitor, path);
@@ -207,7 +252,7 @@ async function visitAsync_(key, node, visitor, path) {
                 }
             }
         }
-        else if (isPair(node)) {
+        else if (Node$s.isPair(node)) {
             path = Object.freeze(path.concat(node));
             const ck = await visitAsync_('key', node.key, visitor, path);
             if (ck === BREAK$1)
@@ -245,38 +290,44 @@ function initVisitor(visitor) {
 function callVisitor(key, node, visitor, path) {
     if (typeof visitor === 'function')
         return visitor(key, node, path);
-    if (isMap(node))
+    if (Node$s.isMap(node))
         return visitor.Map?.(key, node, path);
-    if (isSeq(node))
+    if (Node$s.isSeq(node))
         return visitor.Seq?.(key, node, path);
-    if (isPair(node))
+    if (Node$s.isPair(node))
         return visitor.Pair?.(key, node, path);
-    if (isScalar$1(node))
+    if (Node$s.isScalar(node))
         return visitor.Scalar?.(key, node, path);
-    if (isAlias(node))
+    if (Node$s.isAlias(node))
         return visitor.Alias?.(key, node, path);
     return undefined;
 }
 function replaceNode(key, path, node) {
     const parent = path[path.length - 1];
-    if (isCollection$1(parent)) {
+    if (Node$s.isCollection(parent)) {
         parent.items[key] = node;
     }
-    else if (isPair(parent)) {
+    else if (Node$s.isPair(parent)) {
         if (key === 'key')
             parent.key = node;
         else
             parent.value = node;
     }
-    else if (isDocument(parent)) {
+    else if (Node$s.isDocument(parent)) {
         parent.contents = node;
     }
     else {
-        const pt = isAlias(parent) ? 'alias' : 'scalar';
+        const pt = Node$s.isAlias(parent) ? 'alias' : 'scalar';
         throw new Error(`Cannot replace node with ${pt} parent`);
     }
 }
 
+visit$6.visit = visit$5;
+visit$6.visitAsync = visitAsync$1;
+
+var Node$r = Node$t;
+var visit$4 = visit$6;
+
 const escapeChars = {
     '!': '%21',
     ',': '%2C',
@@ -420,10 +471,10 @@ class Directives {
             : [];
         const tagEntries = Object.entries(this.tags);
         let tagNames;
-        if (doc && tagEntries.length > 0 && isNode(doc.contents)) {
+        if (doc && tagEntries.length > 0 && Node$r.isNode(doc.contents)) {
             const tags = {};
-            visit$1(doc.contents, (_key, node) => {
-                if (isNode(node) && node.tag)
+            visit$4.visit(doc.contents, (_key, node) => {
+                if (Node$r.isNode(node) && node.tag)
                     tags[node.tag] = true;
             });
             tagNames = Object.keys(tags);
@@ -442,6 +493,17 @@ class Directives {
 Directives.defaultYaml = { explicit: false, version: '1.2' };
 Directives.defaultTags = { '!!': 'tag:yaml.org,2002:' };
 
+directives$2.Directives = Directives;
+
+var Document$5 = {};
+
+var Alias$5 = {};
+
+var anchors$3 = {};
+
+var Node$q = Node$t;
+var visit$3 = visit$6;
+
 /**
  * Verify that the input string is a valid anchor.
  *
@@ -457,7 +519,7 @@ function anchorIsValid(anchor) {
 }
 function anchorNames(root) {
     const anchors = new Set();
-    visit$1(root, {
+    visit$3.visit(root, {
         Value(_key, node) {
             if (node.anchor)
                 anchors.add(node.anchor);
@@ -496,7 +558,7 @@ function createNodeAnchors(doc, prefix) {
                 const ref = sourceObjects.get(source);
                 if (typeof ref === 'object' &&
                     ref.anchor &&
-                    (isScalar$1(ref.node) || isCollection$1(ref.node))) {
+                    (Node$q.isScalar(ref.node) || Node$q.isCollection(ref.node))) {
                     ref.node.anchor = ref.anchor;
                 }
                 else {
@@ -510,9 +572,18 @@ function createNodeAnchors(doc, prefix) {
     };
 }
 
-class Alias extends NodeBase {
+anchors$3.anchorIsValid = anchorIsValid;
+anchors$3.anchorNames = anchorNames;
+anchors$3.createNodeAnchors = createNodeAnchors;
+anchors$3.findNewAnchor = findNewAnchor;
+
+var anchors$2 = anchors$3;
+var visit$2 = visit$6;
+var Node$p = Node$t;
+
+class Alias$4 extends Node$p.NodeBase {
     constructor(source) {
-        super(ALIAS);
+        super(Node$p.ALIAS);
         this.source = source;
         Object.defineProperty(this, 'tag', {
             set() {
@@ -526,10 +597,10 @@ class Alias extends NodeBase {
      */
     resolve(doc) {
         let found = undefined;
-        visit$1(doc, {
+        visit$2.visit(doc, {
             Node: (_key, node) => {
                 if (node === this)
-                    return visit$1.BREAK;
+                    return visit$2.visit.BREAK;
                 if (node.anchor === this.source)
                     found = node;
             }
@@ -565,7 +636,7 @@ class Alias extends NodeBase {
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;
         if (ctx) {
-            anchorIsValid(this.source);
+            anchors$2.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);
@@ -577,12 +648,12 @@ class Alias extends NodeBase {
     }
 }
 function getAliasCount(doc, node, anchors) {
-    if (isAlias(node)) {
+    if (Node$p.isAlias(node)) {
         const source = node.resolve(doc);
         const anchor = anchors && source && anchors.get(source);
         return anchor ? anchor.count * anchor.aliasCount : 0;
     }
-    else if (isCollection$1(node)) {
+    else if (Node$p.isCollection(node)) {
         let count = 0;
         for (const item of node.items) {
             const c = getAliasCount(doc, item, anchors);
@@ -591,7 +662,7 @@ function getAliasCount(doc, node, anchors) {
         }
         return count;
     }
-    else if (isPair(node)) {
+    else if (Node$p.isPair(node)) {
         const kc = getAliasCount(doc, node.key, anchors);
         const vc = getAliasCount(doc, node.value, anchors);
         return Math.max(kc, vc);
@@ -599,6 +670,18 @@ function getAliasCount(doc, node, anchors) {
     return 1;
 }
 
+Alias$5.Alias = Alias$4;
+
+var Collection$5 = {};
+
+var createNode$5 = {};
+
+var Scalar$k = {};
+
+var toJS$6 = {};
+
+var Node$o = Node$t;
+
 /**
  * Recursively convert any node or its contents to native JavaScript
  *
@@ -609,13 +692,13 @@ function getAliasCount(doc, node, anchors) {
  *   `{ keep: true }` is not set, output should be suitable for JSON
  *   stringification.
  */
-function toJS(value, arg, ctx) {
+function toJS$5(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));
+        return value.map((v, i) => toJS$5(v, String(i), ctx));
     if (value && typeof value.toJSON === 'function') {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        if (!ctx || !hasAnchor(value))
+        if (!ctx || !Node$o.hasAnchor(value))
             return value.toJSON(arg, ctx);
         const data = { aliasCount: 0, count: 1, res: undefined };
         ctx.anchors.set(value, data);
@@ -633,24 +716,36 @@ function toJS(value, arg, ctx) {
     return value;
 }
 
+toJS$6.toJS = toJS$5;
+
+var Node$n = Node$t;
+var toJS$4 = toJS$6;
+
 const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
-class Scalar extends NodeBase {
+class Scalar$j extends Node$n.NodeBase {
     constructor(value) {
-        super(SCALAR$1);
+        super(Node$n.SCALAR);
         this.value = value;
     }
     toJSON(arg, ctx) {
-        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+        return ctx?.keep ? this.value : toJS$4.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';
+Scalar$j.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar$j.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar$j.PLAIN = 'PLAIN';
+Scalar$j.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar$j.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+Scalar$k.Scalar = Scalar$j;
+Scalar$k.isScalarValue = isScalarValue;
+
+var Alias$3 = Alias$5;
+var Node$m = Node$t;
+var Scalar$i = Scalar$k;
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
 function findTagObject(value, tagName, tags) {
@@ -663,13 +758,13 @@ function findTagObject(value, tagName, tags) {
     }
     return tags.find(t => t.identify?.(value) && !t.format);
 }
-function createNode(value, tagName, ctx) {
-    if (isDocument(value))
+function createNode$4(value, tagName, ctx) {
+    if (Node$m.isDocument(value))
         value = value.contents;
-    if (isNode(value))
+    if (Node$m.isNode(value))
         return value;
-    if (isPair(value)) {
-        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);
+    if (Node$m.isPair(value)) {
+        const map = ctx.schema[Node$m.MAP].createNode?.(ctx.schema, null, ctx);
         map.items.push(value);
         return map;
     }
@@ -690,7 +785,7 @@ function createNode(value, tagName, ctx) {
         if (ref) {
             if (!ref.anchor)
                 ref.anchor = onAnchor(value);
-            return new Alias(ref.anchor);
+            return new Alias$3.Alias(ref.anchor);
         }
         else {
             ref = { anchor: null, node: null };
@@ -706,17 +801,17 @@ function createNode(value, tagName, ctx) {
             value = value.toJSON();
         }
         if (!value || typeof value !== 'object') {
-            const node = new Scalar(value);
+            const node = new Scalar$i.Scalar(value);
             if (ref)
                 ref.node = node;
             return node;
         }
         tagObj =
             value instanceof Map
-                ? schema[MAP]
+                ? schema[Node$m.MAP]
                 : Symbol.iterator in Object(value)
-                    ? schema[SEQ]
-                    : schema[MAP];
+                    ? schema[Node$m.SEQ]
+                    : schema[Node$m.MAP];
     }
     if (onTagObj) {
         onTagObj(tagObj);
@@ -724,7 +819,7 @@ function createNode(value, tagName, ctx) {
     }
     const node = tagObj?.createNode
         ? tagObj.createNode(ctx.schema, value, ctx)
-        : new Scalar(value);
+        : new Scalar$i.Scalar(value);
     if (tagName)
         node.tag = tagName;
     if (ref)
@@ -732,6 +827,11 @@ function createNode(value, tagName, ctx) {
     return node;
 }
 
+createNode$5.createNode = createNode$4;
+
+var createNode$3 = createNode$5;
+var Node$l = Node$t;
+
 function collectionFromPath(schema, path, value) {
     let v = value;
     for (let i = path.length - 1; i >= 0; --i) {
@@ -745,7 +845,7 @@ function collectionFromPath(schema, path, value) {
             v = new Map([[k, v]]);
         }
     }
-    return createNode(v, undefined, {
+    return createNode$3.createNode(v, undefined, {
         aliasDuplicateObjects: false,
         keepUndefined: false,
         onAnchor: () => {
@@ -759,7 +859,7 @@ function collectionFromPath(schema, path, value) {
 // 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 {
+class Collection$4 extends Node$l.NodeBase {
     constructor(type, schema) {
         super(type);
         Object.defineProperty(this, 'schema', {
@@ -778,7 +878,7 @@ class Collection extends NodeBase {
         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);
+        copy.items = copy.items.map(it => Node$l.isNode(it) || Node$l.isPair(it) ? it.clone(schema) : it);
         if (this.range)
             copy.range = this.range.slice();
         return copy;
@@ -794,7 +894,7 @@ class Collection extends NodeBase {
         else {
             const [key, ...rest] = path;
             const node = this.get(key, true);
-            if (isCollection$1(node))
+            if (Node$l.isCollection(node))
                 node.addIn(rest, value);
             else if (node === undefined && this.schema)
                 this.set(key, collectionFromPath(this.schema, rest, value));
@@ -811,7 +911,7 @@ class Collection extends NodeBase {
         if (rest.length === 0)
             return this.delete(key);
         const node = this.get(key, true);
-        if (isCollection$1(node))
+        if (Node$l.isCollection(node))
             return node.deleteIn(rest);
         else
             throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
@@ -825,18 +925,18 @@ class Collection extends NodeBase {
         const [key, ...rest] = path;
         const node = this.get(key, true);
         if (rest.length === 0)
-            return !keepScalar && isScalar$1(node) ? node.value : node;
+            return !keepScalar && Node$l.isScalar(node) ? node.value : node;
         else
-            return isCollection$1(node) ? node.getIn(rest, keepScalar) : undefined;
+            return Node$l.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
     }
     hasAllNullValues(allowScalar) {
         return this.items.every(node => {
-            if (!isPair(node))
+            if (!Node$l.isPair(node))
                 return false;
             const n = node.value;
             return (n == null ||
                 (allowScalar &&
-                    isScalar$1(n) &&
+                    Node$l.isScalar(n) &&
                     n.value == null &&
                     !n.commentBefore &&
                     !n.comment &&
@@ -851,7 +951,7 @@ class Collection extends NodeBase {
         if (rest.length === 0)
             return this.has(key);
         const node = this.get(key, true);
-        return isCollection$1(node) ? node.hasIn(rest) : false;
+        return Node$l.isCollection(node) ? node.hasIn(rest) : false;
     }
     /**
      * Sets a value in this collection. For `!!set`, `value` needs to be a
@@ -864,7 +964,7 @@ class Collection extends NodeBase {
         }
         else {
             const node = this.get(key, true);
-            if (isCollection$1(node))
+            if (Node$l.isCollection(node))
                 node.setIn(rest, value);
             else if (node === undefined && this.schema)
                 this.set(key, collectionFromPath(this.schema, rest, value));
@@ -873,7 +973,19 @@ class Collection extends NodeBase {
         }
     }
 }
-Collection.maxFlowStringSingleLineLength = 60;
+Collection$4.maxFlowStringSingleLineLength = 60;
+
+Collection$5.Collection = Collection$4;
+Collection$5.collectionFromPath = collectionFromPath;
+Collection$5.isEmptyPath = isEmptyPath;
+
+var Pair$9 = {};
+
+var stringifyPair$2 = {};
+
+var stringify$9 = {};
+
+var stringifyComment$5 = {};
 
 /**
  * Stringifies a comment.
@@ -882,7 +994,7 @@ Collection.maxFlowStringSingleLineLength = 60;
  * lines consisting of a single space are replaced by `#`,
  * and all other lines are prefixed with a `#`.
  */
-const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');
+const stringifyComment$4 = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');
 function indentComment(comment, indent) {
     if (/^\n+$/.test(comment))
         return comment.substring(1);
@@ -894,6 +1006,14 @@ const lineComment = (str, indent, comment) => str.endsWith('\n')
         ? '\n' + indentComment(comment, indent)
         : (str.endsWith(' ') ? '' : ' ') + comment;
 
+stringifyComment$5.indentComment = indentComment;
+stringifyComment$5.lineComment = lineComment;
+stringifyComment$5.stringifyComment = stringifyComment$4;
+
+var stringifyString$5 = {};
+
+var foldFlowLines$2 = {};
+
 const FOLD_FLOW = 'flow';
 const FOLD_BLOCK = 'block';
 const FOLD_QUOTED = 'quoted';
@@ -902,7 +1022,7 @@ const FOLD_QUOTED = 'quoted';
  * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
  * terminated with `\n` and started with `indent`.
  */
-function foldFlowLines(text, indent, mode, { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow }) {
+function foldFlowLines$1(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
     if (!lineWidth || lineWidth < 0)
         return text;
     const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
@@ -1028,6 +1148,14 @@ function consumeMoreIndentedLines(text, i) {
     return i;
 }
 
+foldFlowLines$2.FOLD_BLOCK = FOLD_BLOCK;
+foldFlowLines$2.FOLD_FLOW = FOLD_FLOW;
+foldFlowLines$2.FOLD_QUOTED = FOLD_QUOTED;
+foldFlowLines$2.foldFlowLines = foldFlowLines$1;
+
+var Scalar$h = Scalar$k;
+var foldFlowLines = foldFlowLines$2;
+
 const getFoldOptions = (ctx) => ({
     indentAtStart: ctx.indentAtStart,
     lineWidth: ctx.options.lineWidth,
@@ -1142,7 +1270,7 @@ function doubleQuotedString(value, ctx) {
     str = start ? str + json.slice(start) : json;
     return implicitKey
         ? str
-        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx));
 }
 function singleQuotedString(value, ctx) {
     if (ctx.options.singleQuote === false ||
@@ -1154,7 +1282,7 @@ function singleQuotedString(value, ctx) {
     const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
     return ctx.implicitKey
         ? res
-        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
+        : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
 }
 function quotedString(value, ctx) {
     const { singleQuote } = ctx.options;
@@ -1184,9 +1312,9 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
     const literal = blockQuote === 'literal'
         ? true
-        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED
+        : blockQuote === 'folded' || type === Scalar$h.Scalar.BLOCK_FOLDED
             ? false
-            : type === Scalar.BLOCK_LITERAL
+            : type === Scalar$h.Scalar.BLOCK_LITERAL
                 ? true
                 : !lineLengthOverLimit(value, lineWidth, indent.length);
     if (!value)
@@ -1252,7 +1380,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
         //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
@@ -1276,7 +1404,7 @@ function plainString(item, ctx, onComment, onChompKeep) {
     }
     if (!implicitKey &&
         !inFlow &&
-        type !== Scalar.PLAIN &&
+        type !== Scalar$h.Scalar.PLAIN &&
         value.includes('\n')) {
         // Where allowed & type not set explicitly, prefer block style for multiline strings
         return blockString(item, ctx, onComment, onChompKeep);
@@ -1297,31 +1425,31 @@ function plainString(item, ctx, onComment, onChompKeep) {
     }
     return implicitKey
         ? str
-        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
 }
-function stringifyString(item, ctx, onComment, onChompKeep) {
+function stringifyString$4(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;
     const ss = typeof item.value === 'string'
         ? item
         : Object.assign({}, item, { value: String(item.value) });
     let { type } = item;
-    if (type !== Scalar.QUOTE_DOUBLE) {
+    if (type !== Scalar$h.Scalar.QUOTE_DOUBLE) {
         // force double quotes on control characters & unpaired surrogates
         if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value))
-            type = Scalar.QUOTE_DOUBLE;
+            type = Scalar$h.Scalar.QUOTE_DOUBLE;
     }
     const _stringify = (_type) => {
         switch (_type) {
-            case Scalar.BLOCK_FOLDED:
-            case Scalar.BLOCK_LITERAL:
+            case Scalar$h.Scalar.BLOCK_FOLDED:
+            case Scalar$h.Scalar.BLOCK_LITERAL:
                 return implicitKey || inFlow
                     ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
                     : blockString(ss, ctx, onComment, onChompKeep);
-            case Scalar.QUOTE_DOUBLE:
+            case Scalar$h.Scalar.QUOTE_DOUBLE:
                 return doubleQuotedString(ss.value, ctx);
-            case Scalar.QUOTE_SINGLE:
+            case Scalar$h.Scalar.QUOTE_SINGLE:
                 return singleQuotedString(ss.value, ctx);
-            case Scalar.PLAIN:
+            case Scalar$h.Scalar.PLAIN:
                 return plainString(ss, ctx, onComment, onChompKeep);
             default:
                 return null;
@@ -1338,10 +1466,17 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     return res;
 }
 
+stringifyString$5.stringifyString = stringifyString$4;
+
+var anchors$1 = anchors$3;
+var Node$k = Node$t;
+var stringifyComment$3 = stringifyComment$5;
+var stringifyString$3 = stringifyString$5;
+
 function createStringifyContext(doc, options) {
     const opt = Object.assign({
         blockQuote: true,
-        commentString: stringifyComment,
+        commentString: stringifyComment$3.stringifyComment,
         defaultKeyType: null,
         defaultStringType: 'PLAIN',
         directives: null,
@@ -1385,7 +1520,7 @@ function getTagObject(tags, item) {
     }
     let tagObj = undefined;
     let obj;
-    if (isScalar$1(item)) {
+    if (Node$k.isScalar(item)) {
         obj = item.value;
         const match = tags.filter(t => t.identify?.(obj));
         tagObj =
@@ -1402,13 +1537,13 @@ function getTagObject(tags, item) {
     return tagObj;
 }
 // needs to be called before value stringifier to allow for circular anchor refs
-function stringifyProps(node, tagObj, { anchors, doc }) {
+function stringifyProps(node, tagObj, { anchors: anchors$1$1, doc }) {
     if (!doc.directives)
         return '';
     const props = [];
-    const anchor = (isScalar$1(node) || isCollection$1(node)) && node.anchor;
-    if (anchor && anchorIsValid(anchor)) {
-        anchors.add(anchor);
+    const anchor = (Node$k.isScalar(node) || Node$k.isCollection(node)) && node.anchor;
+    if (anchor && anchors$1.anchorIsValid(anchor)) {
+        anchors$1$1.add(anchor);
         props.push(`&${anchor}`);
     }
     const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
@@ -1416,10 +1551,10 @@ function stringifyProps(node, tagObj, { anchors, doc }) {
         props.push(doc.directives.tagString(tag));
     return props.join(' ');
 }
-function stringify$2(item, ctx, onComment, onChompKeep) {
-    if (isPair(item))
+function stringify$8(item, ctx, onComment, onChompKeep) {
+    if (Node$k.isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
-    if (isAlias(item)) {
+    if (Node$k.isAlias(item)) {
         if (ctx.doc.directives)
             return item.toString(ctx);
         if (ctx.resolvedAliases?.has(item)) {
@@ -1434,7 +1569,7 @@ function stringify$2(item, ctx, onComment, onChompKeep) {
         }
     }
     let tagObj = undefined;
-    const node = isNode(item)
+    const node = Node$k.isNode(item)
         ? item
         : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });
     if (!tagObj)
@@ -1444,24 +1579,32 @@ function stringify$2(item, ctx, onComment, onChompKeep) {
         ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
     const str = typeof tagObj.stringify === 'function'
         ? tagObj.stringify(node, ctx, onComment, onChompKeep)
-        : isScalar$1(node)
-            ? stringifyString(node, ctx, onComment, onChompKeep)
+        : Node$k.isScalar(node)
+            ? stringifyString$3.stringifyString(node, ctx, onComment, onChompKeep)
             : node.toString(ctx, onComment, onChompKeep);
     if (!props)
         return str;
-    return isScalar$1(node) || str[0] === '{' || str[0] === '['
+    return Node$k.isScalar(node) || str[0] === '{' || str[0] === '['
         ? `${props} ${str}`
         : `${props}\n${ctx.indent}${str}`;
 }
 
-function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+stringify$9.createStringifyContext = createStringifyContext;
+stringify$9.stringify = stringify$8;
+
+var Node$j = Node$t;
+var Scalar$g = Scalar$k;
+var stringify$7 = stringify$9;
+var stringifyComment$2 = stringifyComment$5;
+
+function stringifyPair$1({ key, value }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
-    let keyComment = (isNode(key) && key.comment) || null;
+    let keyComment = (Node$j.isNode(key) && key.comment) || null;
     if (simpleKeys) {
         if (keyComment) {
             throw new Error('With simple keys, key nodes cannot have comments');
         }
-        if (isCollection$1(key)) {
+        if (Node$j.isCollection(key)) {
             const msg = 'With simple keys, collection cannot be used as a key value';
             throw new Error(msg);
         }
@@ -1469,9 +1612,9 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     let explicitKey = !simpleKeys &&
         (!key ||
             (keyComment && value == null && !ctx.inFlow) ||
-            isCollection$1(key) ||
-            (isScalar$1(key)
-                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL
+            Node$j.isCollection(key) ||
+            (Node$j.isScalar(key)
+                ? key.type === Scalar$g.Scalar.BLOCK_FOLDED || key.type === Scalar$g.Scalar.BLOCK_LITERAL
                 : typeof key === 'object'));
     ctx = Object.assign({}, ctx, {
         allNullValues: false,
@@ -1480,7 +1623,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     });
     let keyCommentDone = false;
     let chompKeep = false;
-    let str = stringify$2(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));
+    let str = stringify$7.stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));
     if (!explicitKey && !ctx.inFlow && str.length > 1024) {
         if (simpleKeys)
             throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
@@ -1496,7 +1639,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
         str = `? ${str}`;
         if (keyComment && !keyCommentDone) {
-            str += lineComment(str, ctx.indent, commentString(keyComment));
+            str += stringifyComment$2.lineComment(str, ctx.indent, commentString(keyComment));
         }
         else if (chompKeep && onChompKeep)
             onChompKeep();
@@ -1506,22 +1649,22 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         keyComment = null;
     if (explicitKey) {
         if (keyComment)
-            str += lineComment(str, ctx.indent, commentString(keyComment));
+            str += stringifyComment$2.lineComment(str, ctx.indent, commentString(keyComment));
         str = `? ${str}\n${indent}:`;
     }
     else {
         str = `${str}:`;
         if (keyComment)
-            str += lineComment(str, ctx.indent, commentString(keyComment));
+            str += stringifyComment$2.lineComment(str, ctx.indent, commentString(keyComment));
     }
     let vcb = '';
     let valueComment = null;
-    if (isNode(value)) {
+    if (Node$j.isNode(value)) {
         if (value.spaceBefore)
             vcb = '\n';
         if (value.commentBefore) {
             const cs = commentString(value.commentBefore);
-            vcb += `\n${indentComment(cs, ctx.indent)}`;
+            vcb += `\n${stringifyComment$2.indentComment(cs, ctx.indent)}`;
         }
         valueComment = value.comment;
     }
@@ -1529,14 +1672,14 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         value = doc.createNode(value);
     }
     ctx.implicitKey = false;
-    if (!explicitKey && !keyComment && isScalar$1(value))
+    if (!explicitKey && !keyComment && Node$j.isScalar(value))
         ctx.indentAtStart = str.length + 1;
     chompKeep = false;
     if (!indentSeq &&
         indentStep.length >= 2 &&
         !ctx.inFlow &&
         !explicitKey &&
-        isSeq(value) &&
+        Node$j.isSeq(value) &&
         !value.flow &&
         !value.tag &&
         !value.anchor) {
@@ -1544,7 +1687,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         ctx.indent = ctx.indent.substr(2);
     }
     let valueCommentDone = false;
-    const valueStr = stringify$2(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
+    const valueStr = stringify$7.stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
     let ws = ' ';
     if (vcb || keyComment) {
         if (valueStr === '' && !ctx.inFlow)
@@ -1552,7 +1695,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         else
             ws = `${vcb}\n${ctx.indent}`;
     }
-    else if (!explicitKey && isCollection$1(value)) {
+    else if (!explicitKey && Node$j.isCollection(value)) {
         const flow = valueStr[0] === '[' || valueStr[0] === '{';
         if (!flow || valueStr.includes('\n'))
             ws = `\n${ctx.indent}`;
@@ -1565,7 +1708,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
             onComment();
     }
     else if (valueComment && !valueCommentDone) {
-        str += lineComment(str, ctx.indent, commentString(valueComment));
+        str += stringifyComment$2.lineComment(str, ctx.indent, commentString(valueComment));
     }
     else if (chompKeep && onChompKeep) {
         onChompKeep();
@@ -1573,6 +1716,16 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     return str;
 }
 
+stringifyPair$2.stringifyPair = stringifyPair$1;
+
+var addPairToJSMap$3 = {};
+
+var log$2 = {};
+
+function debug(logLevel, ...messages) {
+    if (logLevel === 'debug')
+        console.log(...messages);
+}
 function warn(logLevel, warning) {
     if (logLevel === 'debug' || logLevel === 'warn') {
         if (typeof process !== 'undefined' && process.emitWarning)
@@ -1582,11 +1735,20 @@ function warn(logLevel, warning) {
     }
 }
 
+log$2.debug = debug;
+log$2.warn = warn;
+
+var log$1 = log$2;
+var stringify$6 = stringify$9;
+var Node$i = Node$t;
+var Scalar$f = Scalar$k;
+var toJS$3 = toJS$6;
+
 const MERGE_KEY = '<<';
-function addPairToJSMap(ctx, map, { key, value }) {
+function addPairToJSMap$2(ctx, map, { key, value }) {
     if (ctx?.doc.schema.merge && isMergeKey(key)) {
-        value = isAlias(value) ? value.resolve(ctx.doc) : value;
-        if (isSeq(value))
+        value = Node$i.isAlias(value) ? value.resolve(ctx.doc) : value;
+        if (Node$i.isSeq(value))
             for (const it of value.items)
                 mergeToJSMap(ctx, map, it);
         else if (Array.isArray(value))
@@ -1596,16 +1758,16 @@ function addPairToJSMap(ctx, map, { key, value }) {
             mergeToJSMap(ctx, map, value);
     }
     else {
-        const jsKey = toJS(key, '', ctx);
+        const jsKey = toJS$3.toJS(key, '', ctx);
         if (map instanceof Map) {
-            map.set(jsKey, toJS(value, jsKey, ctx));
+            map.set(jsKey, toJS$3.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);
+            const jsValue = toJS$3.toJS(value, stringKey, ctx);
             if (stringKey in map)
                 Object.defineProperty(map, stringKey, {
                     value: jsValue,
@@ -1620,9 +1782,9 @@ function addPairToJSMap(ctx, map, { key, value }) {
     return map;
 }
 const isMergeKey = (key) => key === MERGE_KEY ||
-    (isScalar$1(key) &&
+    (Node$i.isScalar(key) &&
         key.value === MERGE_KEY &&
-        (!key.type || key.type === Scalar.PLAIN));
+        (!key.type || key.type === Scalar$f.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
@@ -1631,8 +1793,8 @@ const isMergeKey = (key) => key === MERGE_KEY ||
 // 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))
+    const source = ctx && Node$i.isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (!Node$i.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) {
@@ -1659,8 +1821,8 @@ function stringifyKey(key, jsKey, ctx) {
         return '';
     if (typeof jsKey !== 'object')
         return String(jsKey);
-    if (isNode(key) && ctx && ctx.doc) {
-        const strCtx = createStringifyContext(ctx.doc, {});
+    if (Node$i.isNode(key) && ctx && ctx.doc) {
+        const strCtx = stringify$6.createStringifyContext(ctx.doc, {});
         strCtx.anchors = new Set();
         for (const node of ctx.anchors.keys())
             strCtx.anchors.add(node.anchor);
@@ -1671,7 +1833,7 @@ function stringifyKey(key, jsKey, ctx) {
             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.`);
+            log$1.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;
@@ -1679,37 +1841,60 @@ function stringifyKey(key, jsKey, ctx) {
     return JSON.stringify(jsKey);
 }
 
+addPairToJSMap$3.addPairToJSMap = addPairToJSMap$2;
+
+var createNode$2 = createNode$5;
+var stringifyPair = stringifyPair$2;
+var addPairToJSMap$1 = addPairToJSMap$3;
+var Node$h = Node$t;
+
 function createPair(key, value, ctx) {
-    const k = createNode(key, undefined, ctx);
-    const v = createNode(value, undefined, ctx);
-    return new Pair(k, v);
+    const k = createNode$2.createNode(key, undefined, ctx);
+    const v = createNode$2.createNode(value, undefined, ctx);
+    return new Pair$8(k, v);
 }
-class Pair {
+class Pair$8 {
     constructor(key, value = null) {
-        Object.defineProperty(this, NODE_TYPE, { value: PAIR });
+        Object.defineProperty(this, Node$h.NODE_TYPE, { value: Node$h.PAIR });
         this.key = key;
         this.value = value;
     }
     clone(schema) {
         let { key, value } = this;
-        if (isNode(key))
+        if (Node$h.isNode(key))
             key = key.clone(schema);
-        if (isNode(value))
+        if (Node$h.isNode(value))
             value = value.clone(schema);
-        return new Pair(key, value);
+        return new Pair$8(key, value);
     }
     toJSON(_, ctx) {
         const pair = ctx?.mapAsMap ? new Map() : {};
-        return addPairToJSMap(ctx, pair, this);
+        return addPairToJSMap$1.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
         return ctx?.doc
-            ? stringifyPair(this, ctx, onComment, onChompKeep)
+            ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
             : JSON.stringify(this);
     }
 }
 
-function stringifyCollection(collection, ctx, options) {
+Pair$9.Pair = Pair$8;
+Pair$9.createPair = createPair;
+
+var Schema$3 = {};
+
+var map$6 = {};
+
+var YAMLMap$7 = {};
+
+var stringifyCollection$3 = {};
+
+var Collection$3 = Collection$5;
+var Node$g = Node$t;
+var stringify$5 = stringify$9;
+var stringifyComment$1 = stringifyComment$5;
+
+function stringifyCollection$2(collection, ctx, options) {
     const flow = ctx.inFlow ?? collection.flow;
     const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;
     return stringify(collection, ctx, options);
@@ -1722,15 +1907,15 @@ function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, fl
     for (let i = 0; i < items.length; ++i) {
         const item = items[i];
         let comment = null;
-        if (isNode(item)) {
+        if (Node$g.isNode(item)) {
             if (!chompKeep && item.spaceBefore)
                 lines.push('');
             addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
             if (item.comment)
                 comment = item.comment;
         }
-        else if (isPair(item)) {
-            const ik = isNode(item.key) ? item.key : null;
+        else if (Node$g.isPair(item)) {
+            const ik = Node$g.isNode(item.key) ? item.key : null;
             if (ik) {
                 if (!chompKeep && ik.spaceBefore)
                     lines.push('');
@@ -1738,9 +1923,9 @@ function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, fl
             }
         }
         chompKeep = false;
-        let str = stringify$2(item, itemCtx, () => (comment = null), () => (chompKeep = true));
+        let str = stringify$5.stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));
         if (comment)
-            str += lineComment(str, itemIndent, commentString(comment));
+            str += stringifyComment$1.lineComment(str, itemIndent, commentString(comment));
         if (chompKeep && comment)
             chompKeep = false;
         lines.push(blockItemPrefix + str);
@@ -1757,7 +1942,7 @@ function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, fl
         }
     }
     if (comment) {
-        str += '\n' + indentComment(commentString(comment), indent);
+        str += '\n' + stringifyComment$1.indentComment(commentString(comment), indent);
         if (onComment)
             onComment();
     }
@@ -1779,15 +1964,15 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
     for (let i = 0; i < items.length; ++i) {
         const item = items[i];
         let comment = null;
-        if (isNode(item)) {
+        if (Node$g.isNode(item)) {
             if (item.spaceBefore)
                 lines.push('');
             addCommentBefore(ctx, lines, item.commentBefore, false);
             if (item.comment)
                 comment = item.comment;
         }
-        else if (isPair(item)) {
-            const ik = isNode(item.key) ? item.key : null;
+        else if (Node$g.isPair(item)) {
+            const ik = Node$g.isNode(item.key) ? item.key : null;
             if (ik) {
                 if (ik.spaceBefore)
                     lines.push('');
@@ -1795,7 +1980,7 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
                 if (ik.comment)
                     reqNewline = true;
             }
-            const iv = isNode(item.value) ? item.value : null;
+            const iv = Node$g.isNode(item.value) ? item.value : null;
             if (iv) {
                 if (iv.comment)
                     comment = iv.comment;
@@ -1808,11 +1993,11 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
         }
         if (comment)
             reqNewline = true;
-        let str = stringify$2(item, itemCtx, () => (comment = null));
+        let str = stringify$5.stringify(item, itemCtx, () => (comment = null));
         if (i < items.length - 1)
             str += ',';
         if (comment)
-            str += lineComment(str, itemIndent, commentString(comment));
+            str += stringifyComment$1.lineComment(str, itemIndent, commentString(comment));
         if (!reqNewline && (lines.length > linesAtValue || str.includes('\n')))
             reqNewline = true;
         lines.push(str);
@@ -1826,7 +2011,7 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
     else {
         if (!reqNewline) {
             const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
-            reqNewline = len > Collection.maxFlowStringSingleLineLength;
+            reqNewline = len > Collection$3.Collection.maxFlowStringSingleLineLength;
         }
         if (reqNewline) {
             str = start;
@@ -1839,7 +2024,7 @@ function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemInden
         }
     }
     if (comment) {
-        str += lineComment(str, commentString(comment), indent);
+        str += stringifyComment$1.lineComment(str, commentString(comment), indent);
         if (onComment)
             onComment();
     }
@@ -1849,26 +2034,35 @@ function addCommentBefore({ indent, options: { commentString } }, lines, comment
     if (comment && chompKeep)
         comment = comment.replace(/^\n+/, '');
     if (comment) {
-        const ic = indentComment(commentString(comment), indent);
+        const ic = stringifyComment$1.indentComment(commentString(comment), indent);
         lines.push(ic.trimStart()); // Avoid double indent on first line
     }
 }
 
+stringifyCollection$3.stringifyCollection = stringifyCollection$2;
+
+var stringifyCollection$1 = stringifyCollection$3;
+var addPairToJSMap = addPairToJSMap$3;
+var Collection$2 = Collection$5;
+var Node$f = Node$t;
+var Pair$7 = Pair$9;
+var Scalar$e = Scalar$k;
+
 function findPair(items, key) {
-    const k = isScalar$1(key) ? key.value : key;
+    const k = Node$f.isScalar(key) ? key.value : key;
     for (const it of items) {
-        if (isPair(it)) {
+        if (Node$f.isPair(it)) {
             if (it.key === key || it.key === k)
                 return it;
-            if (isScalar$1(it.key) && it.key.value === k)
+            if (Node$f.isScalar(it.key) && it.key.value === k)
                 return it;
         }
     }
     return undefined;
 }
-class YAMLMap extends Collection {
+class YAMLMap$6 extends Collection$2.Collection {
     constructor(schema) {
-        super(MAP, schema);
+        super(Node$f.MAP, schema);
         this.items = [];
     }
     static get tagName() {
@@ -1882,21 +2076,21 @@ class YAMLMap extends Collection {
      */
     add(pair, overwrite) {
         let _pair;
-        if (isPair(pair))
+        if (Node$f.isPair(pair))
             _pair = pair;
         else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
             // In TypeScript, this never happens.
-            _pair = new Pair(pair, pair?.value);
+            _pair = new Pair$7.Pair(pair, pair?.value);
         }
         else
-            _pair = new Pair(pair.key, pair.value);
+            _pair = new Pair$7.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$1(prev.value) && isScalarValue(_pair.value))
+            if (Node$f.isScalar(prev.value) && Scalar$e.isScalarValue(_pair.value))
                 prev.value.value = _pair.value;
             else
                 prev.value = _pair.value;
@@ -1922,13 +2116,13 @@ class YAMLMap extends Collection {
     get(key, keepScalar) {
         const it = findPair(this.items, key);
         const node = it?.value;
-        return (!keepScalar && isScalar$1(node) ? node.value : node) ?? undefined;
+        return (!keepScalar && Node$f.isScalar(node) ? node.value : node) ?? undefined;
     }
     has(key) {
         return !!findPair(this.items, key);
     }
     set(key, value) {
-        this.add(new Pair(key, value), true);
+        this.add(new Pair$7.Pair(key, value), true);
     }
     /**
      * @param ctx - Conversion context, originally set in Document#toJS()
@@ -1940,19 +2134,19 @@ class YAMLMap extends Collection {
         if (ctx?.onCreate)
             ctx.onCreate(map);
         for (const item of this.items)
-            addPairToJSMap(ctx, map, item);
+            addPairToJSMap.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))
+            if (!Node$f.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, {
+        return stringifyCollection$1.stringifyCollection(this, ctx, {
             blockItemPrefix: '',
             flowChars: { start: '{', end: '}' },
             itemIndent: ctx.indent || '',
@@ -1962,16 +2156,23 @@ class YAMLMap extends Collection {
     }
 }
 
+YAMLMap$7.YAMLMap = YAMLMap$6;
+YAMLMap$7.findPair = findPair;
+
+var Node$e = Node$t;
+var Pair$6 = Pair$9;
+var YAMLMap$5 = YAMLMap$7;
+
 function createMap(schema, obj, ctx) {
     const { keepUndefined, replacer } = ctx;
-    const map = new YAMLMap(schema);
+    const map = new YAMLMap$5.YAMLMap(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));
+            map.items.push(Pair$6.createPair(key, value, ctx));
     };
     if (obj instanceof Map) {
         for (const [key, value] of obj)
@@ -1986,22 +2187,34 @@ function createMap(schema, obj, ctx) {
     }
     return map;
 }
-const map = {
+const map$5 = {
     collection: 'map',
     createNode: createMap,
     default: true,
-    nodeClass: YAMLMap,
+    nodeClass: YAMLMap$5.YAMLMap,
     tag: 'tag:yaml.org,2002:map',
     resolve(map, onError) {
-        if (!isMap(map))
+        if (!Node$e.isMap(map))
             onError('Expected a mapping for this tag');
         return map;
     }
 };
 
-class YAMLSeq extends Collection {
+map$6.map = map$5;
+
+var seq$6 = {};
+
+var YAMLSeq$7 = {};
+
+var stringifyCollection = stringifyCollection$3;
+var Collection$1 = Collection$5;
+var Node$d = Node$t;
+var Scalar$d = Scalar$k;
+var toJS$2 = toJS$6;
+
+class YAMLSeq$6 extends Collection$1.Collection {
     constructor(schema) {
-        super(SEQ, schema);
+        super(Node$d.SEQ, schema);
         this.items = [];
     }
     static get tagName() {
@@ -2030,7 +2243,7 @@ class YAMLSeq extends Collection {
         if (typeof idx !== 'number')
             return undefined;
         const it = this.items[idx];
-        return !keepScalar && isScalar$1(it) ? it.value : it;
+        return !keepScalar && Node$d.isScalar(it) ? it.value : it;
     }
     /**
      * Checks if the collection includes a value with the key `key`.
@@ -2054,7 +2267,7 @@ class YAMLSeq extends Collection {
         if (typeof idx !== 'number')
             throw new Error(`Expected a valid index, not ${key}.`);
         const prev = this.items[idx];
-        if (isScalar$1(prev) && isScalarValue(value))
+        if (Node$d.isScalar(prev) && Scalar$d.isScalarValue(value))
             prev.value = value;
         else
             this.items[idx] = value;
@@ -2065,13 +2278,13 @@ class YAMLSeq extends Collection {
             ctx.onCreate(seq);
         let i = 0;
         for (const item of this.items)
-            seq.push(toJS(item, String(i++), ctx));
+            seq.push(toJS$2.toJS(item, String(i++), ctx));
         return seq;
     }
     toString(ctx, onComment, onChompKeep) {
         if (!ctx)
             return JSON.stringify(this);
-        return stringifyCollection(this, ctx, {
+        return stringifyCollection.stringifyCollection(this, ctx, {
             blockItemPrefix: '- ',
             flowChars: { start: '[', end: ']' },
             itemIndent: (ctx.indent || '') + '  ',
@@ -2081,7 +2294,7 @@ class YAMLSeq extends Collection {
     }
 }
 function asItemIndex(key) {
-    let idx = isScalar$1(key) ? key.value : key;
+    let idx = Node$d.isScalar(key) ? key.value : key;
     if (idx && typeof idx === 'string')
         idx = Number(idx);
     return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0
@@ -2089,9 +2302,15 @@ function asItemIndex(key) {
         : null;
 }
 
+YAMLSeq$7.YAMLSeq = YAMLSeq$6;
+
+var createNode$1 = createNode$5;
+var Node$c = Node$t;
+var YAMLSeq$5 = YAMLSeq$7;
+
 function createSeq(schema, obj, ctx) {
     const { replacer } = ctx;
-    const seq = new YAMLSeq(schema);
+    const seq = new YAMLSeq$5.YAMLSeq(schema);
     if (obj && Symbol.iterator in Object(obj)) {
         let i = 0;
         for (let it of obj) {
@@ -2099,53 +2318,73 @@ function createSeq(schema, obj, ctx) {
                 const key = obj instanceof Set ? it : String(i++);
                 it = replacer.call(obj, key, it);
             }
-            seq.items.push(createNode(it, undefined, ctx));
+            seq.items.push(createNode$1.createNode(it, undefined, ctx));
         }
     }
     return seq;
 }
-const seq = {
+const seq$5 = {
     collection: 'seq',
     createNode: createSeq,
     default: true,
-    nodeClass: YAMLSeq,
+    nodeClass: YAMLSeq$5.YAMLSeq,
     tag: 'tag:yaml.org,2002:seq',
     resolve(seq, onError) {
-        if (!isSeq(seq))
+        if (!Node$c.isSeq(seq))
             onError('Expected a sequence for this tag');
         return seq;
     }
 };
 
-const string = {
+seq$6.seq = seq$5;
+
+var string$5 = {};
+
+var stringifyString$2 = stringifyString$5;
+
+const string$4 = {
     identify: value => typeof value === 'string',
     default: true,
     tag: 'tag:yaml.org,2002:str',
     resolve: str => str,
     stringify(item, ctx, onComment, onChompKeep) {
         ctx = Object.assign({ actualString: true }, ctx);
-        return stringifyString(item, ctx, onComment, onChompKeep);
+        return stringifyString$2.stringifyString(item, ctx, onComment, onChompKeep);
     }
 };
 
+string$5.string = string$4;
+
+var tags$1 = {};
+
+var _null$3 = {};
+
+var Scalar$c = Scalar$k;
+
 const nullTag = {
     identify: value => value == null,
-    createNode: () => new Scalar(null),
+    createNode: () => new Scalar$c.Scalar(null),
     default: true,
     tag: 'tag:yaml.org,2002:null',
     test: /^(?:~|[Nn]ull|NULL)?$/,
-    resolve: () => new Scalar(null),
+    resolve: () => new Scalar$c.Scalar(null),
     stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)
         ? source
         : ctx.options.nullStr
 };
 
+_null$3.nullTag = nullTag;
+
+var bool$4 = {};
+
+var Scalar$b = Scalar$k;
+
 const boolTag = {
     identify: value => typeof value === 'boolean',
     default: true,
     tag: 'tag:yaml.org,2002:bool',
     test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
-    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),
+    resolve: str => new Scalar$b.Scalar(str[0] === 't' || str[0] === 'T'),
     stringify({ source, value }, ctx) {
         if (source && boolTag.test.test(source)) {
             const sv = source[0] === 't' || source[0] === 'T';
@@ -2156,7 +2395,13 @@ const boolTag = {
     }
 };
 
-function stringifyNumber({ format, minFractionDigits, tag, value }) {
+bool$4.boolTag = boolTag;
+
+var float$6 = {};
+
+var stringifyNumber$6 = {};
+
+function stringifyNumber$5({ format, minFractionDigits, tag, value }) {
     if (typeof value === 'bigint')
         return String(value);
     const num = typeof value === 'number' ? value : Number(value);
@@ -2179,6 +2424,11 @@ function stringifyNumber({ format, minFractionDigits, tag, value }) {
     return n;
 }
 
+stringifyNumber$6.stringifyNumber = stringifyNumber$5;
+
+var Scalar$a = Scalar$k;
+var stringifyNumber$4 = stringifyNumber$6;
+
 const floatNaN$1 = {
     identify: value => typeof value === 'number',
     default: true,
@@ -2189,7 +2439,7 @@ const floatNaN$1 = {
         : str[0] === '-'
             ? Number.NEGATIVE_INFINITY
             : Number.POSITIVE_INFINITY,
-    stringify: stringifyNumber
+    stringify: stringifyNumber$4.stringifyNumber
 };
 const floatExp$1 = {
     identify: value => typeof value === 'number',
@@ -2200,31 +2450,39 @@ const floatExp$1 = {
     resolve: str => parseFloat(str),
     stringify(node) {
         const num = Number(node.value);
-        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+        return isFinite(num) ? num.toExponential() : stringifyNumber$4.stringifyNumber(node);
     }
 };
-const float$1 = {
+const float$5 = {
     identify: value => typeof value === 'number',
     default: true,
     tag: 'tag:yaml.org,2002:float',
     test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
     resolve(str) {
-        const node = new Scalar(parseFloat(str));
+        const node = new Scalar$a.Scalar(parseFloat(str));
         const dot = str.indexOf('.');
         if (dot !== -1 && str[str.length - 1] === '0')
             node.minFractionDigits = str.length - dot - 1;
         return node;
     },
-    stringify: stringifyNumber
+    stringify: stringifyNumber$4.stringifyNumber
 };
 
+float$6.float = float$5;
+float$6.floatExp = floatExp$1;
+float$6.floatNaN = floatNaN$1;
+
+var int$6 = {};
+
+var stringifyNumber$3 = stringifyNumber$6;
+
 const intIdentify$2 = (value) => typeof value === 'bigint' || Number.isInteger(value);
 const intResolve$1 = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));
 function intStringify$1(node, radix, prefix) {
     const { value } = node;
     if (intIdentify$2(value) && value >= 0)
         return prefix + value.toString(radix);
-    return stringifyNumber(node);
+    return stringifyNumber$3.stringifyNumber(node);
 }
 const intOct$1 = {
     identify: value => intIdentify$2(value) && value >= 0,
@@ -2235,13 +2493,13 @@ const intOct$1 = {
     resolve: (str, _onError, opt) => intResolve$1(str, 2, 8, opt),
     stringify: node => intStringify$1(node, 8, '0o')
 };
-const int$1 = {
+const int$5 = {
     identify: intIdentify$2,
     default: true,
     tag: 'tag:yaml.org,2002:int',
     test: /^[-+]?[0-9]+$/,
     resolve: (str, _onError, opt) => intResolve$1(str, 0, 10, opt),
-    stringify: stringifyNumber
+    stringify: stringifyNumber$3.stringifyNumber
 };
 const intHex$1 = {
     identify: value => intIdentify$2(value) && value >= 0,
@@ -2253,20 +2511,42 @@ const intHex$1 = {
     stringify: node => intStringify$1(node, 16, '0x')
 };
 
-const schema$2 = [
-    map,
-    seq,
-    string,
-    nullTag,
-    boolTag,
-    intOct$1,
-    int$1,
-    intHex$1,
-    floatNaN$1,
-    floatExp$1,
-    float$1
+int$6.int = int$5;
+int$6.intHex = intHex$1;
+int$6.intOct = intOct$1;
+
+var schema$8 = {};
+
+var map$4 = map$6;
+var _null$2 = _null$3;
+var seq$4 = seq$6;
+var string$3 = string$5;
+var bool$3 = bool$4;
+var float$4 = float$6;
+var int$4 = int$6;
+
+const schema$7 = [
+    map$4.map,
+    seq$4.seq,
+    string$3.string,
+    _null$2.nullTag,
+    bool$3.boolTag,
+    int$4.intOct,
+    int$4.int,
+    int$4.intHex,
+    float$4.floatNaN,
+    float$4.floatExp,
+    float$4.float
 ];
 
+schema$8.schema = schema$7;
+
+var schema$6 = {};
+
+var Scalar$9 = Scalar$k;
+var map$3 = map$6;
+var seq$3 = seq$6;
+
 function intIdentify$1(value) {
     return typeof value === 'bigint' || Number.isInteger(value);
 }
@@ -2281,7 +2561,7 @@ const jsonScalars = [
     },
     {
         identify: value => value == null,
-        createNode: () => new Scalar(null),
+        createNode: () => new Scalar$9.Scalar(null),
         default: true,
         tag: 'tag:yaml.org,2002:null',
         test: /^null$/,
@@ -2322,9 +2602,16 @@ const jsonError = {
         return str;
     }
 };
-const schema$1 = [map, seq].concat(jsonScalars, jsonError);
+const schema$5 = [map$3.map, seq$3.seq].concat(jsonScalars, jsonError);
+
+schema$6.schema = schema$5;
+
+var binary$3 = {};
 
-const binary = {
+var Scalar$8 = Scalar$k;
+var stringifyString$1 = stringifyString$5;
+
+const binary$2 = {
     identify: value => value instanceof Uint8Array,
     default: false,
     tag: 'tag:yaml.org,2002:binary',
@@ -2372,30 +2659,41 @@ const binary = {
             throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
         }
         if (!type)
-            type = Scalar.BLOCK_LITERAL;
-        if (type !== Scalar.QUOTE_DOUBLE) {
+            type = Scalar$8.Scalar.BLOCK_LITERAL;
+        if (type !== Scalar$8.Scalar.QUOTE_DOUBLE) {
             const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
             const n = Math.ceil(str.length / lineWidth);
             const lines = new Array(n);
             for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
                 lines[i] = str.substr(o, lineWidth);
             }
-            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\n' : ' ');
+            str = lines.join(type === Scalar$8.Scalar.BLOCK_LITERAL ? '\n' : ' ');
         }
-        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);
+        return stringifyString$1.stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);
     }
 };
 
+binary$3.binary = binary$2;
+
+var omap$3 = {};
+
+var pairs$4 = {};
+
+var Node$b = Node$t;
+var Pair$5 = Pair$9;
+var Scalar$7 = Scalar$k;
+var YAMLSeq$4 = YAMLSeq$7;
+
 function resolvePairs(seq, onError) {
-    if (isSeq(seq)) {
+    if (Node$b.isSeq(seq)) {
         for (let i = 0; i < seq.items.length; ++i) {
             let item = seq.items[i];
-            if (isPair(item))
+            if (Node$b.isPair(item))
                 continue;
-            else if (isMap(item)) {
+            else if (Node$b.isMap(item)) {
                 if (item.items.length > 1)
                     onError('Each pair must have its own sequence indicator');
-                const pair = item.items[0] || new Pair(new Scalar(null));
+                const pair = item.items[0] || new Pair$5.Pair(new Scalar$7.Scalar(null));
                 if (item.commentBefore)
                     pair.key.commentBefore = pair.key.commentBefore
                         ? `${item.commentBefore}\n${pair.key.commentBefore}`
@@ -2408,7 +2706,7 @@ function resolvePairs(seq, onError) {
                 }
                 item = pair;
             }
-            seq.items[i] = isPair(item) ? item : new Pair(item);
+            seq.items[i] = Node$b.isPair(item) ? item : new Pair$5.Pair(item);
         }
     }
     else
@@ -2417,7 +2715,7 @@ function resolvePairs(seq, onError) {
 }
 function createPairs(schema, iterable, ctx) {
     const { replacer } = ctx;
-    const pairs = new YAMLSeq(schema);
+    const pairs = new YAMLSeq$4.YAMLSeq(schema);
     pairs.tag = 'tag:yaml.org,2002:pairs';
     let i = 0;
     if (iterable && Symbol.iterator in Object(iterable))
@@ -2445,11 +2743,11 @@ function createPairs(schema, iterable, ctx) {
             else {
                 key = it;
             }
-            pairs.items.push(createPair(key, value, ctx));
+            pairs.items.push(Pair$5.createPair(key, value, ctx));
         }
     return pairs;
 }
-const pairs = {
+const pairs$3 = {
     collection: 'seq',
     default: false,
     tag: 'tag:yaml.org,2002:pairs',
@@ -2457,14 +2755,24 @@ const pairs = {
     createNode: createPairs
 };
 
-class YAMLOMap extends YAMLSeq {
+pairs$4.createPairs = createPairs;
+pairs$4.pairs = pairs$3;
+pairs$4.resolvePairs = resolvePairs;
+
+var YAMLSeq$3 = YAMLSeq$7;
+var toJS$1 = toJS$6;
+var Node$a = Node$t;
+var YAMLMap$4 = YAMLMap$7;
+var pairs$2 = pairs$4;
+
+class YAMLOMap extends YAMLSeq$3.YAMLSeq {
     constructor() {
         super();
-        this.add = YAMLMap.prototype.add.bind(this);
-        this.delete = YAMLMap.prototype.delete.bind(this);
-        this.get = YAMLMap.prototype.get.bind(this);
-        this.has = YAMLMap.prototype.has.bind(this);
-        this.set = YAMLMap.prototype.set.bind(this);
+        this.add = YAMLMap$4.YAMLMap.prototype.add.bind(this);
+        this.delete = YAMLMap$4.YAMLMap.prototype.delete.bind(this);
+        this.get = YAMLMap$4.YAMLMap.prototype.get.bind(this);
+        this.has = YAMLMap$4.YAMLMap.prototype.has.bind(this);
+        this.set = YAMLMap$4.YAMLMap.prototype.set.bind(this);
         this.tag = YAMLOMap.tag;
     }
     /**
@@ -2479,12 +2787,12 @@ class YAMLOMap extends YAMLSeq {
             ctx.onCreate(map);
         for (const pair of this.items) {
             let key, value;
-            if (isPair(pair)) {
-                key = toJS(pair.key, '', ctx);
-                value = toJS(pair.value, key, ctx);
+            if (Node$a.isPair(pair)) {
+                key = toJS$1.toJS(pair.key, '', ctx);
+                value = toJS$1.toJS(pair.value, key, ctx);
             }
             else {
-                key = toJS(pair, '', ctx);
+                key = toJS$1.toJS(pair, '', ctx);
             }
             if (map.has(key))
                 throw new Error('Ordered maps must not include duplicate keys');
@@ -2494,17 +2802,17 @@ class YAMLOMap extends YAMLSeq {
     }
 }
 YAMLOMap.tag = 'tag:yaml.org,2002:omap';
-const omap = {
+const omap$2 = {
     collection: 'seq',
     identify: value => value instanceof Map,
     nodeClass: YAMLOMap,
     default: false,
     tag: 'tag:yaml.org,2002:omap',
     resolve(seq, onError) {
-        const pairs = resolvePairs(seq, onError);
+        const pairs$1 = pairs$2.resolvePairs(seq, onError);
         const seenKeys = [];
-        for (const { key } of pairs.items) {
-            if (isScalar$1(key)) {
+        for (const { key } of pairs$1.items) {
+            if (Node$a.isScalar(key)) {
                 if (seenKeys.includes(key.value)) {
                     onError(`Ordered maps must not include duplicate keys: ${key.value}`);
                 }
@@ -2513,16 +2821,25 @@ const omap = {
                 }
             }
         }
-        return Object.assign(new YAMLOMap(), pairs);
+        return Object.assign(new YAMLOMap(), pairs$1);
     },
     createNode(schema, iterable, ctx) {
-        const pairs = createPairs(schema, iterable, ctx);
+        const pairs$1 = pairs$2.createPairs(schema, iterable, ctx);
         const omap = new YAMLOMap();
-        omap.items = pairs.items;
+        omap.items = pairs$1.items;
         return omap;
     }
 };
 
+omap$3.YAMLOMap = YAMLOMap;
+omap$3.omap = omap$2;
+
+var schema$4 = {};
+
+var bool$2 = {};
+
+var Scalar$6 = Scalar$k;
+
 function boolStringify({ value, source }, ctx) {
     const boolObj = value ? trueTag : falseTag;
     if (source && boolObj.test.test(source))
@@ -2534,7 +2851,7 @@ const trueTag = {
     default: true,
     tag: 'tag:yaml.org,2002:bool',
     test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
-    resolve: () => new Scalar(true),
+    resolve: () => new Scalar$6.Scalar(true),
     stringify: boolStringify
 };
 const falseTag = {
@@ -2542,10 +2859,18 @@ const falseTag = {
     default: true,
     tag: 'tag:yaml.org,2002:bool',
     test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
-    resolve: () => new Scalar(false),
+    resolve: () => new Scalar$6.Scalar(false),
     stringify: boolStringify
 };
 
+bool$2.falseTag = falseTag;
+bool$2.trueTag = trueTag;
+
+var float$3 = {};
+
+var Scalar$5 = Scalar$k;
+var stringifyNumber$2 = stringifyNumber$6;
+
 const floatNaN = {
     identify: value => typeof value === 'number',
     default: true,
@@ -2556,7 +2881,7 @@ const floatNaN = {
         : str[0] === '-'
             ? Number.NEGATIVE_INFINITY
             : Number.POSITIVE_INFINITY,
-    stringify: stringifyNumber
+    stringify: stringifyNumber$2.stringifyNumber
 };
 const floatExp = {
     identify: value => typeof value === 'number',
@@ -2567,16 +2892,16 @@ const floatExp = {
     resolve: (str) => parseFloat(str.replace(/_/g, '')),
     stringify(node) {
         const num = Number(node.value);
-        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+        return isFinite(num) ? num.toExponential() : stringifyNumber$2.stringifyNumber(node);
     }
 };
-const float = {
+const float$2 = {
     identify: value => typeof value === 'number',
     default: true,
     tag: 'tag:yaml.org,2002:float',
     test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
     resolve(str) {
-        const node = new Scalar(parseFloat(str.replace(/_/g, '')));
+        const node = new Scalar$5.Scalar(parseFloat(str.replace(/_/g, '')));
         const dot = str.indexOf('.');
         if (dot !== -1) {
             const f = str.substring(dot + 1).replace(/_/g, '');
@@ -2585,9 +2910,17 @@ const float = {
         }
         return node;
     },
-    stringify: stringifyNumber
+    stringify: stringifyNumber$2.stringifyNumber
 };
 
+float$3.float = float$2;
+float$3.floatExp = floatExp;
+float$3.floatNaN = floatNaN;
+
+var int$3 = {};
+
+var stringifyNumber$1 = stringifyNumber$6;
+
 const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
 function intResolve(str, offset, radix, { intAsBigInt }) {
     const sign = str[0];
@@ -2618,7 +2951,7 @@ function intStringify(node, radix, prefix) {
         const str = value.toString(radix);
         return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
     }
-    return stringifyNumber(node);
+    return stringifyNumber$1.stringifyNumber(node);
 }
 const intBin = {
     identify: intIdentify,
@@ -2638,13 +2971,13 @@ const intOct = {
     resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
     stringify: node => intStringify(node, 8, '0')
 };
-const int = {
+const int$2 = {
     identify: intIdentify,
     default: true,
     tag: 'tag:yaml.org,2002:int',
     test: /^[-+]?[0-9][0-9_]*$/,
     resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
-    stringify: stringifyNumber
+    stringify: stringifyNumber$1.stringifyNumber
 };
 const intHex = {
     identify: intIdentify,
@@ -2656,23 +2989,34 @@ const intHex = {
     stringify: node => intStringify(node, 16, '0x')
 };
 
-class YAMLSet extends YAMLMap {
+int$3.int = int$2;
+int$3.intBin = intBin;
+int$3.intHex = intHex;
+int$3.intOct = intOct;
+
+var set$3 = {};
+
+var Node$9 = Node$t;
+var Pair$4 = Pair$9;
+var YAMLMap$3 = YAMLMap$7;
+
+class YAMLSet extends YAMLMap$3.YAMLMap {
     constructor(schema) {
         super(schema);
         this.tag = YAMLSet.tag;
     }
     add(key) {
         let pair;
-        if (isPair(key))
+        if (Node$9.isPair(key))
             pair = key;
         else if (typeof key === 'object' &&
             'key' in key &&
             'value' in key &&
             key.value === null)
-            pair = new Pair(key.key, null);
+            pair = new Pair$4.Pair(key.key, null);
         else
-            pair = new Pair(key, null);
-        const prev = findPair(this.items, pair.key);
+            pair = new Pair$4.Pair(key, null);
+        const prev = YAMLMap$3.findPair(this.items, pair.key);
         if (!prev)
             this.items.push(pair);
     }
@@ -2681,9 +3025,9 @@ class YAMLSet extends YAMLMap {
      * Otherwise, returns the value of that Pair's key.
      */
     get(key, keepPair) {
-        const pair = findPair(this.items, key);
-        return !keepPair && isPair(pair)
-            ? isScalar$1(pair.key)
+        const pair = YAMLMap$3.findPair(this.items, key);
+        return !keepPair && Node$9.isPair(pair)
+            ? Node$9.isScalar(pair.key)
                 ? pair.key.value
                 : pair.key
             : pair;
@@ -2691,12 +3035,12 @@ class YAMLSet extends YAMLMap {
     set(key, value) {
         if (typeof value !== 'boolean')
             throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
-        const prev = findPair(this.items, key);
+        const prev = YAMLMap$3.findPair(this.items, key);
         if (prev && !value) {
             this.items.splice(this.items.indexOf(prev), 1);
         }
         else if (!prev && value) {
-            this.items.push(new Pair(key));
+            this.items.push(new Pair$4.Pair(key));
         }
     }
     toJSON(_, ctx) {
@@ -2712,14 +3056,14 @@ class YAMLSet extends YAMLMap {
     }
 }
 YAMLSet.tag = 'tag:yaml.org,2002:set';
-const set = {
+const set$2 = {
     collection: 'map',
     identify: value => value instanceof Set,
     nodeClass: YAMLSet,
     default: false,
     tag: 'tag:yaml.org,2002:set',
     resolve(map, onError) {
-        if (isMap(map)) {
+        if (Node$9.isMap(map)) {
             if (map.hasAllNullValues(true))
                 return Object.assign(new YAMLSet(), map);
             else
@@ -2736,12 +3080,19 @@ const set = {
             for (let value of iterable) {
                 if (typeof replacer === 'function')
                     value = replacer.call(iterable, value, value);
-                set.items.push(createPair(value, null, ctx));
+                set.items.push(Pair$4.createPair(value, null, ctx));
             }
         return set;
     }
 };
 
+set$3.YAMLSet = YAMLSet;
+set$3.set = set$2;
+
+var timestamp$3 = {};
+
+var stringifyNumber = stringifyNumber$6;
+
 /** Internal types handle bigint as number, because TS can't figure it out. */
 function parseSexagesimal(str, asBigInt) {
     const sign = str[0];
@@ -2764,7 +3115,7 @@ function stringifySexagesimal(node) {
     if (typeof value === 'bigint')
         num = n => BigInt(n);
     else if (isNaN(value) || !isFinite(value))
-        return stringifyNumber(node);
+        return stringifyNumber.stringifyNumber(node);
     let sign = '';
     if (value < 0) {
         sign = '-';
@@ -2808,7 +3159,7 @@ const floatTime = {
     resolve: str => parseSexagesimal(str, false),
     stringify: stringifySexagesimal
 };
-const timestamp = {
+const timestamp$2 = {
     identify: value => value instanceof Date,
     default: true,
     tag: 'tag:yaml.org,2002:timestamp',
@@ -2822,7 +3173,7 @@ const timestamp = {
         '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30
         ')?$'),
     resolve(str) {
-        const match = str.match(timestamp.test);
+        const match = str.match(timestamp$2.test);
         if (!match)
             throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');
         const [, year, month, day, hour, minute, second] = match.map(Number);
@@ -2840,61 +3191,96 @@ const timestamp = {
     stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '')
 };
 
-const schema = [
-    map,
-    seq,
-    string,
-    nullTag,
-    trueTag,
-    falseTag,
-    intBin,
-    intOct,
-    int,
-    intHex,
-    floatNaN,
-    floatExp,
-    float,
-    binary,
-    omap,
-    pairs,
-    set,
-    intTime,
-    floatTime,
-    timestamp
+timestamp$3.floatTime = floatTime;
+timestamp$3.intTime = intTime;
+timestamp$3.timestamp = timestamp$2;
+
+var map$2 = map$6;
+var _null$1 = _null$3;
+var seq$2 = seq$6;
+var string$2 = string$5;
+var binary$1 = binary$3;
+var bool$1 = bool$2;
+var float$1 = float$3;
+var int$1 = int$3;
+var omap$1 = omap$3;
+var pairs$1 = pairs$4;
+var set$1 = set$3;
+var timestamp$1 = timestamp$3;
+
+const schema$3 = [
+    map$2.map,
+    seq$2.seq,
+    string$2.string,
+    _null$1.nullTag,
+    bool$1.trueTag,
+    bool$1.falseTag,
+    int$1.intBin,
+    int$1.intOct,
+    int$1.int,
+    int$1.intHex,
+    float$1.floatNaN,
+    float$1.floatExp,
+    float$1.float,
+    binary$1.binary,
+    omap$1.omap,
+    pairs$1.pairs,
+    set$1.set,
+    timestamp$1.intTime,
+    timestamp$1.floatTime,
+    timestamp$1.timestamp
 ];
 
+schema$4.schema = schema$3;
+
+var map$1 = map$6;
+var _null = _null$3;
+var seq$1 = seq$6;
+var string$1 = string$5;
+var bool = bool$4;
+var float = float$6;
+var int = int$6;
+var schema = schema$8;
+var schema$1 = schema$6;
+var binary = binary$3;
+var omap = omap$3;
+var pairs = pairs$4;
+var schema$2 = schema$4;
+var set = set$3;
+var timestamp = timestamp$3;
+
 const schemas = new Map([
-    ['core', schema$2],
-    ['failsafe', [map, seq, string]],
-    ['json', schema$1],
-    ['yaml11', schema],
-    ['yaml-1.1', schema]
+    ['core', schema.schema],
+    ['failsafe', [map$1.map, seq$1.seq, string$1.string]],
+    ['json', schema$1.schema],
+    ['yaml11', schema$2.schema],
+    ['yaml-1.1', schema$2.schema]
 ]);
 const tagsByName = {
-    binary,
-    bool: boolTag,
-    float: float$1,
-    floatExp: floatExp$1,
-    floatNaN: floatNaN$1,
-    floatTime,
-    int: int$1,
-    intHex: intHex$1,
-    intOct: intOct$1,
-    intTime,
-    map,
-    null: nullTag,
-    omap,
-    pairs,
-    seq,
-    set,
-    timestamp
+    binary: binary.binary,
+    bool: bool.boolTag,
+    float: float.float,
+    floatExp: float.floatExp,
+    floatNaN: float.floatNaN,
+    floatTime: timestamp.floatTime,
+    int: int.int,
+    intHex: int.intHex,
+    intOct: int.intOct,
+    intTime: timestamp.intTime,
+    map: map$1.map,
+    null: _null.nullTag,
+    omap: omap.omap,
+    pairs: pairs.pairs,
+    seq: seq$1.seq,
+    set: set.set,
+    timestamp: timestamp.timestamp
 };
 const coreKnownTags = {
-    'tag:yaml.org,2002:binary': binary,
-    'tag:yaml.org,2002:omap': omap,
-    'tag:yaml.org,2002:pairs': pairs,
-    'tag:yaml.org,2002:set': set,
-    'tag:yaml.org,2002:timestamp': timestamp
+    'tag:yaml.org,2002:binary': binary.binary,
+    'tag:yaml.org,2002:omap': omap.omap,
+    'tag:yaml.org,2002:pairs': pairs.pairs,
+    'tag:yaml.org,2002:set': set.set,
+    'tag:yaml.org,2002:timestamp': timestamp.timestamp
 };
 function getTags(customTags, schemaName) {
     let tags = schemas.get(schemaName);
@@ -2929,22 +3315,31 @@ function getTags(customTags, schemaName) {
     });
 }
 
+tags$1.coreKnownTags = coreKnownTags;
+tags$1.getTags = getTags;
+
+var Node$8 = Node$t;
+var map = map$6;
+var seq = seq$6;
+var string = string$5;
+var tags = tags$1;
+
 const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
-class Schema {
+class Schema$2 {
     constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
         this.compat = Array.isArray(compat)
-            ? getTags(compat, 'compat')
+            ? tags.getTags(compat, 'compat')
             : compat
-                ? getTags(null, compat)
+                ? tags.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.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
+        this.tags = tags.getTags(customTags, this.name);
         this.toStringOptions = toStringDefaults ?? null;
-        Object.defineProperty(this, MAP, { value: map });
-        Object.defineProperty(this, SCALAR$1, { value: string });
-        Object.defineProperty(this, SEQ, { value: seq });
+        Object.defineProperty(this, Node$8.MAP, { value: map.map });
+        Object.defineProperty(this, Node$8.SCALAR, { value: string.string });
+        Object.defineProperty(this, Node$8.SEQ, { value: seq.seq });
         // Used by createMap()
         this.sortMapEntries =
             typeof sortMapEntries === 'function'
@@ -2954,13 +3349,21 @@ class Schema {
                     : null;
     }
     clone() {
-        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        const copy = Object.create(Schema$2.prototype, Object.getOwnPropertyDescriptors(this));
         copy.tags = this.tags.slice();
         return copy;
     }
 }
 
-function stringifyDocument(doc, options) {
+Schema$3.Schema = Schema$2;
+
+var stringifyDocument$2 = {};
+
+var Node$7 = Node$t;
+var stringify$4 = stringify$9;
+var stringifyComment = stringifyComment$5;
+
+function stringifyDocument$1(doc, options) {
     const lines = [];
     let hasDirectives = options.directives === true;
     if (options.directives !== false && doc.directives) {
@@ -2974,32 +3377,32 @@ function stringifyDocument(doc, options) {
     }
     if (hasDirectives)
         lines.push('---');
-    const ctx = createStringifyContext(doc, options);
+    const ctx = stringify$4.createStringifyContext(doc, options);
     const { commentString } = ctx.options;
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
         const cs = commentString(doc.commentBefore);
-        lines.unshift(indentComment(cs, ''));
+        lines.unshift(stringifyComment.indentComment(cs, ''));
     }
     let chompKeep = false;
     let contentComment = null;
     if (doc.contents) {
-        if (isNode(doc.contents)) {
+        if (Node$7.isNode(doc.contents)) {
             if (doc.contents.spaceBefore && hasDirectives)
                 lines.push('');
             if (doc.contents.commentBefore) {
                 const cs = commentString(doc.contents.commentBefore);
-                lines.push(indentComment(cs, ''));
+                lines.push(stringifyComment.indentComment(cs, ''));
             }
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
         }
         const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
-        let body = stringify$2(doc.contents, ctx, () => (contentComment = null), onChompKeep);
+        let body = stringify$4.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
         if (contentComment)
-            body += lineComment(body, '', commentString(contentComment));
+            body += stringifyComment.lineComment(body, '', commentString(contentComment));
         if ((body[0] === '|' || body[0] === '>') &&
             lines[lines.length - 1] === '---') {
             // Top-level block scalars with a preceding doc marker ought to use the
@@ -3010,14 +3413,14 @@ function stringifyDocument(doc, options) {
             lines.push(body);
     }
     else {
-        lines.push(stringify$2(doc.contents, ctx));
+        lines.push(stringify$4.stringify(doc.contents, ctx));
     }
     if (doc.directives?.docEnd) {
         if (doc.comment) {
             const cs = commentString(doc.comment);
             if (cs.includes('\n')) {
                 lines.push('...');
-                lines.push(indentComment(cs, ''));
+                lines.push(stringifyComment.indentComment(cs, ''));
             }
             else {
                 lines.push(`... ${cs}`);
@@ -3034,12 +3437,16 @@ function stringifyDocument(doc, options) {
         if (dc) {
             if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
                 lines.push('');
-            lines.push(indentComment(commentString(dc), ''));
+            lines.push(stringifyComment.indentComment(commentString(dc), ''));
         }
     }
     return lines.join('\n') + '\n';
 }
 
+stringifyDocument$2.stringifyDocument = stringifyDocument$1;
+
+var applyReviver$2 = {};
+
 /**
  * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
  * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
@@ -3047,12 +3454,12 @@ function stringifyDocument(doc, options) {
  *
  * Includes extensions for handling Map and Set objects.
  */
-function applyReviver(reviver, obj, key, val) {
+function applyReviver$1(reviver, obj, key, val) {
     if (val && typeof val === 'object') {
         if (Array.isArray(val)) {
             for (let i = 0, len = val.length; i < len; ++i) {
                 const v0 = val[i];
-                const v1 = applyReviver(reviver, val, String(i), v0);
+                const v1 = applyReviver$1(reviver, val, String(i), v0);
                 if (v1 === undefined)
                     delete val[i];
                 else if (v1 !== v0)
@@ -3062,7 +3469,7 @@ function applyReviver(reviver, obj, key, val) {
         else if (val instanceof Map) {
             for (const k of Array.from(val.keys())) {
                 const v0 = val.get(k);
-                const v1 = applyReviver(reviver, val, k, v0);
+                const v1 = applyReviver$1(reviver, val, k, v0);
                 if (v1 === undefined)
                     val.delete(k);
                 else if (v1 !== v0)
@@ -3071,7 +3478,7 @@ function applyReviver(reviver, obj, key, val) {
         }
         else if (val instanceof Set) {
             for (const v0 of Array.from(val)) {
-                const v1 = applyReviver(reviver, val, v0, v0);
+                const v1 = applyReviver$1(reviver, val, v0, v0);
                 if (v1 === undefined)
                     val.delete(v0);
                 else if (v1 !== v0) {
@@ -3082,7 +3489,7 @@ function applyReviver(reviver, obj, key, val) {
         }
         else {
             for (const [k, v0] of Object.entries(val)) {
-                const v1 = applyReviver(reviver, val, k, v0);
+                const v1 = applyReviver$1(reviver, val, k, v0);
                 if (v1 === undefined)
                     delete val[k];
                 else if (v1 !== v0)
@@ -3093,7 +3500,22 @@ function applyReviver(reviver, obj, key, val) {
     return reviver.call(obj, key, val);
 }
 
-class Document {
+applyReviver$2.applyReviver = applyReviver$1;
+
+var Alias$2 = Alias$5;
+var Collection = Collection$5;
+var Node$6 = Node$t;
+var Pair$3 = Pair$9;
+var toJS = toJS$6;
+var Schema$1 = Schema$3;
+var stringify$3 = stringify$9;
+var stringifyDocument = stringifyDocument$2;
+var anchors = anchors$3;
+var applyReviver = applyReviver$2;
+var createNode = createNode$5;
+var directives$1 = directives$2;
+
+class Document$4 {
     constructor(value, replacer, options) {
         /** A comment before this Document */
         this.commentBefore = null;
@@ -3103,7 +3525,7 @@ class Document {
         this.errors = [];
         /** Warnings encountered during parsing. */
         this.warnings = [];
-        Object.defineProperty(this, NODE_TYPE, { value: DOC });
+        Object.defineProperty(this, Node$6.NODE_TYPE, { value: Node$6.DOC });
         let _replacer = null;
         if (typeof replacer === 'function' || Array.isArray(replacer)) {
             _replacer = replacer;
@@ -3129,7 +3551,7 @@ class Document {
                 version = this.directives.yaml.version;
         }
         else
-            this.directives = new Directives({ version });
+            this.directives = new directives$1.Directives({ version });
         this.setSchema(version, options);
         if (value === undefined)
             this.contents = null;
@@ -3143,8 +3565,8 @@ class Document {
      * Custom Node values that inherit from `Object` still refer to their original instances.
      */
     clone() {
-        const copy = Object.create(Document.prototype, {
-            [NODE_TYPE]: { value: DOC }
+        const copy = Object.create(Document$4.prototype, {
+            [Node$6.NODE_TYPE]: { value: Node$6.DOC }
         });
         copy.commentBefore = this.commentBefore;
         copy.comment = this.comment;
@@ -3154,7 +3576,7 @@ class Document {
         if (this.directives)
             copy.directives = this.directives.clone();
         copy.schema = this.schema.clone();
-        copy.contents = isNode(this.contents)
+        copy.contents = Node$6.isNode(this.contents)
             ? this.contents.clone(copy.schema)
             : this.contents;
         if (this.range)
@@ -3182,12 +3604,12 @@ class Document {
      */
     createAlias(node, name) {
         if (!node.anchor) {
-            const prev = anchorNames(this);
+            const prev = anchors.anchorNames(this);
             node.anchor =
                 // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;
+                !name || prev.has(name) ? anchors.findNewAnchor(name || 'a', prev) : name;
         }
-        return new Alias(node.anchor);
+        return new Alias$2.Alias(node.anchor);
     }
     createNode(value, replacer, options) {
         let _replacer = undefined;
@@ -3207,7 +3629,7 @@ class Document {
             replacer = undefined;
         }
         const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};
-        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, 
+        const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, 
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         anchorPrefix || 'a');
         const ctx = {
@@ -3219,8 +3641,8 @@ class Document {
             schema: this.schema,
             sourceObjects
         };
-        const node = createNode(value, tag, ctx);
-        if (flow && isCollection$1(node))
+        const node = createNode.createNode(value, tag, ctx);
+        if (flow && Node$6.isCollection(node))
             node.flow = true;
         setAnchors();
         return node;
@@ -3232,7 +3654,7 @@ class Document {
     createPair(key, value, options = {}) {
         const k = this.createNode(key, null, options);
         const v = this.createNode(value, null, options);
-        return new Pair(k, v);
+        return new Pair$3.Pair(k, v);
     }
     /**
      * Removes a value from the document.
@@ -3246,7 +3668,7 @@ class Document {
      * @returns `true` if the item was found and removed.
      */
     deleteIn(path) {
-        if (isEmptyPath(path)) {
+        if (Collection.isEmptyPath(path)) {
             if (this.contents == null)
                 return false;
             this.contents = null;
@@ -3262,7 +3684,7 @@ class Document {
      * `true` (collections are always returned intact).
      */
     get(key, keepScalar) {
-        return isCollection$1(this.contents)
+        return Node$6.isCollection(this.contents)
             ? this.contents.get(key, keepScalar)
             : undefined;
     }
@@ -3272,11 +3694,11 @@ class Document {
      * `true` (collections are always returned intact).
      */
     getIn(path, keepScalar) {
-        if (isEmptyPath(path))
-            return !keepScalar && isScalar$1(this.contents)
+        if (Collection.isEmptyPath(path))
+            return !keepScalar && Node$6.isScalar(this.contents)
                 ? this.contents.value
                 : this.contents;
-        return isCollection$1(this.contents)
+        return Node$6.isCollection(this.contents)
             ? this.contents.getIn(path, keepScalar)
             : undefined;
     }
@@ -3284,15 +3706,15 @@ class Document {
      * Checks if the document includes a value with the key `key`.
      */
     has(key) {
-        return isCollection$1(this.contents) ? this.contents.has(key) : false;
+        return Node$6.isCollection(this.contents) ? this.contents.has(key) : false;
     }
     /**
      * Checks if the document includes a value at `path`.
      */
     hasIn(path) {
-        if (isEmptyPath(path))
+        if (Collection.isEmptyPath(path))
             return this.contents !== undefined;
-        return isCollection$1(this.contents) ? this.contents.hasIn(path) : false;
+        return Node$6.isCollection(this.contents) ? this.contents.hasIn(path) : false;
     }
     /**
      * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3300,7 +3722,7 @@ class Document {
      */
     set(key, value) {
         if (this.contents == null) {
-            this.contents = collectionFromPath(this.schema, [key], value);
+            this.contents = Collection.collectionFromPath(this.schema, [key], value);
         }
         else if (assertCollection(this.contents)) {
             this.contents.set(key, value);
@@ -3311,10 +3733,10 @@ class Document {
      * boolean to add/remove the item from the set.
      */
     setIn(path, value) {
-        if (isEmptyPath(path))
+        if (Collection.isEmptyPath(path))
             this.contents = value;
         else if (this.contents == null) {
-            this.contents = collectionFromPath(this.schema, Array.from(path), value);
+            this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
         }
         else if (assertCollection(this.contents)) {
             this.contents.setIn(path, value);
@@ -3336,7 +3758,7 @@ class Document {
                 if (this.directives)
                     this.directives.yaml.version = '1.1';
                 else
-                    this.directives = new Directives({ version: '1.1' });
+                    this.directives = new directives$1.Directives({ version: '1.1' });
                 opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };
                 break;
             case '1.2':
@@ -3344,7 +3766,7 @@ class Document {
                 if (this.directives)
                     this.directives.yaml.version = version;
                 else
-                    this.directives = new Directives({ version });
+                    this.directives = new directives$1.Directives({ version });
                 opt = { merge: false, resolveKnownTags: true, schema: 'core' };
                 break;
             case null:
@@ -3361,7 +3783,7 @@ class Document {
         if (options.schema instanceof Object)
             this.schema = options.schema;
         else if (opt)
-            this.schema = new Schema(Object.assign(opt, options));
+            this.schema = new Schema$1.Schema(Object.assign(opt, options));
         else
             throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
     }
@@ -3374,14 +3796,14 @@ class Document {
             mapAsMap: mapAsMap === true,
             mapKeyWarned: false,
             maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
-            stringify: stringify$2
+            stringify: stringify$3.stringify
         };
-        const res = toJS(this.contents, jsonArg ?? '', ctx);
+        const res = toJS.toJS(this.contents, jsonArg ?? '', ctx);
         if (typeof onAnchor === 'function')
             for (const { count, res } of ctx.anchors.values())
                 onAnchor(res, count);
         return typeof reviver === 'function'
-            ? applyReviver(reviver, { '': res }, '', res)
+            ? applyReviver.applyReviver(reviver, { '': res }, '', res)
             : res;
     }
     /**
@@ -3402,16 +3824,20 @@ class Document {
             const s = JSON.stringify(options.indent);
             throw new Error(`"indent" option must be a positive integer, not ${s}`);
         }
-        return stringifyDocument(this, options);
+        return stringifyDocument.stringifyDocument(this, options);
     }
 }
 function assertCollection(contents) {
-    if (isCollection$1(contents))
+    if (Node$6.isCollection(contents))
         return true;
     throw new Error('Expected a YAML collection as document contents');
 }
 
-class YAMLError extends Error {
+Document$5.Document = Document$4;
+
+var errors$4 = {};
+
+class YAMLError$1 extends Error {
     constructor(name, pos, code, message) {
         super();
         this.name = name;
@@ -3420,12 +3846,12 @@ class YAMLError extends Error {
         this.pos = pos;
     }
 }
-class YAMLParseError extends YAMLError {
+class YAMLParseError$1 extends YAMLError$1 {
     constructor(pos, code, message) {
         super('YAMLParseError', pos, code, message);
     }
 }
-class YAMLWarning extends YAMLError {
+class YAMLWarning$1 extends YAMLError$1 {
     constructor(pos, code, message) {
         super('YAMLWarning', pos, code, message);
     }
@@ -3467,7 +3893,22 @@ const prettifyError = (src, lc) => (error) => {
     }
 };
 
-function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
+errors$4.YAMLError = YAMLError$1;
+errors$4.YAMLParseError = YAMLParseError$1;
+errors$4.YAMLWarning = YAMLWarning$1;
+errors$4.prettifyError = prettifyError;
+
+var composeDoc$2 = {};
+
+var composeNode$2 = {};
+
+var composeCollection$2 = {};
+
+var resolveBlockMap$2 = {};
+
+var resolveProps$5 = {};
+
+function resolveProps$4(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
@@ -3600,6 +4041,10 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
     };
 }
 
+resolveProps$5.resolveProps = resolveProps$4;
+
+var utilContainsNewline$3 = {};
+
 function containsNewline(key) {
     if (!key)
         return null;
@@ -3633,18 +4078,30 @@ function containsNewline(key) {
     }
 }
 
+utilContainsNewline$3.containsNewline = containsNewline;
+
+var utilFlowIndentCheck$2 = {};
+
+var utilContainsNewline$2 = utilContainsNewline$3;
+
 function flowIndentCheck(indent, fc, onError) {
     if (fc?.type === 'flow-collection') {
         const end = fc.end[0];
         if (end.indent === indent &&
             (end.source === ']' || end.source === '}') &&
-            containsNewline(fc)) {
+            utilContainsNewline$2.containsNewline(fc)) {
             const msg = 'Flow end indicator should be more indented than parent';
             onError(end, 'BAD_INDENT', msg, true);
         }
     }
 }
 
+utilFlowIndentCheck$2.flowIndentCheck = flowIndentCheck;
+
+var utilMapIncludes$2 = {};
+
+var Node$5 = Node$t;
+
 function mapIncludes(ctx, items, search) {
     const { uniqueKeys } = ctx.options;
     if (uniqueKeys === false)
@@ -3652,23 +4109,32 @@ function mapIncludes(ctx, items, search) {
     const isEqual = typeof uniqueKeys === 'function'
         ? uniqueKeys
         : (a, b) => a === b ||
-            (isScalar$1(a) &&
-                isScalar$1(b) &&
+            (Node$5.isScalar(a) &&
+                Node$5.isScalar(b) &&
                 a.value === b.value &&
                 !(a.value === '<<' && ctx.schema.merge));
     return items.some(pair => isEqual(pair.key, search));
 }
 
+utilMapIncludes$2.mapIncludes = mapIncludes;
+
+var Pair$2 = Pair$9;
+var YAMLMap$2 = YAMLMap$7;
+var resolveProps$3 = resolveProps$5;
+var utilContainsNewline$1 = utilContainsNewline$3;
+var utilFlowIndentCheck$1 = utilFlowIndentCheck$2;
+var utilMapIncludes$1 = utilMapIncludes$2;
+
 const startColMsg = 'All mapping items must start at the same column';
-function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
-    const map = new YAMLMap(ctx.schema);
+function resolveBlockMap$1({ composeNode, composeEmptyNode }, ctx, bm, onError) {
+    const map = new YAMLMap$2.YAMLMap(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bm.offset;
     for (const collItem of bm.items) {
         const { start, key, sep, value } = collItem;
         // key properties
-        const keyProps = resolveProps(start, {
+        const keyProps = resolveProps$3.resolveProps(start, {
             indicator: 'explicit-key-ind',
             next: key ?? sep?.[0],
             offset,
@@ -3693,7 +4159,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 }
                 continue;
             }
-            if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
+            if (keyProps.hasNewlineAfterProp || utilContainsNewline$1.containsNewline(key)) {
                 onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
             }
         }
@@ -3706,11 +4172,11 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
             ? composeNode(ctx, key, keyProps, onError)
             : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
         if (ctx.schema.compat)
-            flowIndentCheck(bm.indent, key, onError);
-        if (mapIncludes(ctx, map.items, keyNode))
+            utilFlowIndentCheck$1.flowIndentCheck(bm.indent, key, onError);
+        if (utilMapIncludes$1.mapIncludes(ctx, map.items, keyNode))
             onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
-        const valueProps = resolveProps(sep ?? [], {
+        const valueProps = resolveProps$3.resolveProps(sep ?? [], {
             indicator: 'map-value-ind',
             next: value,
             offset: keyNode.range[2],
@@ -3731,9 +4197,9 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
             if (ctx.schema.compat)
-                flowIndentCheck(bm.indent, value, onError);
+                utilFlowIndentCheck$1.flowIndentCheck(bm.indent, value, onError);
             offset = valueNode.range[2];
-            const pair = new Pair(keyNode, valueNode);
+            const pair = new Pair$2.Pair(keyNode, valueNode);
             if (ctx.options.keepSourceTokens)
                 pair.srcToken = collItem;
             map.items.push(pair);
@@ -3748,7 +4214,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            const pair = new Pair(keyNode);
+            const pair = new Pair$2.Pair(keyNode);
             if (ctx.options.keepSourceTokens)
                 pair.srcToken = collItem;
             map.items.push(pair);
@@ -3758,13 +4224,21 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     return map;
 }
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
-    const seq = new YAMLSeq(ctx.schema);
+resolveBlockMap$2.resolveBlockMap = resolveBlockMap$1;
+
+var resolveBlockSeq$2 = {};
+
+var YAMLSeq$2 = YAMLSeq$7;
+var resolveProps$2 = resolveProps$5;
+var utilFlowIndentCheck = utilFlowIndentCheck$2;
+
+function resolveBlockSeq$1({ composeNode, composeEmptyNode }, ctx, bs, onError) {
+    const seq = new YAMLSeq$2.YAMLSeq(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
-        const props = resolveProps(start, {
+        const props = resolveProps$2.resolveProps(start, {
             indicator: 'seq-item-ind',
             next: value,
             offset,
@@ -3790,7 +4264,7 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
             ? composeNode(ctx, value, props, onError)
             : composeEmptyNode(ctx, offset, start, null, props, onError);
         if (ctx.schema.compat)
-            flowIndentCheck(bs.indent, value, onError);
+            utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }
@@ -3798,7 +4272,13 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     return seq;
 }
 
-function resolveEnd(end, offset, reqSpace, onError) {
+resolveBlockSeq$2.resolveBlockSeq = resolveBlockSeq$1;
+
+var resolveFlowCollection$2 = {};
+
+var resolveEnd$6 = {};
+
+function resolveEnd$5(end, offset, reqSpace, onError) {
     let comment = '';
     if (end) {
         let hasSpace = false;
@@ -3834,14 +4314,25 @@ function resolveEnd(end, offset, reqSpace, onError) {
     return { comment, offset };
 }
 
+resolveEnd$6.resolveEnd = resolveEnd$5;
+
+var Node$4 = Node$t;
+var Pair$1 = Pair$9;
+var YAMLMap$1 = YAMLMap$7;
+var YAMLSeq$1 = YAMLSeq$7;
+var resolveEnd$4 = resolveEnd$6;
+var resolveProps$1 = resolveProps$5;
+var utilContainsNewline = utilContainsNewline$3;
+var utilMapIncludes = utilMapIncludes$2;
+
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
-function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+function resolveFlowCollection$1({ composeNode, composeEmptyNode }, ctx, fc, onError) {
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
     const coll = isMap
-        ? new YAMLMap(ctx.schema)
-        : new YAMLSeq(ctx.schema);
+        ? new YAMLMap$1.YAMLMap(ctx.schema)
+        : new YAMLSeq$1.YAMLSeq(ctx.schema);
     coll.flow = true;
     const atRoot = ctx.atRoot;
     if (atRoot)
@@ -3850,7 +4341,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
         const { start, key, sep, value } = collItem;
-        const props = resolveProps(start, {
+        const props = resolveProps$1.resolveProps(start, {
             flow: fcName,
             indicator: 'explicit-key-ind',
             next: key ?? sep?.[0],
@@ -3873,7 +4364,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 offset = props.end;
                 continue;
             }
-            if (!isMap && ctx.options.strict && containsNewline(key))
+            if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
                 onError(key, // checked by containsNewline()
                 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
         }
@@ -3900,7 +4391,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 }
                 if (prevItemComment) {
                     let prev = coll.items[coll.items.length - 1];
-                    if (isPair(prev))
+                    if (Node$4.isPair(prev))
                         prev = prev.value ?? prev.key;
                     if (prev.comment)
                         prev.comment += '\n' + prevItemComment;
@@ -3931,7 +4422,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
             if (isBlock(key))
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
-            const valueProps = resolveProps(sep ?? [], {
+            const valueProps = resolveProps$1.resolveProps(sep ?? [], {
                 flow: fcName,
                 indicator: 'map-value-ind',
                 next: value,
@@ -3976,17 +4467,17 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 else
                     keyNode.comment = valueProps.comment;
             }
-            const pair = new Pair(keyNode, valueNode);
+            const pair = new Pair$1.Pair(keyNode, valueNode);
             if (ctx.options.keepSourceTokens)
                 pair.srcToken = collItem;
             if (isMap) {
                 const map = coll;
-                if (mapIncludes(ctx, map.items, keyNode))
+                if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
                     onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
                 map.items.push(pair);
             }
             else {
-                const map = new YAMLMap(ctx.schema);
+                const map = new YAMLMap$1.YAMLMap(ctx.schema);
                 map.flow = true;
                 map.items.push(pair);
                 coll.items.push(map);
@@ -4009,7 +4500,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
             ee.unshift(ce);
     }
     if (ee.length > 0) {
-        const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+        const end = resolveEnd$4.resolveEnd(ee, cePos, ctx.options.strict, onError);
         if (end.comment) {
             if (coll.comment)
                 coll.comment += '\n' + end.comment;
@@ -4024,19 +4515,27 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     return coll;
 }
 
-function composeCollection(CN, ctx, token, tagToken, onError) {
+resolveFlowCollection$2.resolveFlowCollection = resolveFlowCollection$1;
+
+var Node$3 = Node$t;
+var Scalar$4 = Scalar$k;
+var resolveBlockMap = resolveBlockMap$2;
+var resolveBlockSeq = resolveBlockSeq$2;
+var resolveFlowCollection = resolveFlowCollection$2;
+
+function composeCollection$1(CN, ctx, token, tagToken, onError) {
     let coll;
     switch (token.type) {
         case 'block-map': {
-            coll = resolveBlockMap(CN, ctx, token, onError);
+            coll = resolveBlockMap.resolveBlockMap(CN, ctx, token, onError);
             break;
         }
         case 'block-seq': {
-            coll = resolveBlockSeq(CN, ctx, token, onError);
+            coll = resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError);
             break;
         }
         case 'flow-collection': {
-            coll = resolveFlowCollection(CN, ctx, token, onError);
+            coll = resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError);
             break;
         }
     }
@@ -4051,7 +4550,7 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
         coll.tag = Coll.tagName;
         return coll;
     }
-    const expType = isMap(coll) ? 'map' : 'seq';
+    const expType = Node$3.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];
@@ -4066,9 +4565,9 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
         }
     }
     const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
-    const node = isNode(res)
+    const node = Node$3.isNode(res)
         ? res
-        : new Scalar(res);
+        : new Scalar$4.Scalar(res);
     node.range = coll.range;
     node.tag = tagName;
     if (tag?.format)
@@ -4076,12 +4575,20 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
     return node;
 }
 
-function resolveBlockScalar(scalar, strict, onError) {
+composeCollection$2.composeCollection = composeCollection$1;
+
+var composeScalar$2 = {};
+
+var resolveBlockScalar$3 = {};
+
+var Scalar$3 = Scalar$k;
+
+function resolveBlockScalar$2(scalar, strict, onError) {
     const start = scalar.offset;
     const header = parseBlockScalarHeader(scalar, strict, onError);
     if (!header)
         return { value: '', type: null, comment: '', range: [start, start, start] };
-    const type = header.mode === '>' ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
+    const type = header.mode === '>' ? Scalar$3.Scalar.BLOCK_FOLDED : Scalar$3.Scalar.BLOCK_LITERAL;
     const lines = scalar.source ? splitLines(scalar.source) : [];
     // determine the end of content & start of chomping
     let chompStart = lines.length;
@@ -4150,7 +4657,7 @@ function resolveBlockScalar(scalar, strict, onError) {
             onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message);
             indent = '';
         }
-        if (type === Scalar.BLOCK_LITERAL) {
+        if (type === Scalar$3.Scalar.BLOCK_LITERAL) {
             value += sep + indent.slice(trimIndent) + content;
             sep = '\n';
         }
@@ -4267,22 +4774,29 @@ function splitLines(source) {
     return lines;
 }
 
-function resolveFlowScalar(scalar, strict, onError) {
+resolveBlockScalar$3.resolveBlockScalar = resolveBlockScalar$2;
+
+var resolveFlowScalar$3 = {};
+
+var Scalar$2 = Scalar$k;
+var resolveEnd$3 = resolveEnd$6;
+
+function resolveFlowScalar$2(scalar, strict, onError) {
     const { offset, type, source, end } = scalar;
     let _type;
     let value;
     const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
     switch (type) {
         case 'scalar':
-            _type = Scalar.PLAIN;
+            _type = Scalar$2.Scalar.PLAIN;
             value = plainValue(source, _onError);
             break;
         case 'single-quoted-scalar':
-            _type = Scalar.QUOTE_SINGLE;
+            _type = Scalar$2.Scalar.QUOTE_SINGLE;
             value = singleQuotedValue(source, _onError);
             break;
         case 'double-quoted-scalar':
-            _type = Scalar.QUOTE_DOUBLE;
+            _type = Scalar$2.Scalar.QUOTE_DOUBLE;
             value = doubleQuotedValue(source, _onError);
             break;
         /* istanbul ignore next should not happen */
@@ -4296,7 +4810,7 @@ function resolveFlowScalar(scalar, strict, onError) {
             };
     }
     const valueEnd = offset + source.length;
-    const re = resolveEnd(end, valueEnd, strict, onError);
+    const re = resolveEnd$3.resolveEnd(end, valueEnd, strict, onError);
     return {
         value,
         type: _type,
@@ -4486,10 +5000,17 @@ function parseCharCode(source, offset, length, onError) {
     return String.fromCodePoint(code);
 }
 
-function composeScalar(ctx, token, tagToken, onError) {
+resolveFlowScalar$3.resolveFlowScalar = resolveFlowScalar$2;
+
+var Node$2 = Node$t;
+var Scalar$1 = Scalar$k;
+var resolveBlockScalar$1 = resolveBlockScalar$3;
+var resolveFlowScalar$1 = resolveFlowScalar$3;
+
+function composeScalar$1(ctx, token, tagToken, onError) {
     const { value, type, comment, range } = token.type === 'block-scalar'
-        ? resolveBlockScalar(token, ctx.options.strict, onError)
-        : resolveFlowScalar(token, ctx.options.strict, onError);
+        ? resolveBlockScalar$1.resolveBlockScalar(token, ctx.options.strict, onError)
+        : resolveFlowScalar$1.resolveFlowScalar(token, ctx.options.strict, onError);
     const tagName = tagToken
         ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
         : null;
@@ -4497,16 +5018,16 @@ function composeScalar(ctx, token, tagToken, onError) {
         ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
         : token.type === 'scalar'
             ? findScalarTagByTest(ctx, value, token, onError)
-            : ctx.schema[SCALAR$1];
+            : ctx.schema[Node$2.SCALAR];
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
-        scalar = isScalar$1(res) ? res : new Scalar(res);
+        scalar = Node$2.isScalar(res) ? res : new Scalar$1.Scalar(res);
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg);
-        scalar = new Scalar(value);
+        scalar = new Scalar$1.Scalar(value);
     }
     scalar.range = range;
     scalar.source = value;
@@ -4522,7 +5043,7 @@ function composeScalar(ctx, token, tagToken, onError) {
 }
 function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     if (tagName === '!')
-        return schema[SCALAR$1]; // non-specific tag
+        return schema[Node$2.SCALAR]; // non-specific tag
     const matchWithTest = [];
     for (const tag of schema.tags) {
         if (!tag.collection && tag.tag === tagName) {
@@ -4543,13 +5064,13 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
         return kt;
     }
     onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
-    return schema[SCALAR$1];
+    return schema[Node$2.SCALAR];
 }
 function findScalarTagByTest({ directives, schema }, value, token, onError) {
-    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[SCALAR$1];
+    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[Node$2.SCALAR];
     if (schema.compat) {
         const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
-            schema[SCALAR$1];
+            schema[Node$2.SCALAR];
         if (tag.tag !== compat.tag) {
             const ts = directives.tagString(tag.tag);
             const cs = directives.tagString(compat.tag);
@@ -4560,6 +5081,10 @@ function findScalarTagByTest({ directives, schema }, value, token, onError) {
     return tag;
 }
 
+composeScalar$2.composeScalar = composeScalar$1;
+
+var utilEmptyScalarPosition$1 = {};
+
 function emptyScalarPosition(offset, before, pos) {
     if (before) {
         if (pos === null)
@@ -4586,8 +5111,16 @@ function emptyScalarPosition(offset, before, pos) {
     return offset;
 }
 
-const CN = { composeNode, composeEmptyNode };
-function composeNode(ctx, token, props, onError) {
+utilEmptyScalarPosition$1.emptyScalarPosition = emptyScalarPosition;
+
+var Alias$1 = Alias$5;
+var composeCollection = composeCollection$2;
+var composeScalar = composeScalar$2;
+var resolveEnd$2 = resolveEnd$6;
+var utilEmptyScalarPosition = utilEmptyScalarPosition$1;
+
+const CN = { composeNode: composeNode$1, composeEmptyNode };
+function composeNode$1(ctx, token, props, onError) {
     const { spaceBefore, comment, anchor, tag } = props;
     let node;
     let isSrcToken = true;
@@ -4601,14 +5134,14 @@ function composeNode(ctx, token, props, onError) {
         case 'single-quoted-scalar':
         case 'double-quoted-scalar':
         case 'block-scalar':
-            node = composeScalar(ctx, token, tag, onError);
+            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(CN, ctx, token, tag, onError);
+            node = composeCollection.composeCollection(CN, ctx, token, tag, onError);
             if (anchor)
                 node.anchor = anchor.source.substring(1);
             break;
@@ -4639,11 +5172,11 @@ function composeNode(ctx, token, props, onError) {
 function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
     const token = {
         type: 'scalar',
-        offset: emptyScalarPosition(offset, before, pos),
+        offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
         indent: -1,
         source: ''
     };
-    const node = composeScalar(ctx, token, tag, onError);
+    const node = composeScalar.composeScalar(ctx, token, tag, onError);
     if (anchor) {
         node.anchor = anchor.source.substring(1);
         if (node.anchor === '')
@@ -4656,29 +5189,37 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
     return node;
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
-    const alias = new Alias(source.substring(1));
+    const alias = new Alias$1.Alias(source.substring(1));
     if (alias.source === '')
         onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
     if (alias.source.endsWith(':'))
         onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
     const valueEnd = offset + source.length;
-    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    const re = resolveEnd$2.resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];
     if (re.comment)
         alias.comment = re.comment;
     return alias;
 }
 
-function composeDoc(options, directives, { offset, start, value, end }, onError) {
+composeNode$2.composeEmptyNode = composeEmptyNode;
+composeNode$2.composeNode = composeNode$1;
+
+var Document$3 = Document$5;
+var composeNode = composeNode$2;
+var resolveEnd$1 = resolveEnd$6;
+var resolveProps = resolveProps$5;
+
+function composeDoc$1(options, directives, { offset, start, value, end }, onError) {
     const opts = Object.assign({ _directives: directives }, options);
-    const doc = new Document(undefined, opts);
+    const doc = new Document$3.Document(undefined, opts);
     const ctx = {
         atRoot: true,
         directives: doc.directives,
         options: doc.options,
         schema: doc.schema
     };
-    const props = resolveProps(start, {
+    const props = resolveProps.resolveProps(start, {
         indicator: 'doc-start',
         next: value ?? end?.[0],
         offset,
@@ -4693,16 +5234,25 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
             onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
     }
     doc.contents = value
-        ? composeNode(ctx, value, props, onError)
-        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+        ? composeNode.composeNode(ctx, value, props, onError)
+        : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
     const contentEnd = doc.contents.range[2];
-    const re = resolveEnd(end, contentEnd, false, onError);
+    const re = resolveEnd$1.resolveEnd(end, contentEnd, false, onError);
     if (re.comment)
         doc.comment = re.comment;
     doc.range = [offset, contentEnd, re.offset];
     return doc;
 }
 
+composeDoc$2.composeDoc = composeDoc$1;
+
+var directives = directives$2;
+var Document$2 = Document$5;
+var errors$3 = errors$4;
+var Node$1 = Node$t;
+var composeDoc = composeDoc$2;
+var resolveEnd = resolveEnd$6;
+
 function getErrorPos(src) {
     if (typeof src === 'number')
         return [src, src + 1];
@@ -4750,7 +5300,7 @@ function parsePrelude(prelude) {
  * const docs = new Composer().compose(tokens)
  * ```
  */
-class Composer {
+class Composer$1 {
     constructor(options = {}) {
         this.doc = null;
         this.atDirectives = false;
@@ -4760,12 +5310,12 @@ class Composer {
         this.onError = (source, code, message, warning) => {
             const pos = getErrorPos(source);
             if (warning)
-                this.warnings.push(new YAMLWarning(pos, code, message));
+                this.warnings.push(new errors$3.YAMLWarning(pos, code, message));
             else
-                this.errors.push(new YAMLParseError(pos, code, message));
+                this.errors.push(new errors$3.YAMLParseError(pos, code, message));
         };
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-        this.directives = new Directives({ version: options.version || '1.2' });
+        this.directives = new directives.Directives({ version: options.version || '1.2' });
         this.options = options;
     }
     decorate(doc, afterDoc) {
@@ -4779,9 +5329,9 @@ class Composer {
             else if (afterEmptyLine || doc.directives.docStart || !dc) {
                 doc.commentBefore = comment;
             }
-            else if (isCollection$1(dc) && !dc.flow && dc.items.length > 0) {
+            else if (Node$1.isCollection(dc) && !dc.flow && dc.items.length > 0) {
                 let it = dc.items[0];
-                if (isPair(it))
+                if (Node$1.isPair(it))
                     it = it.key;
                 const cb = it.commentBefore;
                 it.commentBefore = cb ? `${comment}\n${cb}` : comment;
@@ -4829,6 +5379,8 @@ class Composer {
     }
     /** Advance the composer by one CST token. */
     *next(token) {
+        if (process.env.LOG_STREAM)
+            console.dir(token, { depth: null });
         switch (token.type) {
             case 'directive':
                 this.directives.add(token.source, (offset, message, warning) => {
@@ -4840,7 +5392,7 @@ class Composer {
                 this.atDirectives = true;
                 break;
             case 'document': {
-                const doc = composeDoc(this.options, this.directives, token, this.onError);
+                const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError);
                 if (this.atDirectives && !doc.directives.docStart)
                     this.onError(token, 'MISSING_CHAR', 'Missing directives-end/doc-start indicator line');
                 this.decorate(doc, false);
@@ -4861,7 +5413,7 @@ class Composer {
                 const msg = token.source
                     ? `${token.message}: ${JSON.stringify(token.source)}`
                     : token.message;
-                const error = new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg);
+                const error = new errors$3.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg);
                 if (this.atDirectives || !this.doc)
                     this.errors.push(error);
                 else
@@ -4871,11 +5423,11 @@ class Composer {
             case 'doc-end': {
                 if (!this.doc) {
                     const msg = 'Unexpected doc-end without preceding document';
-                    this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
+                    this.errors.push(new errors$3.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
                     break;
                 }
                 this.doc.directives.docEnd = true;
-                const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+                const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
                 this.decorate(this.doc, true);
                 if (end.comment) {
                     const dc = this.doc.comment;
@@ -4885,7 +5437,7 @@ class Composer {
                 break;
             }
             default:
-                this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`));
+                this.errors.push(new errors$3.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`));
         }
     }
     /**
@@ -4902,7 +5454,7 @@ class Composer {
         }
         else if (forceDoc) {
             const opts = Object.assign({ _directives: this.directives }, this.options);
-            const doc = new Document(undefined, opts);
+            const doc = new Document$2.Document(undefined, opts);
             if (this.atDirectives)
                 this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line');
             doc.range = [0, endOffset, endOffset];
@@ -4912,6 +5464,17 @@ class Composer {
     }
 }
 
+composer$2.Composer = Composer$1;
+
+var cst$3 = {};
+
+var cstScalar$1 = {};
+
+var resolveBlockScalar = resolveBlockScalar$3;
+var resolveFlowScalar = resolveFlowScalar$3;
+var errors$2 = errors$4;
+var stringifyString = stringifyString$5;
+
 function resolveAsScalar(token, strict = true, onError) {
     if (token) {
         const _onError = (pos, code, message) => {
@@ -4919,15 +5482,15 @@ function resolveAsScalar(token, strict = true, onError) {
             if (onError)
                 onError(offset, code, message);
             else
-                throw new YAMLParseError([offset, offset + 1], code, message);
+                throw new errors$2.YAMLParseError([offset, offset + 1], code, message);
         };
         switch (token.type) {
             case 'scalar':
             case 'single-quoted-scalar':
             case 'double-quoted-scalar':
-                return resolveFlowScalar(token, strict, _onError);
+                return resolveFlowScalar.resolveFlowScalar(token, strict, _onError);
             case 'block-scalar':
-                return resolveBlockScalar(token, strict, _onError);
+                return resolveBlockScalar.resolveBlockScalar(token, strict, _onError);
         }
     }
     return null;
@@ -4948,7 +5511,7 @@ function resolveAsScalar(token, strict = true, onError) {
  */
 function createScalarToken(value, context) {
     const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
-    const source = stringifyString({ type, value }, {
+    const source = stringifyString.stringifyString({ type, value }, {
         implicitKey,
         indent: indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
@@ -5017,7 +5580,7 @@ function setScalarValue(token, value, context = {}) {
             default:
                 type = 'PLAIN';
         }
-    const source = stringifyString({ type, value }, {
+    const source = stringifyString.stringifyString({ type, value }, {
         implicitKey: implicitKey || indent === null,
         indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
@@ -5120,13 +5683,19 @@ function setFlowScalarValue(token, source, type) {
     }
 }
 
+cstScalar$1.createScalarToken = createScalarToken;
+cstScalar$1.resolveAsScalar = resolveAsScalar;
+cstScalar$1.setScalarValue = setScalarValue;
+
+var cstStringify$1 = {};
+
 /**
  * Stringify a CST document, token, or collection item
  *
  * Fair warning: This applies no validation whatsoever, and
  * simply concatenates the sources in their logical order.
  */
-const stringify$1 = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst);
+const stringify$2 = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst);
 function stringifyToken(token) {
     switch (token.type) {
         case 'block-scalar': {
@@ -5180,6 +5749,10 @@ function stringifyItem({ start, key, sep, value }) {
     return res;
 }
 
+cstStringify$1.stringify = stringify$2;
+
+var cstVisit$1 = {};
+
 const BREAK = Symbol('break visit');
 const SKIP = Symbol('skip children');
 const REMOVE = Symbol('remove item');
@@ -5211,7 +5784,7 @@ const REMOVE = Symbol('remove item');
  *     visitor is called on item entry, next visitors are called after handling
  *     a non-empty `key` and when exiting the item.
  */
-function visit(cst, visitor) {
+function visit$1(cst, visitor) {
     if ('type' in cst && cst.type === 'document')
         cst = { start: cst.start, value: cst.value };
     _visit(Object.freeze([]), cst, visitor);
@@ -5220,13 +5793,13 @@ function visit(cst, visitor) {
 // namespace using `var`, but then complains about that because
 // `unique symbol` must be `const`.
 /** Terminate visit traversal completely */
-visit.BREAK = BREAK;
+visit$1.BREAK = BREAK;
 /** Do not visit the children of the current item */
-visit.SKIP = SKIP;
+visit$1.SKIP = SKIP;
 /** Remove the current item */
-visit.REMOVE = REMOVE;
+visit$1.REMOVE = REMOVE;
 /** Find the item at `path` from `cst` as the root */
-visit.itemAtPath = (cst, path) => {
+visit$1.itemAtPath = (cst, path) => {
     let item = cst;
     for (const [field, index] of path) {
         const tok = item?.[field];
@@ -5243,8 +5816,8 @@ visit.itemAtPath = (cst, path) => {
  *
  * Throws an error if the collection is not found, which should never happen if the item itself exists.
  */
-visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+visit$1.parentCollection = (cst, path) => {
+    const parent = visit$1.itemAtPath(cst, path.slice(0, -1));
     const field = path[path.length - 1][0];
     const coll = parent?.[field];
     if (coll && 'items' in coll)
@@ -5276,6 +5849,12 @@ function _visit(path, item, visitor) {
     return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
 }
 
+cstVisit$1.visit = visit$1;
+
+var cstScalar = cstScalar$1;
+var cstStringify = cstStringify$1;
+var cstVisit = cstVisit$1;
+
 /** The byte order mark */
 const BOM = '\u{FEFF}';
 /** Start of doc-mode */
@@ -5285,9 +5864,9 @@ const FLOW_END = '\x18'; // C0: Cancel
 /** Next token is a scalar value */
 const SCALAR = '\x1f'; // C0: Unit Separator
 /** @returns `true` if `token` is a flow or block collection */
-const isCollection = (token) => !!token && 'items' in token;
+const isCollection$1 = (token) => !!token && 'items' in token;
 /** @returns `true` if `token` is a flow or block scalar; not an alias */
-const isScalar = (token) => !!token &&
+const isScalar$1 = (token) => !!token &&
     (token.type === 'scalar' ||
         token.type === 'single-quoted-scalar' ||
         token.type === 'double-quoted-scalar' ||
@@ -5369,22 +5948,23 @@ function tokenType(source) {
     return null;
 }
 
-var cst = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BOM: BOM,
-    DOCUMENT: DOCUMENT,
-    FLOW_END: FLOW_END,
-    SCALAR: SCALAR,
-    isCollection: isCollection,
-    isScalar: isScalar,
-    prettyToken: prettyToken,
-    tokenType: tokenType,
-    createScalarToken: createScalarToken,
-    resolveAsScalar: resolveAsScalar,
-    setScalarValue: setScalarValue,
-    stringify: stringify$1,
-    visit: visit
-});
+cst$3.createScalarToken = cstScalar.createScalarToken;
+cst$3.resolveAsScalar = cstScalar.resolveAsScalar;
+cst$3.setScalarValue = cstScalar.setScalarValue;
+cst$3.stringify = cstStringify.stringify;
+cst$3.visit = cstVisit.visit;
+cst$3.BOM = BOM;
+cst$3.DOCUMENT = DOCUMENT;
+cst$3.FLOW_END = FLOW_END;
+cst$3.SCALAR = SCALAR;
+cst$3.isCollection = isCollection$1;
+cst$3.isScalar = isScalar$1;
+cst$3.prettyToken = prettyToken;
+cst$3.tokenType = tokenType;
+
+var lexer$2 = {};
+
+var cst$2 = cst$3;
 
 /*
 START -> stream
@@ -5485,7 +6065,7 @@ const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);
  * - `\x1f` (Unit Separator): Next token is a scalar value
  * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
  */
-class Lexer {
+class Lexer$1 {
     constructor() {
         /**
          * Flag indicating whether the end of the current buffer marks the end of
@@ -5628,7 +6208,7 @@ class Lexer {
         let line = this.getLine();
         if (line === null)
             return this.setNext('stream');
-        if (line[0] === BOM) {
+        if (line[0] === cst$2.BOM) {
             yield* this.pushCount(1);
             line = line.substring(1);
         }
@@ -5658,7 +6238,7 @@ class Lexer {
             yield* this.pushNewline();
             return 'stream';
         }
-        yield DOCUMENT;
+        yield cst$2.DOCUMENT;
         return yield* this.parseLineStart();
     }
     *parseLineStart() {
@@ -5768,7 +6348,7 @@ class Lexer {
             if (!atFlowEndMarker) {
                 // this is an error
                 this.flowLevel = 0;
-                yield FLOW_END;
+                yield cst$2.FLOW_END;
                 return yield* this.parseLineStart();
             }
         }
@@ -5933,7 +6513,7 @@ class Lexer {
                     break;
             } while (true);
         }
-        yield SCALAR;
+        yield cst$2.SCALAR;
         yield* this.pushToIndex(nl + 1, true);
         return yield* this.parseLineStart();
     }
@@ -5977,7 +6557,7 @@ class Lexer {
         }
         if (!ch && !this.atEnd)
             return this.setNext('plain-scalar');
-        yield SCALAR;
+        yield cst$2.SCALAR;
         yield* this.pushToIndex(end + 1, true);
         return inFlow ? 'flow' : 'doc';
     }
@@ -6084,12 +6664,16 @@ class Lexer {
     }
 }
 
+lexer$2.Lexer = Lexer$1;
+
+var lineCounter$2 = {};
+
 /**
  * Tracks newlines during parsing in order to provide an efficient API for
  * determining the one-indexed `{ line, col }` position for any offset
  * within the input.
  */
-class LineCounter {
+class LineCounter$1 {
     constructor() {
         this.lineStarts = [];
         /**
@@ -6122,6 +6706,13 @@ class LineCounter {
     }
 }
 
+lineCounter$2.LineCounter = LineCounter$1;
+
+var parser$2 = {};
+
+var cst$1 = cst$3;
+var lexer$1 = lexer$2;
+
 function includesToken(list, type) {
     for (let i = 0; i < list.length; ++i)
         if (list[i].type === type)
@@ -6238,7 +6829,7 @@ function fixFlowSeqItems(fc) {
  * }
  * ```
  */
-class Parser {
+class Parser$1 {
     /**
      * @param onNewLine - If defined, called separately with the start position of
      *   each new line (in `parse()`, including the start of input).
@@ -6261,7 +6852,7 @@ class Parser {
         /** The type of the current token, set in parse() */
         this.type = '';
         // Must be defined after `next()`
-        this.lexer = new Lexer();
+        this.lexer = new lexer$1.Lexer();
         this.onNewLine = onNewLine;
     }
     /**
@@ -6285,13 +6876,15 @@ class Parser {
      */
     *next(source) {
         this.source = source;
+        if (process.env.LOG_TOKENS)
+            console.log('|', cst$1.prettyToken(source));
         if (this.atScalar) {
             this.atScalar = false;
             yield* this.step();
             this.offset += source.length;
             return;
         }
-        const type = tokenType(source);
+        const type = cst$1.tokenType(source);
         if (!type) {
             const message = `Not a YAML token: ${source}`;
             yield* this.pop({ type: 'error', offset: this.offset, message, source });
@@ -7068,10 +7661,21 @@ class Parser {
     }
 }
 
+parser$2.Parser = Parser$1;
+
+var publicApi$1 = {};
+
+var composer$1 = composer$2;
+var Document$1 = Document$5;
+var errors$1 = errors$4;
+var log = log$2;
+var lineCounter$1 = lineCounter$2;
+var parser$1 = parser$2;
+
 function parseOptions(options) {
     const prettyErrors = options.prettyErrors !== false;
-    const lineCounter = options.lineCounter || (prettyErrors && new LineCounter()) || null;
-    return { lineCounter, prettyErrors };
+    const lineCounter$1$1 = options.lineCounter || (prettyErrors && new lineCounter$1.LineCounter()) || null;
+    return { lineCounter: lineCounter$1$1, prettyErrors };
 }
 /**
  * Parse the input as a stream of YAML documents.
@@ -7082,42 +7686,42 @@ function parseOptions(options) {
  *   EmptyStream and contain additional stream information. In
  *   TypeScript, you should use `'empty' in docs` as a type guard for it.
  */
-function parseAllDocuments(source, options = {}) {
+function parseAllDocuments$1(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
-    const parser = new Parser(lineCounter?.addNewLine);
-    const composer = new Composer(options);
-    const docs = Array.from(composer.compose(parser.parse(source)));
+    const parser$1$1 = new parser$1.Parser(lineCounter?.addNewLine);
+    const composer$1$1 = new composer$1.Composer(options);
+    const docs = Array.from(composer$1$1.compose(parser$1$1.parse(source)));
     if (prettyErrors && lineCounter)
         for (const doc of docs) {
-            doc.errors.forEach(prettifyError(source, lineCounter));
-            doc.warnings.forEach(prettifyError(source, lineCounter));
+            doc.errors.forEach(errors$1.prettifyError(source, lineCounter));
+            doc.warnings.forEach(errors$1.prettifyError(source, lineCounter));
         }
     if (docs.length > 0)
         return docs;
-    return Object.assign([], { empty: true }, composer.streamInfo());
+    return Object.assign([], { empty: true }, composer$1$1.streamInfo());
 }
 /** Parse an input string into a single YAML.Document */
-function parseDocument(source, options = {}) {
+function parseDocument$1(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
-    const parser = new Parser(lineCounter?.addNewLine);
-    const composer = new Composer(options);
+    const parser$1$1 = new parser$1.Parser(lineCounter?.addNewLine);
+    const composer$1$1 = new composer$1.Composer(options);
     // `doc` is always set by compose.end(true) at the very latest
     let doc = null;
-    for (const _doc of composer.compose(parser.parse(source), true, source.length)) {
+    for (const _doc of composer$1$1.compose(parser$1$1.parse(source), true, source.length)) {
         if (!doc)
             doc = _doc;
         else if (doc.options.logLevel !== 'silent') {
-            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            doc.errors.push(new errors$1.YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
             break;
         }
     }
     if (prettyErrors && lineCounter) {
-        doc.errors.forEach(prettifyError(source, lineCounter));
-        doc.warnings.forEach(prettifyError(source, lineCounter));
+        doc.errors.forEach(errors$1.prettifyError(source, lineCounter));
+        doc.warnings.forEach(errors$1.prettifyError(source, lineCounter));
     }
     return doc;
 }
-function parse(src, reviver, options) {
+function parse$1(src, reviver, options) {
     let _reviver = undefined;
     if (typeof reviver === 'function') {
         _reviver = reviver;
@@ -7125,10 +7729,10 @@ function parse(src, reviver, options) {
     else if (options === undefined && reviver && typeof reviver === 'object') {
         options = reviver;
     }
-    const doc = parseDocument(src, options);
+    const doc = parseDocument$1(src, options);
     if (!doc)
         return null;
-    doc.warnings.forEach(warning => warn(doc.options.logLevel, warning));
+    doc.warnings.forEach(warning => log.warn(doc.options.logLevel, warning));
     if (doc.errors.length > 0) {
         if (doc.options.logLevel !== 'silent')
             throw doc.errors[0];
@@ -7137,7 +7741,7 @@ function parse(src, reviver, options) {
     }
     return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
-function stringify(value, replacer, options) {
+function stringify$1(value, replacer, options) {
     let _replacer = null;
     if (typeof replacer === 'function' || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -7156,31 +7760,86 @@ function stringify(value, replacer, options) {
         if (!keepUndefined)
             return undefined;
     }
-    return new Document(value, _replacer, options).toString(options);
+    return new Document$1.Document(value, _replacer, options).toString(options);
 }
 
-var YAML = /*#__PURE__*/Object.freeze({
+publicApi$1.parse = parse$1;
+publicApi$1.parseAllDocuments = parseAllDocuments$1;
+publicApi$1.parseDocument = parseDocument$1;
+publicApi$1.stringify = stringify$1;
+
+var composer = composer$2;
+var Document = Document$5;
+var Schema = Schema$3;
+var errors = errors$4;
+var Alias = Alias$5;
+var Node = Node$t;
+var Pair = Pair$9;
+var Scalar = Scalar$k;
+var YAMLMap = YAMLMap$7;
+var YAMLSeq = YAMLSeq$7;
+var cst = cst$3;
+var lexer = lexer$2;
+var lineCounter = lineCounter$2;
+var parser = parser$2;
+var publicApi = publicApi$1;
+var visit = visit$6;
+
+
+
+var Composer = dist.Composer = composer.Composer;
+var Document_1 = dist.Document = Document.Document;
+var Schema_1 = dist.Schema = Schema.Schema;
+var YAMLError = dist.YAMLError = errors.YAMLError;
+var YAMLParseError = dist.YAMLParseError = errors.YAMLParseError;
+var YAMLWarning = dist.YAMLWarning = errors.YAMLWarning;
+var Alias_1 = dist.Alias = Alias.Alias;
+var isAlias = dist.isAlias = Node.isAlias;
+var isCollection = dist.isCollection = Node.isCollection;
+var isDocument = dist.isDocument = Node.isDocument;
+var isMap = dist.isMap = Node.isMap;
+var isNode = dist.isNode = Node.isNode;
+var isPair = dist.isPair = Node.isPair;
+var isScalar = dist.isScalar = Node.isScalar;
+var isSeq = dist.isSeq = Node.isSeq;
+var Pair_1 = dist.Pair = Pair.Pair;
+var Scalar_1 = dist.Scalar = Scalar.Scalar;
+var YAMLMap_1 = dist.YAMLMap = YAMLMap.YAMLMap;
+var YAMLSeq_1 = dist.YAMLSeq = YAMLSeq.YAMLSeq;
+var CST = dist.CST = cst;
+var Lexer = dist.Lexer = lexer.Lexer;
+var LineCounter = dist.LineCounter = lineCounter.LineCounter;
+var Parser = dist.Parser = parser.Parser;
+var parse = dist.parse = publicApi.parse;
+var parseAllDocuments = dist.parseAllDocuments = publicApi.parseAllDocuments;
+var parseDocument = dist.parseDocument = publicApi.parseDocument;
+var stringify = dist.stringify = publicApi.stringify;
+var visit_1 = dist.visit = visit.visit;
+var visitAsync = dist.visitAsync = visit.visitAsync;
+
+var index = /*#__PURE__*/_mergeNamespaces({
     __proto__: null,
-    CST: cst,
+    'default': dist,
     Composer: Composer,
-    Document: Document,
-    Schema: Schema,
+    Document: Document_1,
+    Schema: Schema_1,
     YAMLError: YAMLError,
     YAMLParseError: YAMLParseError,
     YAMLWarning: YAMLWarning,
-    Alias: Alias,
+    Alias: Alias_1,
     isAlias: isAlias,
-    isCollection: isCollection$1,
+    isCollection: isCollection,
     isDocument: isDocument,
     isMap: isMap,
     isNode: isNode,
     isPair: isPair,
-    isScalar: isScalar$1,
+    isScalar: isScalar,
     isSeq: isSeq,
-    Pair: Pair,
-    Scalar: Scalar,
-    YAMLMap: YAMLMap,
-    YAMLSeq: YAMLSeq,
+    Pair: Pair_1,
+    Scalar: Scalar_1,
+    YAMLMap: YAMLMap_1,
+    YAMLSeq: YAMLSeq_1,
+    CST: CST,
     Lexer: Lexer,
     LineCounter: LineCounter,
     Parser: Parser,
@@ -7188,39 +7847,8 @@ var YAML = /*#__PURE__*/Object.freeze({
     parseAllDocuments: parseAllDocuments,
     parseDocument: parseDocument,
     stringify: stringify,
-    visit: visit$1,
+    visit: visit_1,
     visitAsync: visitAsync
-});
+}, [dist]);
 
-// `export * as default from ...` fails on Webpack v4
-
-exports.Alias = Alias;
-exports.CST = cst;
-exports.Composer = Composer;
-exports.Document = Document;
-exports.Lexer = Lexer;
-exports.LineCounter = LineCounter;
-exports.Pair = Pair;
-exports.Parser = Parser;
-exports.Scalar = Scalar;
-exports.Schema = Schema;
-exports.YAMLError = YAMLError;
-exports.YAMLMap = YAMLMap;
-exports.YAMLParseError = YAMLParseError;
-exports.YAMLSeq = YAMLSeq;
-exports.YAMLWarning = YAMLWarning;
-exports["default"] = YAML;
-exports.isAlias = isAlias;
-exports.isCollection = isCollection$1;
-exports.isDocument = isDocument;
-exports.isMap = isMap;
-exports.isNode = isNode;
-exports.isPair = isPair;
-exports.isScalar = isScalar$1;
-exports.isSeq = isSeq;
-exports.parse = parse;
-exports.parseAllDocuments = parseAllDocuments;
-exports.parseDocument = parseDocument;
-exports.stringify = stringify;
-exports.visit = visit$1;
-exports.visitAsync = visitAsync;
+exports.index = index;