yaml 2.0.0-4 → 2.0.0-5

package/dist/compose/compose-scalar.js

@@ -5,44 +5,41 @@ 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);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
         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 +59,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 +70,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,6 +8,14 @@ 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) {
     let comment = '';
     let atComment = false;
@@ -40,90 +48,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 +86,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 +122,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,5 @@
-import type { Document } from '../doc/Document.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<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null>;

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

@@ -6,24 +6,28 @@ var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./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.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, {
+            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)
@@ -34,39 +38,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 && 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);
         // 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 || [], {
+            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.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 +85,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;
 };

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

@@ -3,9 +3,10 @@
 var Scalar = require('../nodes/Scalar.js');
 
 function resolveBlockScalar(scalar, strict, onError) {
+    const start = scalar.offset;
     const header = parseBlockScalarHeader(scalar, strict, onError);
     if (!header)
-        return { value: '', type: null, comment: '', length: 0 };
+        return { value: '', type: null, comment: '', range: [start, start, start] };
     const type = header.mode === '>' ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
     const lines = scalar.source ? splitLines(scalar.source) : [];
     // determine the end of content & start of chomping
@@ -20,10 +21,10 @@ 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') : '';
-        let length = header.length;
+        let end = start + header.length;
         if (scalar.source)
-            length += scalar.source.length;
-        return { value, type, comment: header.comment, length };
+            end += scalar.source.length;
+        return { value, type, comment: header.comment, range: [start, end, end] };
     }
     // find the indentation level to trim from start
     let trimIndent = scalar.indent + header.indent;
@@ -38,7 +39,7 @@ function resolveBlockScalar(scalar, strict, onError) {
         else {
             if (indent.length < trimIndent) {
                 const message = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
-                onError(offset + indent.length, message);
+                onError(offset + indent.length, 'MISSING_CHAR', message);
             }
             if (header.indent === 0)
                 trimIndent = indent.length;
@@ -65,7 +66,7 @@ function resolveBlockScalar(scalar, strict, onError) {
                 ? 'explicit indentation indicator'
                 : 'first line';
             const message = `Block scalar lines must not be less indented than their ${src}`;
-            onError(offset - content.length - (crlf ? 2 : 1), message);
+            onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message);
             indent = '';
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
@@ -107,17 +108,13 @@ function resolveBlockScalar(scalar, strict, onError) {
         default:
             value += '\n';
     }
-    return {
-        value,
-        type,
-        comment: header.comment,
-        length: header.length + scalar.source.length
-    };
+    const end = start + header.length + scalar.source.length;
+    return { value, type, comment: header.comment, range: [start, end, end] };
 }
 function parseBlockScalarHeader({ offset, props }, strict, onError) {
     /* istanbul ignore if should not happen */
     if (props[0].type !== 'block-scalar-header') {
-        onError(offset, 'Block scalar header not found');
+        onError(props[0], 'IMPOSSIBLE', 'Block scalar header not found');
         return null;
     }
     const { source } = props[0];
@@ -138,7 +135,7 @@ function parseBlockScalarHeader({ offset, props }, strict, onError) {
         }
     }
     if (error !== -1)
-        onError(error, `Block scalar header includes extra characters: ${source}`);
+        onError(error, 'UNEXPECTED_TOKEN', `Block scalar header includes extra characters: ${source}`);
     let hasSpace = false;
     let comment = '';
     let length = source.length;
@@ -154,19 +151,19 @@ 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(offset + length, message);
+                    onError(token, 'COMMENT_SPACE', message);
                 }
                 length += token.source.length;
                 comment = token.source.substring(1);
                 break;
             case 'error':
-                onError(offset + length, token.message);
+                onError(token, 'UNEXPECTED_TOKEN', token.message);
                 length += token.source.length;
                 break;
             /* istanbul ignore next should not happen */
             default: {
                 const message = `Unexpected token in block scalar header: ${token.type}`;
-                onError(offset + length, message);
+                onError(token, 'UNEXPECTED_TOKEN', message);
                 const ts = token.source;
                 if (ts && typeof ts === 'string')
                     length += ts.length;

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

@@ -1,5 +1,5 @@
-import type { Document } from '../doc/Document.js';
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { BlockSequence } from '../parse/tokens.js';
-import type { ComposeNode } from './compose-node.js';
-export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, doc: Document.Parsed, { items, offset }: BlockSequence, anchor: string | null, onError: (offset: number, message: string, warning?: boolean) => void): YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+import type { BlockSequence } from '../parse/cst.js';
+import type { ComposeContext, ComposeNode } from './compose-node.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler): YAMLSeq.Parsed<import("../index.js").ParsedNode>;