yaml 2.0.0-4 → 2.0.0-5

package/dist/nodes/Alias.js

@@ -1,7 +1,8 @@
 'use strict';
 
+var anchors = require('../doc/anchors.js');
+var visit = require('../visit.js');
 var Node = require('./Node.js');
-var toJS = require('./toJS.js');
 
 class Alias extends Node.NodeBase {
     constructor(source) {
@@ -13,58 +14,80 @@ class Alias extends Node.NodeBase {
             }
         });
     }
-    toJSON(arg, ctx) {
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc) {
+        let found = undefined;
+        visit.visit(doc, {
+            Node: (_key, node) => {
+                if (node === this)
+                    return visit.visit.BREAK;
+                if (node.anchor === this.source)
+                    found = node;
+            }
+        });
+        return found;
+    }
+    toJSON(_arg, ctx) {
         if (!ctx)
-            return toJS.toJS(this.source, typeof arg === 'string' ? arg : null, ctx);
-        const { anchors, maxAliasCount } = ctx;
-        const anchor = anchors && anchors.get(this.source);
+            return { source: this.source };
+        const { anchors, doc, maxAliasCount } = ctx;
+        const source = this.resolve(doc);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        const data = anchors.get(source);
         /* istanbul ignore if */
-        if (!anchor || anchor.res === undefined) {
+        if (!data || data.res === undefined) {
             const msg = 'This should not happen: Alias anchor was not resolved?';
             throw new ReferenceError(msg);
         }
         if (maxAliasCount >= 0) {
-            anchor.count += 1;
-            if (anchor.aliasCount === 0)
-                anchor.aliasCount = getAliasCount(this.source, anchors);
-            if (anchor.count * anchor.aliasCount > maxAliasCount) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+                data.aliasCount = getAliasCount(doc, source, anchors);
+            if (data.count * data.aliasCount > maxAliasCount) {
                 const msg = 'Excessive alias count indicates a resource exhaustion attack';
                 throw new ReferenceError(msg);
             }
         }
-        return anchor.res;
+        return data.res;
     }
-    // Only called when stringifying an alias mapping key while constructing
-    // Object output.
-    toString({ anchors, doc, implicitKey, inStringifyKey }, _onComment, _onChompKeep) {
-        let anchor = Object.keys(anchors).find(a => anchors[a] === this.source);
-        if (!anchor && inStringifyKey)
-            anchor = doc.anchors.getName(this.source) || doc.anchors.newName();
-        if (anchor)
-            return `*${anchor}${implicitKey ? ' ' : ''}`;
-        const msg = doc.anchors.getName(this.source)
-            ? 'Alias node must be after source node'
-            : 'Source node not found for alias node';
-        throw new Error(`${msg} [${this.range}]`);
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchors.anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
     }
 }
-function getAliasCount(node, anchors) {
+function getAliasCount(doc, node, anchors) {
     if (Node.isAlias(node)) {
-        const anchor = anchors && anchors.get(node.source);
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
         return anchor ? anchor.count * anchor.aliasCount : 0;
     }
     else if (Node.isCollection(node)) {
         let count = 0;
         for (const item of node.items) {
-            const c = getAliasCount(item, anchors);
+            const c = getAliasCount(doc, item, anchors);
             if (c > count)
                 count = c;
         }
         return count;
     }
     else if (Node.isPair(node)) {
-        const kc = getAliasCount(node.key, anchors);
-        const vc = getAliasCount(node.value, anchors);
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
         return Math.max(kc, vc);
     }
     return 1;

package/dist/nodes/Collection.d.ts

@@ -1,27 +1,14 @@
-import type { Schema } from '../doc/Schema.js';
-import { StringifyContext } from '../stringify/stringify.js';
+import type { Schema } from '../schema/Schema.js';
 import { NodeBase, NODE_TYPE } from './Node.js';
 export declare function collectionFromPath(schema: Schema, path: unknown[], value: unknown): import("./Node.js").Node;
 export declare const isEmptyPath: (path: Iterable<unknown> | null | undefined) => boolean;
-export declare namespace Collection {
-    interface StringifyContext {
-        blockItem(node: StringifyNode): string;
-        flowChars: {
-            start: '{' | '[';
-            end: '}' | ']';
-        };
-        itemIndent: string;
-    }
-    interface StringifyNode {
-        type: 'comment' | 'item';
-        str: string;
-    }
-}
 export declare abstract class Collection extends NodeBase {
     static maxFlowStringSingleLineLength: number;
     schema: Schema | undefined;
     [NODE_TYPE]: symbol;
     items: unknown[];
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
     /**
      * If true, stringify this and all child nodes using flow rather than
      * block styles.
@@ -77,5 +64,4 @@ export declare abstract class Collection extends NodeBase {
      * boolean to add/remove the item from the set.
      */
     setIn([key, ...rest]: Iterable<unknown>, value: unknown): void;
-    _toString(ctx: StringifyContext, { blockItem, flowChars, itemIndent }: Collection.StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/dist/nodes/Collection.js

@@ -1,8 +1,6 @@
 'use strict';
 
 var createNode = require('../doc/createNode.js');
-var addComment = require('../stringify/addComment.js');
-var stringify = require('../stringify/stringify.js');
 var Node = require('./Node.js');
 
 function collectionFromPath(schema, path, value) {
@@ -26,11 +24,11 @@ function collectionFromPath(schema, path, value) {
         }
     }
     return createNode.createNode(v, undefined, {
-        onAlias() {
+        onAnchor() {
             throw new Error('Repeated objects are not supported here');
         },
-        prevObjects: new Map(),
-        schema
+        schema,
+        sourceObjects: new Map()
     });
 }
 // null, undefined, or an empty non-string iterable (e.g. [])
@@ -92,7 +90,7 @@ class Collection extends Node.NodeBase {
     }
     hasAllNullValues(allowScalar) {
         return this.items.every(node => {
-            if (!node || Node.isNode(node))
+            if (!Node.isPair(node))
                 return false;
             const n = node.value;
             return (n == null ||
@@ -131,82 +129,6 @@ class Collection extends Node.NodeBase {
                 throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
         }
     }
-    _toString(ctx, { blockItem, flowChars, itemIndent }, onComment, onChompKeep) {
-        const { indent, indentStep } = ctx;
-        const inFlow = this.flow || ctx.inFlow;
-        if (inFlow)
-            itemIndent += indentStep;
-        ctx = Object.assign({}, ctx, { indent: itemIndent, inFlow, type: null });
-        let chompKeep = false;
-        let hasItemWithNewLine = false;
-        const nodes = this.items.reduce((nodes, item, i) => {
-            let comment = null;
-            if (Node.isNode(item) || Node.isPair(item)) {
-                if (!chompKeep && item.spaceBefore)
-                    nodes.push({ type: 'comment', str: '' });
-                if (item.commentBefore) {
-                    // This match will always succeed on a non-empty string
-                    for (const line of item.commentBefore.match(/^.*$/gm))
-                        nodes.push({ type: 'comment', str: `#${line}` });
-                }
-                if (item.comment)
-                    comment = item.comment;
-                const pair = item; // Apply guards manually in the following
-                if (inFlow &&
-                    ((!chompKeep && item.spaceBefore) ||
-                        item.commentBefore ||
-                        item.comment ||
-                        (pair.key && (pair.key.commentBefore || pair.key.comment)) ||
-                        (pair.value && (pair.value.commentBefore || pair.value.comment))))
-                    hasItemWithNewLine = true;
-            }
-            chompKeep = false;
-            let str = stringify.stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
-            if (inFlow && !hasItemWithNewLine && str.includes('\n'))
-                hasItemWithNewLine = true;
-            if (inFlow && i < this.items.length - 1)
-                str += ',';
-            str = addComment.addComment(str, itemIndent, comment);
-            if (chompKeep && (comment || inFlow))
-                chompKeep = false;
-            nodes.push({ type: 'item', str });
-            return nodes;
-        }, []);
-        let str;
-        if (nodes.length === 0) {
-            str = flowChars.start + flowChars.end;
-        }
-        else if (inFlow) {
-            const { start, end } = flowChars;
-            const strings = nodes.map(n => n.str);
-            if (hasItemWithNewLine ||
-                strings.reduce((sum, str) => sum + str.length + 2, 2) >
-                    Collection.maxFlowStringSingleLineLength) {
-                str = start;
-                for (const s of strings) {
-                    str += s ? `\n${indentStep}${indent}${s}` : '\n';
-                }
-                str += `\n${indent}${end}`;
-            }
-            else {
-                str = `${start} ${strings.join(' ')} ${end}`;
-            }
-        }
-        else {
-            const strings = nodes.map(blockItem);
-            str = strings.shift() || '';
-            for (const s of strings)
-                str += s ? `\n${indent}${s}` : '\n';
-        }
-        if (this.comment) {
-            str += '\n' + this.comment.replace(/^/gm, `${indent}#`);
-            if (onComment)
-                onComment();
-        }
-        else if (chompKeep && onChompKeep)
-            onChompKeep();
-        return str;
-    }
 }
 Collection.maxFlowStringSingleLineLength = 60;
 

package/dist/nodes/Node.d.ts

@@ -7,6 +7,7 @@ import type { YAMLMap } from './YAMLMap.js';
 import type { YAMLSeq } from './YAMLSeq.js';
 export declare type Node = Alias | Scalar | YAMLMap | YAMLSeq;
 export declare type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
+export declare type Range = [number, number, number];
 export declare const ALIAS: unique symbol;
 export declare const DOC: unique symbol;
 export declare const MAP: unique symbol;
@@ -14,7 +15,7 @@ export declare const PAIR: unique symbol;
 export declare const SCALAR: unique symbol;
 export declare const SEQ: unique symbol;
 export declare const NODE_TYPE: unique symbol;
-export declare const isAlias: (node: any) => node is Alias<Node>;
+export declare const isAlias: (node: any) => node is Alias;
 export declare const isDocument: (node: any) => node is Document<unknown>;
 export declare const isMap: (node: any) => node is YAMLMap<unknown, unknown>;
 export declare const isPair: (node: any) => node is Pair<unknown, unknown>;
@@ -22,6 +23,7 @@ export declare const isScalar: (node: any) => node is Scalar<unknown>;
 export declare const isSeq: (node: any) => node is YAMLSeq<unknown>;
 export declare function isCollection(node: any): node is YAMLMap | YAMLSeq;
 export declare function isNode(node: any): node is Node;
+export declare const hasAnchor: (node: unknown) => node is YAMLMap<unknown, unknown> | YAMLSeq<unknown> | Scalar<unknown>;
 export declare abstract class NodeBase {
     readonly [NODE_TYPE]: symbol;
     /** A comment on or immediately after this */
@@ -29,10 +31,10 @@ export declare abstract class NodeBase {
     /** A comment before this */
     commentBefore?: string | null;
     /**
-     * The [start, end] range of characters of the source parsed
-     * into this node (undefined for pairs or if not parsed)
+     * The [start, value-end, node-end] character offsets for the part of the
+     * source parsed into this node (undefined if not parsed).
      */
-    range?: [number, number] | null;
+    range?: Range | null;
     /** A blank line before this node and its commentBefore */
     spaceBefore?: boolean;
     /** A fully qualified tag, if required */

package/dist/nodes/Node.js

@@ -33,6 +33,7 @@ function isNode(node) {
         }
     return false;
 }
+const hasAnchor = (node) => (isScalar(node) || isCollection(node)) && !!node.anchor;
 class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
@@ -47,6 +48,7 @@ exports.NodeBase = NodeBase;
 exports.PAIR = PAIR;
 exports.SCALAR = SCALAR;
 exports.SEQ = SEQ;
+exports.hasAnchor = hasAnchor;
 exports.isAlias = isAlias;
 exports.isCollection = isCollection;
 exports.isDocument = isDocument;

package/dist/nodes/Pair.d.ts

@@ -1,21 +1,16 @@
 import { CreateNodeContext } from '../doc/createNode.js';
 import { StringifyContext } from '../stringify/stringify.js';
-import { Scalar } from './Scalar.js';
+import { addPairToJSMap } from './addPairToJSMap.js';
+import { NODE_TYPE } from './Node.js';
 import { ToJSContext } from './toJS.js';
-import { Node, NodeBase } from './Node.js';
-export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<Node, import("./Alias.js").Alias<Node> | Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
-export declare class Pair<K = unknown, V = unknown> extends NodeBase {
-    static readonly MERGE_KEY = "<<";
+export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
+export declare class Pair<K = unknown, V = unknown> {
+    readonly [NODE_TYPE]: symbol;
     /** Always Node or null when parsed, but can be set to anything. */
     key: K;
     /** Always Node or null when parsed, but can be set to anything. */
     value: V | null;
     constructor(key: K, value?: V | null);
-    get commentBefore(): string | null | undefined;
-    set commentBefore(cb: string | null | undefined);
-    get spaceBefore(): boolean | undefined;
-    set spaceBefore(sb: boolean | undefined);
-    addToJSMap(ctx: ToJSContext | undefined, map: Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>): Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;
-    toJSON(_?: unknown, ctx?: ToJSContext): Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;
+    toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/dist/nodes/Pair.js

@@ -1,11 +1,8 @@
 'use strict';
 
 var createNode = require('../doc/createNode.js');
-var log = require('../log.js');
-var addComment = require('../stringify/addComment.js');
-var stringify = require('../stringify/stringify.js');
-var Scalar = require('./Scalar.js');
-var toJS = require('./toJS.js');
+var stringifyPair = require('../stringify/stringifyPair.js');
+var addPairToJSMap = require('./addPairToJSMap.js');
 var Node = require('./Node.js');
 
 function createPair(key, value, ctx) {
@@ -13,241 +10,21 @@ function createPair(key, value, ctx) {
     const v = createNode.createNode(value, undefined, ctx);
     return new Pair(k, v);
 }
-const isMergeKey = (key) => key === Pair.MERGE_KEY ||
-    (Node.isScalar(key) &&
-        key.value === Pair.MERGE_KEY &&
-        (!key.type || key.type === Scalar.Scalar.PLAIN));
-// If the value associated with a merge key is a single mapping node, each of
-// its key/value pairs is inserted into the current mapping, unless the key
-// already exists in it. If the value associated with the merge key is a
-// sequence, then this sequence is expected to contain mapping nodes and each
-// of these nodes is merged in turn according to its order in the sequence.
-// Keys in mapping nodes earlier in the sequence override keys specified in
-// later mapping nodes. -- http://yaml.org/type/merge.html
-function mergeToJSMap(ctx, map, value) {
-    if (!Node.isAlias(value) || !Node.isMap(value.source))
-        throw new Error('Merge sources must be map aliases');
-    const srcMap = value.source.toJSON(null, ctx, Map);
-    for (const [key, value] of srcMap) {
-        if (map instanceof Map) {
-            if (!map.has(key))
-                map.set(key, value);
-        }
-        else if (map instanceof Set) {
-            map.add(key);
-        }
-        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
-            Object.defineProperty(map, key, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        }
-    }
-    return map;
-}
-class Pair extends Node.NodeBase {
+class Pair {
     constructor(key, value = null) {
-        super(Node.PAIR);
+        Object.defineProperty(this, Node.NODE_TYPE, { value: Node.PAIR });
         this.key = key;
         this.value = value;
     }
-    // @ts-ignore This is fine.
-    get commentBefore() {
-        return Node.isNode(this.key) ? this.key.commentBefore : undefined;
-    }
-    set commentBefore(cb) {
-        if (this.key == null)
-            this.key = new Scalar.Scalar(null); // FIXME
-        if (Node.isNode(this.key))
-            this.key.commentBefore = cb;
-        else {
-            const msg = 'Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.';
-            throw new Error(msg);
-        }
-    }
-    // @ts-ignore This is fine.
-    get spaceBefore() {
-        return Node.isNode(this.key) ? this.key.spaceBefore : undefined;
-    }
-    set spaceBefore(sb) {
-        if (this.key == null)
-            this.key = new Scalar.Scalar(null); // FIXME
-        if (Node.isNode(this.key))
-            this.key.spaceBefore = sb;
-        else {
-            const msg = 'Pair.spaceBefore is an alias for Pair.key.spaceBefore. To set it, the key must be a Node.';
-            throw new Error(msg);
-        }
-    }
-    addToJSMap(ctx, map) {
-        if (ctx && ctx.doc.schema.merge && isMergeKey(this.key)) {
-            if (Node.isSeq(this.value))
-                for (const it of this.value.items)
-                    mergeToJSMap(ctx, map, it);
-            else if (Array.isArray(this.value))
-                for (const it of this.value)
-                    mergeToJSMap(ctx, map, it);
-            else
-                mergeToJSMap(ctx, map, this.value);
-        }
-        else {
-            const key = toJS.toJS(this.key, '', ctx);
-            if (map instanceof Map) {
-                const value = toJS.toJS(this.value, key, ctx);
-                map.set(key, value);
-            }
-            else if (map instanceof Set) {
-                map.add(key);
-            }
-            else {
-                const stringKey = stringifyKey(this.key, key, ctx);
-                const value = toJS.toJS(this.value, stringKey, ctx);
-                if (stringKey in map)
-                    Object.defineProperty(map, stringKey, {
-                        value,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true
-                    });
-                else
-                    map[stringKey] = value;
-            }
-        }
-        return map;
-    }
     toJSON(_, ctx) {
         const pair = ctx && ctx.mapAsMap ? new Map() : {};
-        return this.addToJSMap(ctx, pair);
+        return addPairToJSMap.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
-        if (!ctx || !ctx.doc)
-            return JSON.stringify(this);
-        const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
-        let { key, value } = this;
-        let keyComment = (Node.isNode(key) && key.comment) || null;
-        if (simpleKeys) {
-            if (keyComment) {
-                throw new Error('With simple keys, key nodes cannot have comments');
-            }
-            if (Node.isCollection(key)) {
-                const msg = 'With simple keys, collection cannot be used as a key value';
-                throw new Error(msg);
-            }
-        }
-        let explicitKey = !simpleKeys &&
-            (!key ||
-                (keyComment && value == null) ||
-                Node.isCollection(key) ||
-                (Node.isScalar(key)
-                    ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL
-                    : typeof key === 'object'));
-        ctx = Object.assign({}, ctx, {
-            allNullValues: false,
-            implicitKey: !explicitKey && (simpleKeys || !allNullValues),
-            indent: indent + indentStep
-        });
-        let chompKeep = false;
-        let str = stringify.stringify(key, ctx, () => (keyComment = null), () => (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');
-            explicitKey = true;
-        }
-        if ((allNullValues && (!simpleKeys || ctx.inFlow)) ||
-            (value == null && (explicitKey || ctx.inFlow))) {
-            str = addComment.addComment(str, ctx.indent, keyComment);
-            if (this.comment) {
-                if (keyComment && !this.comment.includes('\n'))
-                    str += `\n${ctx.indent || ''}#${this.comment}`;
-                else
-                    str = addComment.addComment(str, ctx.indent, this.comment);
-                if (onComment)
-                    onComment();
-            }
-            else if (chompKeep && !keyComment && onChompKeep)
-                onChompKeep();
-            return ctx.inFlow && !explicitKey ? str : `? ${str}`;
-        }
-        str = explicitKey
-            ? `? ${addComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
-            : addComment.addComment(`${str}:`, ctx.indent, keyComment);
-        if (this.comment) {
-            if (keyComment && !explicitKey && !this.comment.includes('\n'))
-                str += `\n${ctx.indent || ''}#${this.comment}`;
-            else
-                str = addComment.addComment(str, ctx.indent, this.comment);
-            if (onComment)
-                onComment();
-        }
-        let vcb = '';
-        let valueComment = null;
-        if (Node.isNode(value)) {
-            if (value.spaceBefore)
-                vcb = '\n';
-            if (value.commentBefore) {
-                const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
-                vcb += `\n${cs}`;
-            }
-            valueComment = value.comment;
-        }
-        else if (value && typeof value === 'object') {
-            value = doc.createNode(value);
-        }
-        ctx.implicitKey = false;
-        if (!explicitKey && !keyComment && !this.comment && Node.isScalar(value))
-            ctx.indentAtStart = str.length + 1;
-        chompKeep = false;
-        if (!indentSeq &&
-            indentStep.length >= 2 &&
-            !ctx.inFlow &&
-            !explicitKey &&
-            Node.isSeq(value) &&
-            !value.flow &&
-            !value.tag &&
-            !doc.anchors.getName(value)) {
-            // If indentSeq === false, consider '- ' as part of indentation where possible
-            ctx.indent = ctx.indent.substr(2);
-        }
-        const valueStr = stringify.stringify(value, ctx, () => (valueComment = null), () => (chompKeep = true));
-        let ws = ' ';
-        if (vcb || keyComment || this.comment) {
-            ws = `${vcb}\n${ctx.indent}`;
-        }
-        else if (!explicitKey && Node.isCollection(value)) {
-            const flow = valueStr[0] === '[' || valueStr[0] === '{';
-            if (!flow || valueStr.includes('\n'))
-                ws = `\n${ctx.indent}`;
-        }
-        else if (valueStr[0] === '\n')
-            ws = '';
-        if (chompKeep && !valueComment && onChompKeep)
-            onChompKeep();
-        return addComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
-    }
-}
-Pair.MERGE_KEY = '<<';
-function stringifyKey(key, jsKey, ctx) {
-    if (jsKey === null)
-        return '';
-    if (typeof jsKey !== 'object')
-        return String(jsKey);
-    if (Node.isNode(key) && ctx && ctx.doc) {
-        const strCtx = stringify.createStringifyContext(ctx.doc, {});
-        strCtx.inFlow = true;
-        strCtx.inStringifyKey = true;
-        const strKey = key.toString(strCtx);
-        if (!ctx.mapKeyWarned) {
-            let jsonStr = JSON.stringify(strKey);
-            if (jsonStr.length > 40)
-                jsonStr = jsonStr.substring(0, 36) + '..."';
-            log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
-            ctx.mapKeyWarned = true;
-        }
-        return strKey;
+        return ctx && ctx.doc
+            ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
     }
-    return JSON.stringify(jsKey);
 }
 
 exports.Pair = Pair;

package/dist/nodes/Scalar.d.ts

@@ -1,9 +1,9 @@
-import { NodeBase } from './Node.js';
+import { NodeBase, Range } from './Node.js';
 import { ToJSContext } from './toJS.js';
 export declare const isScalarValue: (value: unknown) => boolean;
 export declare namespace Scalar {
     interface Parsed extends Scalar {
-        range: [number, number];
+        range: Range;
         source: string;
     }
     type BLOCK_FOLDED = 'BLOCK_FOLDED';
@@ -20,7 +20,8 @@ export declare class Scalar<T = unknown> extends NodeBase {
     static readonly QUOTE_DOUBLE = "QUOTE_DOUBLE";
     static readonly QUOTE_SINGLE = "QUOTE_SINGLE";
     value: T;
-    type?: Scalar.Type;
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
     /**
      * By default (undefined), numbers use decimal notation.
      * The YAML 1.2 core schema only supports 'HEX' and 'OCT'.
@@ -31,6 +32,8 @@ export declare class Scalar<T = unknown> extends NodeBase {
     minFractionDigits?: number;
     /** Set during parsing to the source string value */
     source?: string;
+    /** The scalar style used for the node's string representation */
+    type?: Scalar.Type;
     constructor(value: T);
     toJSON(arg?: any, ctx?: ToJSContext): any;
     toString(): string;

package/dist/nodes/YAMLMap.d.ts

@@ -1,14 +1,14 @@
-import type { Schema } from '../doc/Schema.js';
+import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
-import { ParsedNode } from './Node.js';
+import { ParsedNode, Range } from './Node.js';
 import { Pair } from './Pair.js';
 import type { ToJSContext } from './toJS.js';
 export declare function findPair<K = unknown, V = unknown>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
 export declare namespace YAMLMap {
     interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
         items: Pair<K, V>[];
-        range: [number, number];
+        range: Range;
     }
 }
 export declare class YAMLMap<K = unknown, V = unknown> extends Collection {