yaml 2.0.0-4 → 2.0.0-5

package/browser/dist/doc/createNode.js

@@ -1,4 +1,5 @@
-import { isNode, isPair } from '../nodes/Node.js';
+import { Alias } from '../nodes/Alias.js';
+import { isNode, isPair, MAP, SEQ } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
@@ -17,7 +18,7 @@ function createNode(value, tagName, ctx) {
     if (isNode(value))
         return value;
     if (isPair(value)) {
-        const map = (_b = (_a = ctx.schema.map).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
+        const map = (_b = (_a = ctx.schema[MAP]).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
         map.items.push(value);
         return map;
     }
@@ -29,39 +30,48 @@ function createNode(value, tagName, ctx) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { onAlias, onTagObj, prevObjects } = ctx;
-    const { map, seq, tags } = ctx.schema;
+    const { onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    // Detect duplicate references to the same object & use Alias nodes for all
+    // after first. The `ref` wrapper allows for circular references to resolve.
+    let ref = undefined;
+    if (value && typeof value === 'object') {
+        ref = sourceObjects.get(value);
+        if (ref) {
+            if (!ref.anchor)
+                ref.anchor = onAnchor(value);
+            return new Alias(ref.anchor);
+        }
+        else {
+            ref = { anchor: null, node: null };
+            sourceObjects.set(value, ref);
+        }
+    }
     if (tagName && tagName.startsWith('!!'))
         tagName = defaultTagPrefix + tagName.slice(2);
-    let tagObj = findTagObject(value, tagName, tags);
+    let tagObj = findTagObject(value, tagName, schema.tags);
     if (!tagObj) {
         if (value && typeof value.toJSON === 'function')
             value = value.toJSON();
         if (!value || typeof value !== 'object')
             return new Scalar(value);
         tagObj =
-            value instanceof Map ? map : Symbol.iterator in Object(value) ? seq : map;
+            value instanceof Map
+                ? schema[MAP]
+                : Symbol.iterator in Object(value)
+                    ? schema[SEQ]
+                    : schema[MAP];
     }
     if (onTagObj) {
         onTagObj(tagObj);
         delete ctx.onTagObj;
     }
-    // Detect duplicate references to the same object & use Alias nodes for all
-    // after first. The `ref` wrapper allows for circular references to resolve.
-    const ref = { value: undefined, node: undefined };
-    if (value && typeof value === 'object') {
-        const prev = prevObjects.get(value);
-        if (prev)
-            return onAlias(prev);
-        ref.value = value;
-        prevObjects.set(value, ref);
-    }
     const node = (tagObj === null || tagObj === void 0 ? void 0 : tagObj.createNode)
         ? tagObj.createNode(ctx.schema, value, ctx)
         : new Scalar(value);
     if (tagName)
         node.tag = tagName;
-    ref.node = node;
+    if (ref)
+        ref.node = node;
     return node;
 }
 

package/browser/dist/errors.js

@@ -1,28 +1,27 @@
 class YAMLError extends Error {
-    constructor(name, offset, message) {
-        if (!message)
-            throw new Error(`Invalid arguments for new ${name}`);
+    constructor(name, pos, code, message) {
         super();
         this.name = name;
+        this.code = code;
         this.message = message;
-        this.offset = offset;
+        this.pos = pos;
     }
 }
 class YAMLParseError extends YAMLError {
-    constructor(offset, message) {
-        super('YAMLParseError', offset, message);
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
     }
 }
 class YAMLWarning extends YAMLError {
-    constructor(offset, message) {
-        super('YAMLWarning', offset, message);
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
     }
 }
 const prettifyError = (src, lc) => (error) => {
-    if (error.offset === -1)
+    if (error.pos[0] === -1)
         return;
-    error.linePos = lc.linePos(error.offset);
-    const { line, col } = error.linePos;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
     error.message += ` at line ${line}, column ${col}`;
     let ci = col - 1;
     let lineStr = src
@@ -45,7 +44,12 @@ const prettifyError = (src, lc) => (error) => {
         lineStr = prev + lineStr;
     }
     if (/[^ ]/.test(lineStr)) {
-        const pointer = ' '.repeat(ci) + '^';
+        let count = 1;
+        const end = error.linePos[1];
+        if (end && end.line === line && end.col > col) {
+            count = Math.min(end.col - col, 80 - ci);
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;
     }
 };

package/browser/dist/index.js

@@ -1,6 +1,6 @@
 export { Composer } from './compose/composer.js';
 export { Document } from './doc/Document.js';
-export { Schema } from './doc/Schema.js';
+export { Schema } from './schema/Schema.js';
 export { YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
 export { Alias } from './nodes/Alias.js';
 export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq } from './nodes/Node.js';
@@ -9,10 +9,10 @@ export { Scalar } from './nodes/Scalar.js';
 export { YAMLMap } from './nodes/YAMLMap.js';
 export { YAMLSeq } from './nodes/YAMLSeq.js';
 export { defaultOptions } from './options.js';
+import * as cst from './parse/cst.js';
+export { cst as CST };
 export { Lexer } from './parse/lexer.js';
 export { LineCounter } from './parse/line-counter.js';
 export { Parser } from './parse/parser.js';
-import * as tokens from './parse/tokens.js';
-export { tokens };
 export { parse, parseAllDocuments, parseDocument, stringify } from './public-api.js';
 export { visit } from './visit.js';

package/browser/dist/nodes/Alias.js

@@ -1,5 +1,6 @@
+import { anchorIsValid } from '../doc/anchors.js';
+import { visit } from '../visit.js';
 import { NodeBase, ALIAS, isAlias, isCollection, isPair } from './Node.js';
-import { toJS } from './toJS.js';
 
 class Alias extends NodeBase {
     constructor(source) {
@@ -11,58 +12,80 @@ class Alias extends 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(doc, {
+            Node: (_key, node) => {
+                if (node === this)
+                    return visit.BREAK;
+                if (node.anchor === this.source)
+                    found = node;
+            }
+        });
+        return found;
+    }
+    toJSON(_arg, ctx) {
         if (!ctx)
-            return 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) {
+            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 (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 (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 (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/browser/dist/nodes/Collection.js

@@ -1,7 +1,5 @@
 import { createNode } from '../doc/createNode.js';
-import { addComment } from '../stringify/addComment.js';
-import { stringify } from '../stringify/stringify.js';
-import { NodeBase, isCollection, isScalar, isNode, isPair } from './Node.js';
+import { NodeBase, isCollection, isScalar, isPair } from './Node.js';
 
 function collectionFromPath(schema, path, value) {
     let v = value;
@@ -24,11 +22,11 @@ function collectionFromPath(schema, path, value) {
         }
     }
     return 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. [])
@@ -90,7 +88,7 @@ class Collection extends NodeBase {
     }
     hasAllNullValues(allowScalar) {
         return this.items.every(node => {
-            if (!node || isNode(node))
+            if (!isPair(node))
                 return false;
             const n = node.value;
             return (n == null ||
@@ -129,82 +127,6 @@ class Collection extends 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 (isNode(item) || 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(item, ctx, () => (comment = null), () => (chompKeep = true));
-            if (inFlow && !hasItemWithNewLine && str.includes('\n'))
-                hasItemWithNewLine = true;
-            if (inFlow && i < this.items.length - 1)
-                str += ',';
-            str = 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/browser/dist/nodes/Node.js

@@ -31,10 +31,11 @@ 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 });
     }
 }
 
-export { ALIAS, DOC, MAP, NODE_TYPE, NodeBase, PAIR, SCALAR, SEQ, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };
+export { ALIAS, DOC, MAP, NODE_TYPE, NodeBase, PAIR, SCALAR, SEQ, hasAnchor, isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq };

package/browser/dist/nodes/Pair.js

@@ -1,251 +1,28 @@
 import { createNode } from '../doc/createNode.js';
-import { warn } from '../log.js';
-import { addComment } from '../stringify/addComment.js';
-import { stringify, createStringifyContext } from '../stringify/stringify.js';
-import { Scalar } from './Scalar.js';
-import { toJS } from './toJS.js';
-import { NodeBase, PAIR, isNode, isScalar, isSeq, isCollection, isAlias, isMap } from './Node.js';
+import { stringifyPair } from '../stringify/stringifyPair.js';
+import { addPairToJSMap } from './addPairToJSMap.js';
+import { NODE_TYPE, PAIR } from './Node.js';
 
 function createPair(key, value, ctx) {
     const k = createNode(key, undefined, ctx);
     const v = createNode(value, undefined, ctx);
     return new Pair(k, v);
 }
-const isMergeKey = (key) => key === Pair.MERGE_KEY ||
-    (isScalar(key) &&
-        key.value === Pair.MERGE_KEY &&
-        (!key.type || key.type === Scalar.PLAIN));
-// If the value associated with a merge key is a single mapping node, each of
-// its key/value pairs is inserted into the current mapping, unless the key
-// already exists in it. If the value associated with the merge key is a
-// sequence, then this sequence is expected to contain mapping nodes and each
-// of these nodes is merged in turn according to its order in the sequence.
-// Keys in mapping nodes earlier in the sequence override keys specified in
-// later mapping nodes. -- http://yaml.org/type/merge.html
-function mergeToJSMap(ctx, map, value) {
-    if (!isAlias(value) || !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 NodeBase {
+class Pair {
     constructor(key, value = null) {
-        super(PAIR);
+        Object.defineProperty(this, NODE_TYPE, { value: PAIR });
         this.key = key;
         this.value = value;
     }
-    // @ts-ignore This is fine.
-    get commentBefore() {
-        return isNode(this.key) ? this.key.commentBefore : undefined;
-    }
-    set commentBefore(cb) {
-        if (this.key == null)
-            this.key = new Scalar(null); // FIXME
-        if (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 isNode(this.key) ? this.key.spaceBefore : undefined;
-    }
-    set spaceBefore(sb) {
-        if (this.key == null)
-            this.key = new Scalar(null); // FIXME
-        if (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 (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(this.key, '', ctx);
-            if (map instanceof Map) {
-                const value = 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(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(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 = (isNode(key) && key.comment) || null;
-        if (simpleKeys) {
-            if (keyComment) {
-                throw new Error('With simple keys, key nodes cannot have comments');
-            }
-            if (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) ||
-                isCollection(key) ||
-                (isScalar(key)
-                    ? key.type === Scalar.BLOCK_FOLDED || key.type === 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(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(str, ctx.indent, keyComment);
-            if (this.comment) {
-                if (keyComment && !this.comment.includes('\n'))
-                    str += `\n${ctx.indent || ''}#${this.comment}`;
-                else
-                    str = addComment(str, ctx.indent, this.comment);
-                if (onComment)
-                    onComment();
-            }
-            else if (chompKeep && !keyComment && onChompKeep)
-                onChompKeep();
-            return ctx.inFlow && !explicitKey ? str : `? ${str}`;
-        }
-        str = explicitKey
-            ? `? ${addComment(str, ctx.indent, keyComment)}\n${indent}:`
-            : addComment(`${str}:`, ctx.indent, keyComment);
-        if (this.comment) {
-            if (keyComment && !explicitKey && !this.comment.includes('\n'))
-                str += `\n${ctx.indent || ''}#${this.comment}`;
-            else
-                str = addComment(str, ctx.indent, this.comment);
-            if (onComment)
-                onComment();
-        }
-        let vcb = '';
-        let valueComment = null;
-        if (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 && isScalar(value))
-            ctx.indentAtStart = str.length + 1;
-        chompKeep = false;
-        if (!indentSeq &&
-            indentStep.length >= 2 &&
-            !ctx.inFlow &&
-            !explicitKey &&
-            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(value, ctx, () => (valueComment = null), () => (chompKeep = true));
-        let ws = ' ';
-        if (vcb || keyComment || this.comment) {
-            ws = `${vcb}\n${ctx.indent}`;
-        }
-        else if (!explicitKey && 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(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 (isNode(key) && ctx && ctx.doc) {
-        const strCtx = 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) + '..."';
-            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(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
     }
-    return JSON.stringify(jsKey);
 }
 
 export { Pair, createPair };