yaml 2.0.0-5 → 2.0.0-9

package/browser/dist/parse/parser.js

@@ -20,38 +20,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':
@@ -502,24 +470,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) {
@@ -624,22 +606,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':
@@ -834,6 +828,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/browser/dist/schema/Schema.js

@@ -18,6 +18,11 @@ class Schema {
         this.sortMapEntries =
             sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
     }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
+    }
 }
 
 export { Schema };

package/browser/dist/schema/tags.js

@@ -50,11 +50,15 @@ const coreKnownTags = {
 function getTags(customTags, schemaName) {
     let tags = schemas[schemaName];
     if (!tags) {
-        const keys = Object.keys(schemas)
-            .filter(key => key !== 'yaml11')
-            .map(key => JSON.stringify(key))
-            .join(', ');
-        throw new Error(`Unknown schema "${schemaName}"; use one of ${keys}`);
+        if (Array.isArray(customTags))
+            tags = [];
+        else {
+            const keys = Object.keys(schemas)
+                .filter(key => key !== 'yaml11')
+                .map(key => JSON.stringify(key))
+                .join(', ');
+            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+        }
     }
     if (Array.isArray(customTags)) {
         for (const tag of customTags)

package/browser/dist/stringify/stringify.js

@@ -8,6 +8,7 @@ const createStringifyContext = (doc, options) => ({
     indent: '',
     indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
     options: Object.assign({
+        blockQuote: true,
         defaultKeyType: null,
         defaultStringType: 'PLAIN',
         directives: null,
@@ -19,7 +20,7 @@ const createStringifyContext = (doc, options) => ({
         minContentWidth: 20,
         nullStr: 'null',
         simpleKeys: false,
-        singleQuote: false,
+        singleQuote: null,
         trueStr: 'true',
         verifyAliasOrder: true
     }, options)

package/browser/dist/stringify/stringifyCollection.js

@@ -1,7 +1,7 @@
 import { Collection } from '../nodes/Collection.js';
-import { addComment } from './addComment.js';
-import { stringify } from './stringify.js';
 import { isNode, isPair } from '../nodes/Node.js';
+import { stringify } from './stringify.js';
+import { addComment, stringifyComment } from './stringifyComment.js';
 
 function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowChars, itemIndent, onChompKeep, onComment }) {
     const { indent, indentStep } = ctx;
@@ -16,10 +16,17 @@ function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowCha
         if (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;
@@ -31,10 +38,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;
@@ -96,7 +110,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(comment, indent);
         if (onComment)
             onComment();
     }

package/browser/dist/stringify/stringifyComment.js

@@ -0,0 +1,14 @@
+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` + stringifyComment(comment, indent)
+            : str.endsWith(' ')
+                ? `${str}#${comment}`
+                : `${str} #${comment}`;
+}
+
+export { addComment, stringifyComment };

package/browser/dist/stringify/stringifyDocument.js

@@ -1,6 +1,6 @@
 import { isNode } from '../nodes/Node.js';
-import { addComment } from './addComment.js';
 import { createStringifyContext, stringify } from './stringify.js';
+import { stringifyComment, addComment } from './stringifyComment.js';
 
 function stringifyDocument(doc, options) {
     const lines = [];
@@ -19,7 +19,7 @@ function stringifyDocument(doc, options) {
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        lines.unshift(doc.commentBefore.replace(/^/gm, '#'));
+        lines.unshift(stringifyComment(doc.commentBefore, ''));
     }
     const ctx = createStringifyContext(doc, options);
     let chompKeep = false;
@@ -29,7 +29,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(doc.contents.commentBefore, ''));
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
@@ -50,10 +50,13 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(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(dc, ''));
     }
     return lines.join('\n') + '\n';
 }

package/browser/dist/stringify/stringifyPair.js

@@ -1,7 +1,7 @@
 import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
-import { addComment } from './addComment.js';
 import { stringify } from './stringify.js';
+import { addComment, stringifyComment } from './stringifyComment.js';
 
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
@@ -59,10 +59,8 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     if (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(value.commentBefore, ctx.indent)}`;
         valueComment = value.comment;
     }
     else if (value && typeof value === 'object') {
@@ -87,14 +85,14 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
     let ws = ' ';
     if (vcb || keyComment) {
-        ws = `${vcb}\n${ctx.indent}`;
+        ws = valueStr === '' && !ctx.inFlow ? vcb : `${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')
+    else if (valueStr === '' || valueStr[0] === '\n')
         ws = '';
     if (ctx.inFlow) {
         if (valueCommentDone && onComment)

package/browser/dist/stringify/stringifyString.js

@@ -118,34 +118,50 @@ function doubleQuotedString(value, ctx) {
         : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
 }
 function singleQuotedString(value, ctx) {
-    if (ctx.implicitKey) {
-        if (/\n/.test(value))
-            return doubleQuotedString(value, ctx);
-    }
-    else {
-        // single quoted string can't have leading or trailing whitespace around newline
-        if (/[ \t]\n|\n[ \t]/.test(value))
-            return doubleQuotedString(value, ctx);
-    }
+    if (ctx.options.singleQuote === false ||
+        (ctx.implicitKey && value.includes('\n')) ||
+        /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline
+    )
+        return doubleQuotedString(value, ctx);
     const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
     const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
     return ctx.implicitKey
         ? res
         : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
 }
+function quotedString(value, ctx) {
+    const { singleQuote } = ctx.options;
+    let qs;
+    if (singleQuote === false)
+        qs = doubleQuotedString;
+    else {
+        const hasDouble = value.includes('"');
+        const hasSingle = value.includes("'");
+        if (hasDouble && !hasSingle)
+            qs = singleQuotedString;
+        else if (hasSingle && !hasDouble)
+            qs = doubleQuotedString;
+        else
+            qs = singleQuote ? singleQuotedString : doubleQuotedString;
+    }
+    return qs(value, ctx);
+}
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+    const { lineWidth, blockQuote } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
     // 2. Strings consisting of only whitespace are best rendered explicitly.
-    if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
-        return doubleQuotedString(value, ctx);
+    if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
+        return quotedString(value, ctx);
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const literal = type === Scalar.BLOCK_FOLDED
-        ? false
-        : type === Scalar.BLOCK_LITERAL
-            ? true
-            : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
+    const literal = blockQuote === 'literal'
+        ? true
+        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED
+            ? false
+            : type === Scalar.BLOCK_LITERAL
+                ? true
+                : !lineLengthOverLimit(value, lineWidth, indent.length);
     if (!value)
         return literal ? '|\n' : '>\n';
     // determine chomping from whitespace at value end
@@ -218,25 +234,10 @@ function plainString(item, ctx, onComment, onChompKeep) {
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
-        return doubleQuotedString(value, ctx);
+        return quotedString(value, ctx);
     }
     if (!value ||
         /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
-        const hasDouble = value.indexOf('"') !== -1;
-        const hasSingle = value.indexOf("'") !== -1;
-        let quotedString;
-        if (hasDouble && !hasSingle) {
-            quotedString = singleQuotedString;
-        }
-        else if (hasSingle && !hasDouble) {
-            quotedString = doubleQuotedString;
-        }
-        else if (ctx.options.singleQuote) {
-            quotedString = singleQuotedString;
-        }
-        else {
-            quotedString = doubleQuotedString;
-        }
         // not allowed:
         // - empty string, '-' or '?'
         // - start with an indicator character (except [?:-]) or /[?-] /
@@ -267,7 +268,7 @@ function plainString(item, ctx, onComment, onChompKeep) {
             if (tag.default &&
                 tag.tag !== 'tag:yaml.org,2002:str' &&
                 ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)))
-                return doubleQuotedString(value, ctx);
+                return quotedString(value, ctx);
         }
     }
     return implicitKey
@@ -290,7 +291,7 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
             case Scalar.BLOCK_FOLDED:
             case Scalar.BLOCK_LITERAL:
                 return implicitKey || inFlow
-                    ? doubleQuotedString(ss.value, ctx) // blocks are not valid inside flow containers
+                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
                     : blockString(ss, ctx, onComment, onChompKeep);
             case Scalar.QUOTE_DOUBLE:
                 return doubleQuotedString(ss.value, ctx);

package/browser/dist/util.js

@@ -1,6 +1,9 @@
 export { debug, warn } from './log.js';
 export { findPair } from './nodes/YAMLMap.js';
 export { toJS } from './nodes/toJS.js';
+export { map as mapTag } from './schema/common/map.js';
+export { seq as seqTag } from './schema/common/seq.js';
+export { string as stringTag } from './schema/common/string.js';
 export { foldFlowLines } from './stringify/foldFlowLines.js';
 export { stringifyNumber } from './stringify/stringifyNumber.js';
 export { stringifyString } from './stringify/stringifyString.js';

package/dist/compose/compose-doc.js

@@ -14,8 +14,8 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
         schema: doc.schema
     };
     const props = resolveProps.resolveProps(start, {
-        ctx,
         indicator: 'doc-start',
+        next: value || (end === null || end === void 0 ? void 0 : end[0]),
         offset,
         onError,
         startOnNewline: true

package/dist/compose/compose-node.js

@@ -35,6 +35,8 @@ function composeNode(ctx, token, props, onError) {
             console.log(token);
             throw new Error(`Unsupporten token type: ${token.type}`);
     }
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment) {
@@ -43,6 +45,8 @@ function composeNode(ctx, token, props, onError) {
         else
             node.commentBefore = comment;
     }
+    if (ctx.options.keepSourceTokens)
+        node.srcToken = token;
     return node;
 }
 function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
@@ -53,8 +57,11 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
         source: ''
     };
     const node = composeScalar.composeScalar(ctx, token, tag, onError);
-    if (anchor)
+    if (anchor) {
         node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment)
@@ -63,6 +70,8 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
     const alias = new Alias.Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
     const valueEnd = offset + source.length;
     const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];

package/dist/compose/compose-scalar.js

@@ -21,7 +21,8 @@ function composeScalar(ctx, token, tagToken, onError) {
         scalar = Node.isScalar(res) ? res : new Scalar.Scalar(res);
     }
     catch (error) {
-        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg);
         scalar = new Scalar.Scalar(value);
     }
     scalar.range = range;

package/dist/compose/composer.js

@@ -17,6 +17,7 @@ function getErrorPos(src) {
     return [offset, offset + (typeof source === 'string' ? source.length : 1)];
 }
 function parsePrelude(prelude) {
+    var _a;
     let comment = '';
     let atComment = false;
     let afterEmptyLine = false;
@@ -26,12 +27,12 @@ function parsePrelude(prelude) {
             case '#':
                 comment +=
                     (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
-                        source.substring(1);
+                        (source.substring(1) || ' ');
                 atComment = true;
                 afterEmptyLine = false;
                 break;
             case '%':
-                if (prelude[i + 1][0] !== '#')
+                if (((_a = prelude[i + 1]) === null || _a === void 0 ? void 0 : _a[0]) !== '#')
                     i += 1;
                 atComment = false;
                 break;

package/dist/compose/resolve-block-map.d.ts

@@ -1,5 +1,6 @@
+import type { ParsedNode } from '../nodes/Node.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import type { BlockMap } from '../parse/cst.js';
 import type { ComposeContext, ComposeNode } from './compose-node.js';
 import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null>;
+export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;

package/dist/compose/resolve-block-map.js

@@ -4,17 +4,19 @@ var Pair = require('../nodes/Pair.js');
 var YAMLMap = require('../nodes/YAMLMap.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
+var utilMapIncludes = require('./util-map-includes.js');
 
 const startColMsg = 'All mapping items must start at the same column';
 function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
     const map = new YAMLMap.YAMLMap(ctx.schema);
     let offset = bm.offset;
-    for (const { start, key, sep, value } of bm.items) {
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
         // key properties
         const keyProps = resolveProps.resolveProps(start, {
-            ctx,
             indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: true
@@ -48,10 +50,12 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
         const keyNode = key
             ? composeNode(ctx, key, keyProps, onError)
             : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+        if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
+            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
         const valueProps = resolveProps.resolveProps(sep || [], {
-            ctx,
             indicator: 'map-value-ind',
+            next: value,
             offset: keyNode.range[2],
             onError,
             startOnNewline: !key || key.type === 'block-scalar'
@@ -70,7 +74,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
             offset = valueNode.range[2];
-            map.items.push(new Pair.Pair(keyNode, valueNode));
+            const pair = new Pair.Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
         else {
             // key with no value
@@ -82,7 +89,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            map.items.push(new Pair.Pair(keyNode));
+            const pair = new Pair.Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
     }
     map.range = [bm.offset, offset, offset];

package/dist/compose/resolve-block-scalar.js

@@ -20,7 +20,7 @@ function resolveBlockScalar(scalar, strict, onError) {
     }
     // shortcut for empty contents
     if (!scalar.source || chompStart === 0) {
-        const value = header.chomp === '+' ? lines.map(line => line[0]).join('\n') : '';
+        const value = header.chomp === '+' ? '\n'.repeat(Math.max(0, lines.length - 1)) : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -151,7 +151,7 @@ function parseBlockScalarHeader({ offset, props }, strict, onError) {
             case 'comment':
                 if (strict && !hasSpace) {
                     const message = 'Comments must be separated from other tokens by white space characters';
-                    onError(token, 'COMMENT_SPACE', message);
+                    onError(token, 'MISSING_CHAR', message);
                 }
                 length += token.source.length;
                 comment = token.source.substring(1);