yaml 2.0.0-5 → 2.0.0-6

package/dist/compose/resolve-flow-collection.js

@@ -7,6 +7,7 @@ var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveEnd = require('./resolve-end.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
+var utilMapIncludes = require('./util-map-includes.js');
 
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
@@ -21,9 +22,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     for (let i = 0; i < fc.items.length; ++i) {
         const { start, key, sep, value } = fc.items[i];
         const props = resolveProps.resolveProps(start, {
-            ctx,
             flow: fcName,
             indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: false
@@ -101,9 +102,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
             const valueProps = resolveProps.resolveProps(sep || [], {
-                ctx,
                 flow: fcName,
                 indicator: 'map-value-ind',
+                next: value,
                 offset: keyNode.range[2],
                 onError,
                 startOnNewline: false
@@ -146,8 +147,12 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair.Pair(keyNode, valueNode);
-            if (isMap)
-                coll.items.push(pair);
+            if (isMap) {
+                const map = coll;
+                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.YAMLMap(ctx.schema);
                 map.flow = true;
@@ -161,7 +166,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const [ce, ...ee] = fc.end;
     let cePos = offset;
     if (ce && ce.source === expectedEnd)
-        cePos += ce.source.length;
+        cePos = ce.offset + ce.source.length;
     else {
         onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
         if (ce && ce.source.length !== 1)

package/dist/compose/resolve-props.d.ts

@@ -1,15 +1,14 @@
-import type { SourceToken } from '../parse/cst.js';
-import type { ComposeContext } from './compose-node.js';
+import type { SourceToken, Token } from '../parse/cst.js';
 import type { ComposeErrorHandler } from './composer.js';
 export interface ResolvePropsArg {
-    ctx: ComposeContext;
     flow?: string;
     indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';
+    next: Token | null | undefined;
     offset: number;
     onError: ComposeErrorHandler;
     startOnNewline: boolean;
 }
-export declare function resolveProps(tokens: SourceToken[], { ctx, flow, indicator, offset, onError, startOnNewline }: ResolvePropsArg): {
+export declare function resolveProps(tokens: SourceToken[], { flow, indicator, next, offset, onError, startOnNewline }: ResolvePropsArg): {
     comma: SourceToken | null;
     found: SourceToken | null;
     spaceBefore: boolean;

package/dist/compose/resolve-props.js

@@ -1,18 +1,26 @@
 'use strict';
 
-function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNewline }) {
+function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
     let comment = '';
     let commentSep = '';
     let hasNewline = false;
+    let reqSpace = false;
     let anchor = null;
     let tag = null;
     let comma = null;
     let found = null;
     let start = null;
     for (const token of tokens) {
+        if (reqSpace) {
+            if (token.type !== 'space' &&
+                token.type !== 'newline' &&
+                token.type !== 'comma')
+                onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+            reqSpace = false;
+        }
         switch (token.type) {
             case 'space':
                 // At the doc level, tabs at line start may be parsed
@@ -26,23 +34,29 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                 hasSpace = true;
                 break;
             case 'comment': {
-                if (ctx.options.strict && !hasSpace)
-                    onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
-                const cb = token.source.substring(1);
+                if (!hasSpace)
+                    onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                const cb = token.source.substring(1) || ' ';
                 if (!comment)
                     comment = cb;
                 else
                     comment += commentSep + cb;
                 commentSep = '';
+                atNewline = false;
                 break;
             }
             case 'newline':
-                if (atNewline && !comment)
-                    spaceBefore = true;
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
-                commentSep += token.source;
                 break;
             case 'anchor':
                 if (anchor)
@@ -52,6 +66,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             case 'tag': {
                 if (tag)
@@ -61,6 +76,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             }
             case indicator:
@@ -89,6 +105,13 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
     }
     const last = tokens[tokens.length - 1];
     const end = last ? last.offset + last.source.length : offset;
+    if (reqSpace &&
+        next &&
+        next.type !== 'space' &&
+        next.type !== 'newline' &&
+        next.type !== 'comma' &&
+        (next.type !== 'scalar' || next.source !== ''))
+        onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
     return {
         comma,
         found,

package/dist/compose/util-map-includes.d.ts

@@ -0,0 +1,4 @@
+import { ParsedNode } from '../nodes/Node';
+import { Pair } from '../nodes/Pair';
+import { ComposeContext } from './compose-node';
+export declare function mapIncludes(ctx: ComposeContext, items: Pair<ParsedNode>[], search: ParsedNode): boolean;

package/dist/compose/util-map-includes.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+
+function mapIncludes(ctx, items, search) {
+    const { uniqueKeys } = ctx.options;
+    if (uniqueKeys === false)
+        return false;
+    const isEqual = typeof uniqueKeys === 'function'
+        ? uniqueKeys
+        : (a, b) => a === b ||
+            (Node.isScalar(a) &&
+                Node.isScalar(b) &&
+                a.value === b.value &&
+                !(a.value === '<<' && ctx.schema.merge));
+    return items.some(pair => isEqual(pair.key, search));
+}
+
+exports.mapIncludes = mapIncludes;

package/dist/doc/Document.d.ts

@@ -27,8 +27,10 @@ export declare class Document<T = unknown> {
     errors: YAMLError[];
     options: Required<Omit<ParseOptions & DocumentOptions, 'lineCounter' | 'directives' | 'version'>>;
     /**
-     * The [start, value-end, node-end] character offsets for the part of the
-     * source parsed into this document (undefined if not parsed).
+     * The `[start, value-end, node-end]` character offsets for the part of the
+     * source parsed into this document (undefined if not parsed). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
      */
     range?: Range;
     /** The schema used with the document. Use `setSchema()` to change. */

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { LineCounter } from './parse/line-counter';
-export declare type ErrorCode = 'ALIAS_PROPS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'COMMENT_SPACE' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_ANCHOR' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN';
+export declare type ErrorCode = 'ALIAS_PROPS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'DUPLICATE_KEY' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_ANCHOR' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN';
 export declare type LinePos = {
     line: number;
     col: number;

package/dist/nodes/Node.d.ts

@@ -31,8 +31,10 @@ export declare abstract class NodeBase {
     /** A comment before this */
     commentBefore?: string | null;
     /**
-     * The [start, value-end, node-end] character offsets for the part of the
-     * source parsed into this node (undefined 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). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
      */
     range?: Range | null;
     /** A blank line before this node and its commentBefore */

package/dist/options.d.ts

@@ -1,6 +1,7 @@
 import type { Reviver } from './doc/applyReviver.js';
 import type { Directives } from './doc/directives.js';
 import type { LogLevelId } from './log.js';
+import type { ParsedNode } from './nodes/Node.js';
 import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { LineCounter } from './parse/line-counter.js';
@@ -34,6 +35,19 @@ export declare type ParseOptions = {
      * Default: `true`
      */
     strict?: boolean;
+    /**
+     * YAML requires map keys to be unique. By default, this is checked by
+     * comparing scalar values with `===`; deep equality is not checked for
+     * aliases or collections. If merge keys are enabled by the schema,
+     * multiple `<<` keys are allowed.
+     *
+     * Set `false` to disable, or provide your own comparator function to
+     * customise. The comparator will be passed two `ParsedNode` values, and
+     * is expected to return a `boolean` indicating their equality.
+     *
+     * Default: `true`
+     */
+    uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean);
 };
 export declare type DocumentOptions = {
     /**
@@ -84,6 +98,7 @@ export declare type SchemaOptions = {
     /**
      * When adding to or stringifying a map, sort the entries.
      * If `true`, sort by comparing key values with `<`.
+     * Does not affect item order when parsing.
      *
      * Default: `false`
      */

package/dist/options.js

@@ -12,6 +12,7 @@ const defaultOptions = {
     logLevel: 'warn',
     prettyErrors: true,
     strict: true,
+    uniqueKeys: true,
     version: '1.2'
 };
 

package/dist/parse/parser.d.ts

@@ -78,6 +78,7 @@ export declare class Parser {
     private flowCollection;
     private flowScalar;
     private startBlockValue;
+    private atIndentedComment;
     private documentEnd;
     private lineEnd;
 }

package/dist/parse/parser.js

@@ -22,38 +22,6 @@ function includesNonEmpty(list) {
     }
     return false;
 }
-function atFirstEmptyLineAfterComments(start) {
-    let hasComment = false;
-    for (let i = 0; i < start.length; ++i) {
-        switch (start[i].type) {
-            case 'space':
-                break;
-            case 'comment':
-                hasComment = true;
-                break;
-            case 'newline':
-                if (!hasComment)
-                    return false;
-                break;
-            default:
-                return false;
-        }
-    }
-    if (hasComment) {
-        for (let i = start.length - 1; i >= 0; --i) {
-            switch (start[i].type) {
-                /* istanbul ignore next */
-                case 'space':
-                    break;
-                case 'newline':
-                    return true;
-                default:
-                    return false;
-            }
-        }
-    }
-    return false;
-}
 function isFlowToken(token) {
     switch (token === null || token === void 0 ? void 0 : token.type) {
         case 'alias':
@@ -506,24 +474,38 @@ class Parser {
         switch (this.type) {
             case 'newline':
                 this.onKeyLine = false;
-                if (!it.sep && atFirstEmptyLineAfterComments(it.start)) {
-                    const prev = map.items[map.items.length - 2];
-                    const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
-                    if (Array.isArray(end)) {
-                        Array.prototype.push.apply(end, it.start);
-                        it.start = [this.sourceToken];
-                        return;
-                    }
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
+                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    else
+                        map.items.push({ start: [this.sourceToken] });
                 }
-            // fallthrough
+                else if (it.sep)
+                    it.sep.push(this.sourceToken);
+                else
+                    it.start.push(this.sourceToken);
+                return;
             case 'space':
             case 'comment':
                 if (it.value)
                     map.items.push({ start: [this.sourceToken] });
                 else if (it.sep)
                     it.sep.push(this.sourceToken);
-                else
+                else {
+                    if (this.atIndentedComment(it.start, map.indent)) {
+                        const prev = map.items[map.items.length - 2];
+                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            map.items.pop();
+                            return;
+                        }
+                    }
                     it.start.push(this.sourceToken);
+                }
                 return;
         }
         if (this.indent >= map.indent) {
@@ -628,22 +610,34 @@ class Parser {
         const it = seq.items[seq.items.length - 1];
         switch (this.type) {
             case 'newline':
-                if (!it.value && atFirstEmptyLineAfterComments(it.start)) {
-                    const prev = seq.items[seq.items.length - 2];
-                    const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
-                    if (Array.isArray(end)) {
-                        Array.prototype.push.apply(end, it.start);
-                        it.start = [this.sourceToken];
-                        return;
-                    }
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
+                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    else
+                        seq.items.push({ start: [this.sourceToken] });
                 }
-            // fallthrough
+                else
+                    it.start.push(this.sourceToken);
+                return;
             case 'space':
             case 'comment':
                 if (it.value)
                     seq.items.push({ start: [this.sourceToken] });
-                else
+                else {
+                    if (this.atIndentedComment(it.start, seq.indent)) {
+                        const prev = seq.items[seq.items.length - 2];
+                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            seq.items.pop();
+                            return;
+                        }
+                    }
                     it.start.push(this.sourceToken);
+                }
                 return;
             case 'anchor':
             case 'tag':
@@ -838,6 +832,13 @@ class Parser {
         }
         return null;
     }
+    atIndentedComment(start, indent) {
+        if (this.type !== 'comment')
+            return false;
+        if (this.indent <= indent)
+            return false;
+        return start.every(st => st.type === 'newline' || st.type === 'space');
+    }
     *documentEnd(docEnd) {
         if (this.type !== 'doc-mode') {
             if (docEnd.end)

package/dist/stringify/stringifyCollection.d.ts

@@ -1,5 +1,5 @@
 import { Collection } from '../nodes/Collection.js';
-import { StringifyContext } from '../stringify/stringify.js';
+import { StringifyContext } from './stringify.js';
 declare type StringifyNode = {
     comment: boolean;
     str: string;

package/dist/stringify/stringifyCollection.js

@@ -1,9 +1,9 @@
 'use strict';
 
 var Collection = require('../nodes/Collection.js');
-var addComment = require('./addComment.js');
-var stringify = require('./stringify.js');
 var Node = require('../nodes/Node.js');
+var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
 
 function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowChars, itemIndent, onChompKeep, onComment }) {
     const { indent, indentStep } = ctx;
@@ -18,10 +18,17 @@ function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowCha
         if (Node.isNode(item)) {
             if (!chompKeep && item.spaceBefore)
                 nodes.push({ comment: true, str: '' });
-            if (item.commentBefore) {
+            let cb = item.commentBefore;
+            if (cb && chompKeep)
+                cb = cb.replace(/^\n+/, '');
+            if (cb) {
+                if (/^\n+$/.test(cb))
+                    cb = cb.substring(1);
                 // This match will always succeed on a non-empty string
-                for (const line of item.commentBefore.match(/^.*$/gm))
-                    nodes.push({ comment: true, str: `#${line}` });
+                for (const line of cb.match(/^.*$/gm)) {
+                    const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                    nodes.push({ comment: true, str });
+                }
             }
             if (item.comment) {
                 comment = item.comment;
@@ -33,10 +40,17 @@ function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowCha
             if (ik) {
                 if (!chompKeep && ik.spaceBefore)
                     nodes.push({ comment: true, str: '' });
-                if (ik.commentBefore) {
+                let cb = ik.commentBefore;
+                if (cb && chompKeep)
+                    cb = cb.replace(/^\n+/, '');
+                if (cb) {
+                    if (/^\n+$/.test(cb))
+                        cb = cb.substring(1);
                     // This match will always succeed on a non-empty string
-                    for (const line of ik.commentBefore.match(/^.*$/gm))
-                        nodes.push({ comment: true, str: `#${line}` });
+                    for (const line of cb.match(/^.*$/gm)) {
+                        const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                        nodes.push({ comment: true, str });
+                    }
                 }
                 if (ik.comment)
                     singleLineOutput = false;
@@ -58,7 +72,7 @@ function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowCha
         let str = stringify.stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
         if (inFlow && i < items.length - 1)
             str += ',';
-        str = addComment.addComment(str, itemIndent, comment);
+        str = stringifyComment.addComment(str, itemIndent, comment);
         if (chompKeep && (comment || inFlow))
             chompKeep = false;
         nodes.push({ comment: false, str });
@@ -98,7 +112,7 @@ function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowCha
             str += s ? `\n${indent}${s}` : '\n';
     }
     if (comment) {
-        str += '\n' + comment.replace(/^/gm, `${indent}#`);
+        str += '\n' + stringifyComment.stringifyComment(comment, indent);
         if (onComment)
             onComment();
     }

package/dist/stringify/stringifyComment.d.ts

@@ -0,0 +1,2 @@
+export declare const stringifyComment: (comment: string, indent: string) => string;
+export declare function addComment(str: string, indent: string, comment?: string | null): string;

package/dist/stringify/{addComment.js → stringifyComment.js}

@@ -1,13 +1,17 @@
 'use strict';
 
+const stringifyComment = (comment, indent) => /^\n+$/.test(comment)
+    ? comment.substring(1)
+    : comment.replace(/^(?!$)(?: $)?/gm, `${indent}#`);
 function addComment(str, indent, comment) {
     return !comment
         ? str
         : comment.includes('\n')
-            ? `${str}\n` + comment.replace(/^/gm, `${indent || ''}#`)
+            ? `${str}\n` + stringifyComment(comment, indent)
             : str.endsWith(' ')
                 ? `${str}#${comment}`
                 : `${str} #${comment}`;
 }
 
 exports.addComment = addComment;
+exports.stringifyComment = stringifyComment;

package/dist/stringify/stringifyDocument.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var Node = require('../nodes/Node.js');
-var addComment = require('./addComment.js');
 var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
 
 function stringifyDocument(doc, options) {
     const lines = [];
@@ -21,7 +21,7 @@ function stringifyDocument(doc, options) {
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        lines.unshift(doc.commentBefore.replace(/^/gm, '#'));
+        lines.unshift(stringifyComment.stringifyComment(doc.commentBefore, ''));
     }
     const ctx = stringify.createStringifyContext(doc, options);
     let chompKeep = false;
@@ -31,7 +31,7 @@ function stringifyDocument(doc, options) {
             if (doc.contents.spaceBefore && hasDirectives)
                 lines.push('');
             if (doc.contents.commentBefore)
-                lines.push(doc.contents.commentBefore.replace(/^/gm, '#'));
+                lines.push(stringifyComment.stringifyComment(doc.contents.commentBefore, ''));
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
@@ -39,7 +39,7 @@ function stringifyDocument(doc, options) {
         const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
         let body = stringify.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
         if (contentComment)
-            body = addComment.addComment(body, '', contentComment);
+            body = stringifyComment.addComment(body, '', contentComment);
         if ((body[0] === '|' || body[0] === '>') &&
             lines[lines.length - 1] === '---') {
             // Top-level block scalars with a preceding doc marker ought to use the
@@ -52,10 +52,13 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(stringify.stringify(doc.contents, ctx));
     }
-    if (doc.comment) {
+    let dc = doc.comment;
+    if (dc && chompKeep)
+        dc = dc.replace(/^\n+/, '');
+    if (dc) {
         if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
             lines.push('');
-        lines.push(doc.comment.replace(/^/gm, '#'));
+        lines.push(stringifyComment.stringifyComment(dc, ''));
     }
     return lines.join('\n') + '\n';
 }

package/dist/stringify/stringifyPair.js

@@ -2,8 +2,8 @@
 
 var Node = require('../nodes/Node.js');
 var Scalar = require('../nodes/Scalar.js');
-var addComment = require('./addComment.js');
 var stringify = require('./stringify.js');
+var stringifyComment = require('./stringifyComment.js');
 
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
@@ -49,22 +49,20 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
             keyComment = null;
         if (chompKeep && !keyComment && onChompKeep)
             onChompKeep();
-        return addComment.addComment(`? ${str}`, ctx.indent, keyComment);
+        return stringifyComment.addComment(`? ${str}`, ctx.indent, keyComment);
     }
     if (keyCommentDone)
         keyComment = null;
     str = explicitKey
-        ? `? ${addComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
-        : addComment.addComment(`${str}:`, ctx.indent, keyComment);
+        ? `? ${stringifyComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
+        : stringifyComment.addComment(`${str}:`, ctx.indent, keyComment);
     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}`;
-        }
+        if (value.commentBefore)
+            vcb += `\n${stringifyComment.stringifyComment(value.commentBefore, ctx.indent)}`;
         valueComment = value.comment;
     }
     else if (value && typeof value === 'object') {
@@ -108,7 +106,7 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
             valueComment = null;
         if (chompKeep && !valueComment && onChompKeep)
             onChompKeep();
-        return addComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
+        return stringifyComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
     }
 }