yaml 2.0.0-4 → 2.0.0-5

package/README.md

@@ -19,7 +19,7 @@ For more information, see the project's documentation site: [**eemeli.org/yaml**
 To install:
 
 ```sh
-npm install yaml@next
+npm install --save-exact yaml@next
 ```
 
 **Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
@@ -67,16 +67,16 @@ const YAML = require('yaml')
 - [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
 - [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
 - [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
-- [`doc.anchors.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#working-with-anchors)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#working-with-anchors)
 - [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
 - [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
 - [`visit(node, visitor)`](https://eemeli.org/yaml/#modifying-nodes)
 
 ### Parsing YAML
 
-- [`new Lexer(push)`](https://eemeli.org/yaml/#lexer)
-- [`new Parser(push, onNewLine?)`](https://eemeli.org/yaml/#parser)
-- [`new Composer(push, options?)`](https://eemeli.org/yaml/#composer)
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
 
 ## YAML.parse
 

package/browser/dist/compose/compose-collection.js

@@ -4,22 +4,25 @@ import { resolveBlockMap } from './resolve-block-map.js';
 import { resolveBlockSeq } from './resolve-block-seq.js';
 import { resolveFlowCollection } from './resolve-flow-collection.js';
 
-function composeCollection(CN, doc, token, anchor, tagName, onError) {
+function composeCollection(CN, ctx, token, tagToken, onError) {
     let coll;
     switch (token.type) {
         case 'block-map': {
-            coll = resolveBlockMap(CN, doc, token, anchor, onError);
+            coll = resolveBlockMap(CN, ctx, token, onError);
             break;
         }
         case 'block-seq': {
-            coll = resolveBlockSeq(CN, doc, token, anchor, onError);
+            coll = resolveBlockSeq(CN, ctx, token, onError);
             break;
         }
         case 'flow-collection': {
-            coll = resolveFlowCollection(CN, doc, token, anchor, onError);
+            coll = resolveFlowCollection(CN, ctx, token, onError);
             break;
         }
     }
+    if (!tagToken)
+        return coll;
+    const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
     if (!tagName)
         return coll;
     // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
@@ -29,20 +32,20 @@ function composeCollection(CN, doc, token, anchor, tagName, onError) {
         return coll;
     }
     const expType = isMap(coll) ? 'map' : 'seq';
-    let tag = doc.schema.tags.find(t => t.collection === expType && t.tag === tagName);
+    let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
     if (!tag) {
-        const kt = doc.schema.knownTags[tagName];
+        const kt = ctx.schema.knownTags[tagName];
         if (kt && kt.collection === expType) {
-            doc.schema.tags.push(Object.assign({}, kt, { default: false }));
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
             tag = kt;
         }
         else {
-            onError(coll.range[0], `Unresolved tag: ${tagName}`, true);
+            onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
             coll.tag = tagName;
             return coll;
         }
     }
-    const res = tag.resolve(coll, msg => onError(coll.range[0], msg), doc.options);
+    const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
     const node = isNode(res)
         ? res
         : new Scalar(res);

package/browser/dist/compose/compose-doc.js

@@ -6,16 +6,33 @@ import { resolveProps } from './resolve-props.js';
 function composeDoc(options, directives, { offset, start, value, end }, onError) {
     const opts = Object.assign({ directives }, options);
     const doc = new Document(undefined, opts);
-    const props = resolveProps(doc, start, true, 'doc-start', offset, onError);
-    if (props.found)
+    const ctx = {
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        ctx,
+        indicator: 'doc-start',
+        offset,
+        onError,
+        startOnNewline: true
+    });
+    if (props.found) {
         doc.directives.marker = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
     doc.contents = value
-        ? composeNode(doc, value, props, onError)
-        : composeEmptyNode(doc, offset + props.length, start, null, props, onError);
-    const re = resolveEnd(end, doc.contents.range[1], false, onError);
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
     if (re.comment)
         doc.comment = re.comment;
-    doc.range = [offset, re.offset];
+    doc.range = [offset, contentEnd, re.offset];
     return doc;
 }
 

package/browser/dist/compose/compose-node.js

@@ -5,25 +5,29 @@ import { resolveEnd } from './resolve-end.js';
 import { emptyScalarPosition } from './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(doc, token, anchor, tagName, onError);
+            node = 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(CN, doc, token, anchor, tagName, onError);
+            node = composeCollection(CN, ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
             break;
         default:
             console.log(token);
@@ -39,28 +43,27 @@ 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: emptyScalarPosition(offset, before, pos),
         indent: -1,
         source: ''
     };
-    const node = composeScalar(doc, token, anchor, tagName, onError);
+    const node = composeScalar(ctx, token, tag, onError);
+    if (anchor)
+        node.anchor = anchor.source.substring(1);
     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(src);
-    const re = 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(source.substring(1));
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
     if (re.comment)
         alias.comment = re.comment;
     return alias;

package/browser/dist/compose/compose-scalar.js

@@ -1,46 +1,43 @@
-import { isScalar } from '../nodes/Node.js';
+import { isScalar, SCALAR } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 import { resolveBlockScalar } from './resolve-block-scalar.js';
 import { resolveFlowScalar } from './resolve-flow-scalar.js';
 
-function composeScalar(doc, token, anchor, tagName, onError) {
-    const { offset } = token;
-    const { value, type, comment, length } = token.type === 'block-scalar'
-        ? resolveBlockScalar(token, doc.options.strict, onError)
-        : 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(token, ctx.options.strict, onError)
+        : 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 = isScalar(res) ? res : new Scalar(res);
     }
     catch (error) {
-        onError(offset, error.message);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
         scalar = new 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[SCALAR]; // non-specific tag
     const matchWithTest = [];
     for (const tag of schema.tags) {
         if (!tag.collection && tag.tag === tagName) {
@@ -60,8 +57,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[SCALAR];
 }
 function findScalarTagByTest(schema, value, apply) {
     var _a;
@@ -71,7 +68,7 @@ function findScalarTagByTest(schema, value, apply) {
                 return tag;
         }
     }
-    return defaultScalarTag(schema);
+    return schema[SCALAR];
 }
 
 export { composeScalar };

package/browser/dist/compose/composer.js

@@ -1,11 +1,19 @@
 import { Directives } from '../doc/directives.js';
 import { Document } from '../doc/Document.js';
 import { YAMLWarning, YAMLParseError } from '../errors.js';
-import { isCollection } from '../nodes/Node.js';
+import { isCollection, isPair } from '../nodes/Node.js';
 import { defaultOptions } from '../options.js';
 import { composeDoc } from './compose-doc.js';
 import { resolveEnd } from './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) {
     let comment = '';
     let atComment = false;
@@ -38,88 +46,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 = {}) {
+    constructor(options = {}) {
         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 YAMLWarning(offset, message));
+                this.warnings.push(new YAMLWarning(pos, code, message));
             else
-                this.errors.push(new 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) => {
-            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(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 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 YAMLParseError(token.offset, msg));
-                        break;
-                    }
-                    const end = 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 YAMLParseError(-1, `Unsupported token ${token.type}`));
-            }
+                this.errors.push(new YAMLParseError(pos, code, message));
         };
         this.directives = new Directives({
-            version: (options === null || options === void 0 ? void 0 : options.version) || defaultOptions.version
+            version: options.version || defaultOptions.version
         });
-        this.onDocument = onDocument;
         this.options = options;
     }
     decorate(doc, afterDoc) {
@@ -134,7 +84,9 @@ class Composer {
                 doc.commentBefore = comment;
             }
             else if (isCollection(dc) && !dc.flow && dc.items.length > 0) {
-                const it = dc.items[0];
+                let it = dc.items[0];
+                if (isPair(it))
+                    it = it.key;
                 const cb = it.commentBefore;
                 it.commentBefore = cb ? `${comment}\n${cb}` : comment;
             }
@@ -168,20 +120,97 @@ 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) {
+        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(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 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 YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
+                    break;
+                }
+                const end = 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 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(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/browser/dist/compose/resolve-block-map.js

@@ -4,24 +4,28 @@ import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.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(doc.schema);
-    if (anchor)
-        doc.anchors.setAnchor(map, anchor);
-    for (const { start, key, sep, value } of items) {
+    const map = new YAMLMap(ctx.schema);
+    let offset = bm.offset;
+    for (const { start, key, sep, value } of bm.items) {
         // key properties
-        const keyProps = resolveProps(doc, start, true, 'explicit-key-ind', offset, onError);
+        const keyProps = resolveProps(start, {
+            ctx,
+            indicator: 'explicit-key-ind',
+            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)
@@ -32,39 +36,44 @@ 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 && 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);
         // value properties
-        const valueProps = resolveProps(doc, sep || [], !key || key.type === 'block-scalar', 'map-value-ind', offset, onError);
-        offset += valueProps.length;
+        const valueProps = resolveProps(sep || [], {
+            ctx,
+            indicator: 'map-value-ind',
+            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(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;
@@ -74,7 +83,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items
             map.items.push(new Pair(keyNode));
         }
     }
-    map.range = [start, offset];
+    map.range = [bm.offset, offset, offset];
     return map;
 }