yaml 2.0.0-4 → 2.0.0-8

package/dist/compose/compose-node.js

@@ -7,30 +7,36 @@ var resolveEnd = require('./resolve-end.js');
 var utilEmptyScalarPosition = require('./util-empty-scalar-position.js');
 
 const CN = { composeNode, composeEmptyNode };
-function composeNode(doc, token, props, onError) {
-    const { spaceBefore, comment, anchor, tagName } = props;
+function composeNode(ctx, token, props, onError) {
+    const { spaceBefore, comment, anchor, tag } = props;
     let node;
     switch (token.type) {
         case 'alias':
-            node = composeAlias(doc, token, onError);
-            if (anchor || tagName)
-                onError(token.offset, 'An alias node must not specify any properties');
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
             break;
         case 'scalar':
         case 'single-quoted-scalar':
         case 'double-quoted-scalar':
         case 'block-scalar':
-            node = composeScalar.composeScalar(doc, token, anchor, tagName, onError);
+            node = composeScalar.composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
             break;
         case 'block-map':
         case 'block-seq':
         case 'flow-collection':
-            node = composeCollection.composeCollection(CN, doc, token, anchor, tagName, onError);
+            node = composeCollection.composeCollection(CN, ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
             break;
         default:
             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) {
@@ -41,28 +47,32 @@ function composeNode(doc, token, props, onError) {
     }
     return node;
 }
-function composeEmptyNode(doc, offset, before, pos, { spaceBefore, comment, anchor, tagName }, onError) {
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
     const token = {
         type: 'scalar',
         offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
         indent: -1,
         source: ''
     };
-    const node = composeScalar.composeScalar(doc, token, anchor, tagName, onError);
+    const node = composeScalar.composeScalar(ctx, token, tag, onError);
+    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)
         node.comment = comment;
     return node;
 }
-function composeAlias(doc, { offset, source, end }, onError) {
-    const name = source.substring(1);
-    const src = doc.anchors.getNode(name);
-    if (!src)
-        onError(offset, `Aliased anchor not found: ${name}`);
-    const alias = new Alias.Alias(src);
-    const re = resolveEnd.resolveEnd(end, offset + source.length, doc.options.strict, onError);
-    alias.range = [offset, re.offset];
+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];
     if (re.comment)
         alias.comment = re.comment;
     return alias;

package/dist/compose/compose-scalar.d.ts

@@ -1,4 +1,5 @@
-import type { Document } from '../doc/Document.js';
 import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar, FlowScalar } from '../parse/tokens.js';
-export declare function composeScalar(doc: Document.Parsed, token: FlowScalar | BlockScalar, anchor: string | null, tagName: string | null, onError: (offset: number, message: string) => void): Scalar.Parsed;
+import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst.js';
+import type { ComposeContext } from './compose-node.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function composeScalar(ctx: ComposeContext, token: FlowScalar | BlockScalar, tagToken: SourceToken | null, onError: ComposeErrorHandler): Scalar.Parsed;

package/dist/compose/compose-scalar.js

@@ -5,44 +5,42 @@ var Scalar = require('../nodes/Scalar.js');
 var resolveBlockScalar = require('./resolve-block-scalar.js');
 var resolveFlowScalar = require('./resolve-flow-scalar.js');
 
-function composeScalar(doc, token, anchor, tagName, onError) {
-    const { offset } = token;
-    const { value, type, comment, length } = token.type === 'block-scalar'
-        ? resolveBlockScalar.resolveBlockScalar(token, doc.options.strict, onError)
-        : resolveFlowScalar.resolveFlowScalar(token, doc.options.strict, onError);
-    const tag = tagName
-        ? findScalarTagByName(doc.schema, value, tagName, onError)
-        : findScalarTagByTest(doc.schema, value, token.type === 'scalar');
+function composeScalar(ctx, token, tagToken, onError) {
+    const { value, type, comment, range } = token.type === 'block-scalar'
+        ? resolveBlockScalar.resolveBlockScalar(token, ctx.options.strict, onError)
+        : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+    const tagName = tagToken
+        ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
+        : null;
+    const tag = tagToken && tagName
+        ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
+        : findScalarTagByTest(ctx.schema, value, token.type === 'scalar');
     let scalar;
     try {
-        const res = tag
-            ? tag.resolve(value, msg => onError(offset, msg), doc.options)
-            : value;
+        const res = tag.resolve(value, msg => onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
         scalar = Node.isScalar(res) ? res : new Scalar.Scalar(res);
     }
     catch (error) {
-        onError(offset, 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 = [offset, offset + length];
+    scalar.range = range;
     scalar.source = value;
     if (type)
         scalar.type = type;
     if (tagName)
         scalar.tag = tagName;
-    if (tag === null || tag === void 0 ? void 0 : tag.format)
+    if (tag.format)
         scalar.format = tag.format;
     if (comment)
         scalar.comment = comment;
-    if (anchor)
-        doc.anchors.setAnchor(scalar, anchor);
     return scalar;
 }
-const defaultScalarTag = (schema) => schema.tags.find(tag => !tag.collection && tag.tag === 'tag:yaml.org,2002:str');
-function findScalarTagByName(schema, value, tagName, onError) {
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     var _a;
     if (tagName === '!')
-        return defaultScalarTag(schema); // non-specific tag
+        return schema[Node.SCALAR]; // non-specific tag
     const matchWithTest = [];
     for (const tag of schema.tags) {
         if (!tag.collection && tag.tag === tagName) {
@@ -62,8 +60,8 @@ function findScalarTagByName(schema, value, tagName, onError) {
         schema.tags.push(Object.assign({}, kt, { default: false, test: undefined }));
         return kt;
     }
-    onError(0, `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
-    return defaultScalarTag(schema);
+    onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
+    return schema[Node.SCALAR];
 }
 function findScalarTagByTest(schema, value, apply) {
     var _a;
@@ -73,7 +71,7 @@ function findScalarTagByTest(schema, value, apply) {
                 return tag;
         }
     }
-    return defaultScalarTag(schema);
+    return schema[Node.SCALAR];
 }
 
 exports.composeScalar = composeScalar;

package/dist/compose/composer.d.ts

@@ -1,29 +1,34 @@
 import { Directives } from '../doc/directives.js';
-import { YAMLParseError, YAMLWarning } from '../errors.js';
-import { Options } from '../options.js';
-import type { Token } from '../parse/tokens.js';
+import { Document } from '../doc/Document.js';
+import { ErrorCode, YAMLParseError, YAMLWarning } from '../errors.js';
+import { Range } from '../nodes/Node.js';
+import { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
+import type { Token } from '../parse/cst.js';
+declare type ErrorSource = number | [number, number] | Range | {
+    offset: number;
+    source?: string;
+};
+export declare type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode, message: string, warning?: boolean) => void;
 /**
  * Compose a stream of CST nodes into a stream of YAML Documents.
  *
  * ```ts
- * const options: Options = { ... }
- * const docs: Document.Parsed[] = []
- * const composer = new Composer(doc => docs.push(doc), options)
- * const parser = new Parser(composer.next)
- * parser.parse(source)
- * composer.end()
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
  * ```
  */
 export declare class Composer {
     private directives;
     private doc;
-    private onDocument;
     private options;
     private atDirectives;
     private prelude;
     private errors;
     private warnings;
-    constructor(onDocument: Composer['onDocument'], options?: Options);
+    constructor(options?: ParseOptions & DocumentOptions & SchemaOptions);
     private onError;
     private decorate;
     /**
@@ -38,20 +43,20 @@ export declare class Composer {
         warnings: YAMLWarning[];
     };
     /**
-     * Advance the composed by one CST token. Bound to the Composer
-     * instance, so may be used directly as a callback function.
+     * Compose tokens into documents.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
      */
-    next: (token: Token) => void;
-    /** Call at end of input to push out any remaining document. */
-    end(): void;
+    compose(tokens: Iterable<Token>, forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
+    /** Advance the composer by one CST token. */
+    next(token: Token): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
     /**
-     * Call at end of input to push out any remaining document.
+     * Call at end of input to yield any remaining document.
      *
-     * @param forceDoc - If the stream contains no document, still emit a final
-     *   document including any comments and directives that would be applied
-     *   to a subsequent document.
-     * @param offset - Should be set if `forceDoc` is also set, to set the
-     *   document range end and to indicate errors correctly.
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
      */
-    end(forceDoc: true, offset: number): void;
+    end(forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
 }
+export {};

package/dist/compose/composer.js

@@ -8,7 +8,16 @@ var options = require('../options.js');
 var composeDoc = require('./compose-doc.js');
 var resolveEnd = require('./resolve-end.js');
 
+function getErrorPos(src) {
+    if (typeof src === 'number')
+        return [src, src + 1];
+    if (Array.isArray(src))
+        return src.length === 2 ? src : [src[0], src[1]];
+    const { offset, source } = src;
+    return [offset, offset + (typeof source === 'string' ? source.length : 1)];
+}
 function parsePrelude(prelude) {
+    var _a;
     let comment = '';
     let atComment = false;
     let afterEmptyLine = false;
@@ -18,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;
@@ -40,90 +49,30 @@ function parsePrelude(prelude) {
  * Compose a stream of CST nodes into a stream of YAML Documents.
  *
  * ```ts
- * const options: Options = { ... }
- * const docs: Document.Parsed[] = []
- * const composer = new Composer(doc => docs.push(doc), options)
- * const parser = new Parser(composer.next)
- * parser.parse(source)
- * composer.end()
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
  * ```
  */
 class Composer {
-    constructor(onDocument, options$1 = {}) {
+    constructor(options$1 = {}) {
         this.doc = null;
         this.atDirectives = false;
         this.prelude = [];
         this.errors = [];
         this.warnings = [];
-        this.onError = (offset, message, warning) => {
+        this.onError = (source, code, message, warning) => {
+            const pos = getErrorPos(source);
             if (warning)
-                this.warnings.push(new errors.YAMLWarning(offset, message));
+                this.warnings.push(new errors.YAMLWarning(pos, code, message));
             else
-                this.errors.push(new errors.YAMLParseError(offset, message));
-        };
-        /**
-         * Advance the composed by one CST token. Bound to the Composer
-         * instance, so may be used directly as a callback function.
-         */
-        this.next = (token) => {
-            if (process.env.LOG_STREAM)
-                console.dir(token, { depth: null });
-            switch (token.type) {
-                case 'directive':
-                    this.directives.add(token.source, this.onError);
-                    this.prelude.push(token.source);
-                    this.atDirectives = true;
-                    break;
-                case 'document': {
-                    const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError);
-                    this.decorate(doc, false);
-                    if (this.doc)
-                        this.onDocument(this.doc);
-                    this.doc = doc;
-                    this.atDirectives = false;
-                    break;
-                }
-                case 'byte-order-mark':
-                case 'space':
-                    break;
-                case 'comment':
-                case 'newline':
-                    this.prelude.push(token.source);
-                    break;
-                case 'error': {
-                    const msg = token.source
-                        ? `${token.message}: ${JSON.stringify(token.source)}`
-                        : token.message;
-                    const error = new errors.YAMLParseError(-1, msg);
-                    if (this.atDirectives || !this.doc)
-                        this.errors.push(error);
-                    else
-                        this.doc.errors.push(error);
-                    break;
-                }
-                case 'doc-end': {
-                    if (!this.doc) {
-                        const msg = 'Unexpected doc-end without preceding document';
-                        this.errors.push(new errors.YAMLParseError(token.offset, msg));
-                        break;
-                    }
-                    const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
-                    this.decorate(this.doc, true);
-                    if (end.comment) {
-                        const dc = this.doc.comment;
-                        this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
-                    }
-                    this.doc.range[1] = end.offset;
-                    break;
-                }
-                default:
-                    this.errors.push(new errors.YAMLParseError(-1, `Unsupported token ${token.type}`));
-            }
+                this.errors.push(new errors.YAMLParseError(pos, code, message));
         };
         this.directives = new directives.Directives({
-            version: (options$1 === null || options$1 === void 0 ? void 0 : options$1.version) || options.defaultOptions.version
+            version: options$1.version || options.defaultOptions.version
         });
-        this.onDocument = onDocument;
         this.options = options$1;
     }
     decorate(doc, afterDoc) {
@@ -138,7 +87,9 @@ class Composer {
                 doc.commentBefore = comment;
             }
             else if (Node.isCollection(dc) && !dc.flow && dc.items.length > 0) {
-                const it = dc.items[0];
+                let it = dc.items[0];
+                if (Node.isPair(it))
+                    it = it.key;
                 const cb = it.commentBefore;
                 it.commentBefore = cb ? `${comment}\n${cb}` : comment;
             }
@@ -172,20 +123,99 @@ class Composer {
             warnings: this.warnings
         };
     }
-    end(forceDoc = false, offset = -1) {
+    /**
+     * Compose tokens into documents.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *compose(tokens, forceDoc = false, endOffset = -1) {
+        for (const token of tokens)
+            yield* this.next(token);
+        yield* this.end(forceDoc, endOffset);
+    }
+    /** Advance the composer by one CST token. */
+    *next(token) {
+        if (process.env.LOG_STREAM)
+            console.dir(token, { depth: null });
+        switch (token.type) {
+            case 'directive':
+                this.directives.add(token.source, (offset, message, warning) => {
+                    const pos = getErrorPos(token);
+                    pos[0] += offset;
+                    this.onError(pos, 'BAD_DIRECTIVE', message, warning);
+                });
+                this.prelude.push(token.source);
+                this.atDirectives = true;
+                break;
+            case 'document': {
+                const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError);
+                if (this.atDirectives && !doc.directives.marker)
+                    this.onError(token, 'MISSING_CHAR', 'Missing directives-end indicator line');
+                this.decorate(doc, false);
+                if (this.doc)
+                    yield this.doc;
+                this.doc = doc;
+                this.atDirectives = false;
+                break;
+            }
+            case 'byte-order-mark':
+            case 'space':
+                break;
+            case 'comment':
+            case 'newline':
+                this.prelude.push(token.source);
+                break;
+            case 'error': {
+                const msg = token.source
+                    ? `${token.message}: ${JSON.stringify(token.source)}`
+                    : token.message;
+                const error = new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg);
+                if (this.atDirectives || !this.doc)
+                    this.errors.push(error);
+                else
+                    this.doc.errors.push(error);
+                break;
+            }
+            case 'doc-end': {
+                if (!this.doc) {
+                    const msg = 'Unexpected doc-end without preceding document';
+                    this.errors.push(new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
+                    break;
+                }
+                const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+                this.decorate(this.doc, true);
+                if (end.comment) {
+                    const dc = this.doc.comment;
+                    this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
+                }
+                this.doc.range[2] = end.offset;
+                break;
+            }
+            default:
+                this.errors.push(new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`));
+        }
+    }
+    /**
+     * Call at end of input to yield any remaining document.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *end(forceDoc = false, endOffset = -1) {
         if (this.doc) {
             this.decorate(this.doc, true);
-            this.onDocument(this.doc);
+            yield this.doc;
             this.doc = null;
         }
         else if (forceDoc) {
             const opts = Object.assign({ directives: this.directives }, this.options);
             const doc = new Document.Document(undefined, opts);
             if (this.atDirectives)
-                this.onError(offset, 'Missing directives-end indicator line');
-            doc.range = [0, offset];
+                this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line');
+            doc.range = [0, endOffset, endOffset];
             this.decorate(doc, false);
-            this.onDocument(doc);
+            yield doc;
         }
     }
 }

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

@@ -1,5 +1,6 @@
-import type { Document } from '../doc/Document.js';
+import type { ParsedNode } from '../nodes/Node.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
-import type { BlockMap } from '../parse/tokens.js';
-import type { ComposeNode } from './compose-node.js';
-export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, doc: Document.Parsed, { indent, items, offset }: BlockMap, anchor: string | null, onError: (offset: number, message: string, warning?: boolean) => void): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null>;
+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<ParsedNode, ParsedNode | null>;

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

@@ -4,26 +4,31 @@ 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 }, doc, { indent, items, offset }, anchor, onError) {
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
-    const start = offset;
-    const map = new YAMLMap.YAMLMap(doc.schema);
-    if (anchor)
-        doc.anchors.setAnchor(map, anchor);
-    for (const { start, key, sep, value } of items) {
+    const map = new YAMLMap.YAMLMap(ctx.schema);
+    let offset = bm.offset;
+    for (const { start, key, sep, value } of bm.items) {
         // key properties
-        const keyProps = resolveProps.resolveProps(doc, start, true, 'explicit-key-ind', offset, onError);
+        const keyProps = resolveProps.resolveProps(start, {
+            indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            offset,
+            onError,
+            startOnNewline: true
+        });
         const implicitKey = !keyProps.found;
         if (implicitKey) {
             if (key) {
                 if (key.type === 'block-seq')
-                    onError(offset, 'A block sequence may not be used as an implicit map key');
-                else if ('indent' in key && key.indent !== indent)
-                    onError(offset, startColMsg);
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'A block sequence may not be used as an implicit map key');
+                else if ('indent' in key && key.indent !== bm.indent)
+                    onError(offset, 'BAD_INDENT', startColMsg);
             }
-            if (!keyProps.anchor && !keyProps.tagName && !sep) {
+            if (!keyProps.anchor && !keyProps.tag && !sep) {
                 // TODO: assert being at last item?
                 if (keyProps.comment) {
                     if (map.comment)
@@ -34,39 +39,46 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items
                 continue;
             }
         }
-        else if (((_a = keyProps.found) === null || _a === void 0 ? void 0 : _a.indent) !== indent)
-            onError(offset, startColMsg);
-        offset += keyProps.length;
+        else if (((_a = keyProps.found) === null || _a === void 0 ? void 0 : _a.indent) !== bm.indent)
+            onError(offset, 'BAD_INDENT', startColMsg);
         if (implicitKey && utilContainsNewline.containsNewline(key))
-            onError(offset, 'Implicit keys need to be on a single line');
+            onError(key, // checked by containsNewline()
+            'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
         // key value
-        const keyStart = offset;
+        const keyStart = keyProps.end;
         const keyNode = key
-            ? composeNode(doc, key, keyProps, onError)
-            : composeEmptyNode(doc, offset, start, null, keyProps, onError);
-        offset = keyNode.range[1];
+            ? 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(doc, sep || [], !key || key.type === 'block-scalar', 'map-value-ind', offset, onError);
-        offset += valueProps.length;
+        const valueProps = resolveProps.resolveProps(sep || [], {
+            indicator: 'map-value-ind',
+            next: value,
+            offset: keyNode.range[2],
+            onError,
+            startOnNewline: !key || key.type === 'block-scalar'
+        });
+        offset = valueProps.end;
         if (valueProps.found) {
             if (implicitKey) {
                 if ((value === null || value === void 0 ? void 0 : value.type) === 'block-map' && !valueProps.hasNewline)
-                    onError(offset, 'Nested mappings are not allowed in compact mappings');
-                if (doc.options.strict &&
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings');
+                if (ctx.options.strict &&
                     keyProps.start < valueProps.found.offset - 1024)
-                    onError(offset, 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
+                    onError(keyNode.range, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
             }
             // value value
             const valueNode = value
-                ? composeNode(doc, value, valueProps, onError)
-                : composeEmptyNode(doc, offset, sep, null, valueProps, onError);
-            offset = valueNode.range[1];
+                ? composeNode(ctx, value, valueProps, onError)
+                : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+            offset = valueNode.range[2];
             map.items.push(new Pair.Pair(keyNode, valueNode));
         }
         else {
             // key with no value
             if (implicitKey)
-                onError(keyStart, 'Implicit map keys need to be followed by map values');
+                onError(keyNode.range, 'MISSING_CHAR', 'Implicit map keys need to be followed by map values');
             if (valueProps.comment) {
                 if (keyNode.comment)
                     keyNode.comment += '\n' + valueProps.comment;
@@ -76,7 +88,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items
             map.items.push(new Pair.Pair(keyNode));
         }
     }
-    map.range = [start, offset];
+    map.range = [bm.offset, offset, offset];
     return map;
 }
 

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

@@ -1,8 +1,10 @@
+import { Range } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar } from '../parse/tokens.js';
-export declare function resolveBlockScalar(scalar: BlockScalar, strict: boolean, onError: (offset: number, message: string) => void): {
+import type { BlockScalar } from '../parse/cst.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function resolveBlockScalar(scalar: BlockScalar, strict: boolean, onError: ComposeErrorHandler): {
     value: string;
     type: Scalar.BLOCK_FOLDED | Scalar.BLOCK_LITERAL | null;
     comment: string;
-    length: number;
+    range: Range;
 };