yaml 2.0.0-4 → 2.0.0-8

package/browser/dist/stringify/stringifyCollection.js

@@ -0,0 +1,122 @@
+import { Collection } from '../nodes/Collection.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;
+    const inFlow = flow || ctx.inFlow;
+    if (inFlow)
+        itemIndent += indentStep;
+    ctx = Object.assign({}, ctx, { indent: itemIndent, inFlow, type: null });
+    let singleLineOutput = true;
+    let chompKeep = false; // flag for the preceding node's status
+    const nodes = items.reduce((nodes, item, i) => {
+        let comment = null;
+        if (isNode(item)) {
+            if (!chompKeep && item.spaceBefore)
+                nodes.push({ comment: true, str: '' });
+            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 cb.match(/^.*$/gm)) {
+                    const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                    nodes.push({ comment: true, str });
+                }
+            }
+            if (item.comment) {
+                comment = item.comment;
+                singleLineOutput = false;
+            }
+        }
+        else if (isPair(item)) {
+            const ik = isNode(item.key) ? item.key : null;
+            if (ik) {
+                if (!chompKeep && ik.spaceBefore)
+                    nodes.push({ comment: true, str: '' });
+                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 cb.match(/^.*$/gm)) {
+                        const str = line === ' ' ? '#' : line ? `#${line}` : '';
+                        nodes.push({ comment: true, str });
+                    }
+                }
+                if (ik.comment)
+                    singleLineOutput = false;
+            }
+            if (inFlow) {
+                const iv = isNode(item.value) ? item.value : null;
+                if (iv) {
+                    if (iv.comment)
+                        comment = iv.comment;
+                    if (iv.comment || iv.commentBefore)
+                        singleLineOutput = false;
+                }
+                else if (item.value == null && ik && ik.comment) {
+                    comment = ik.comment;
+                }
+            }
+        }
+        chompKeep = false;
+        let str = stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
+        if (inFlow && i < items.length - 1)
+            str += ',';
+        str = addComment(str, itemIndent, comment);
+        if (chompKeep && (comment || inFlow))
+            chompKeep = false;
+        nodes.push({ comment: false, str });
+        return nodes;
+    }, []);
+    let str;
+    if (nodes.length === 0) {
+        str = flowChars.start + flowChars.end;
+    }
+    else if (inFlow) {
+        const { start, end } = flowChars;
+        const strings = nodes.map(n => n.str);
+        let singleLineLength = 2;
+        for (const node of nodes) {
+            if (node.comment || node.str.includes('\n')) {
+                singleLineOutput = false;
+                break;
+            }
+            singleLineLength += node.str.length + 2;
+        }
+        if (!singleLineOutput ||
+            singleLineLength > Collection.maxFlowStringSingleLineLength) {
+            str = start;
+            for (const s of strings) {
+                str += s ? `\n${indentStep}${indent}${s}` : '\n';
+            }
+            str += `\n${indent}${end}`;
+        }
+        else {
+            str = `${start} ${strings.join(' ')} ${end}`;
+        }
+    }
+    else {
+        const strings = nodes.map(blockItem);
+        str = strings.shift() || '';
+        for (const s of strings)
+            str += s ? `\n${indent}${s}` : '\n';
+    }
+    if (comment) {
+        str += '\n' + stringifyComment(comment, indent);
+        if (onComment)
+            onComment();
+    }
+    else if (chompKeep && onChompKeep)
+        onChompKeep();
+    return str;
+}
+
+export { stringifyCollection };

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

@@ -0,0 +1,64 @@
+import { isNode } from '../nodes/Node.js';
+import { createStringifyContext, stringify } from './stringify.js';
+import { stringifyComment, addComment } from './stringifyComment.js';
+
+function stringifyDocument(doc, options) {
+    const lines = [];
+    let hasDirectives = options.directives === true;
+    if (options.directives !== false) {
+        const dir = doc.directives.toString(doc);
+        if (dir) {
+            lines.push(dir);
+            hasDirectives = true;
+        }
+        else if (doc.directives.marker)
+            hasDirectives = true;
+    }
+    if (hasDirectives)
+        lines.push('---');
+    if (doc.commentBefore) {
+        if (lines.length !== 1)
+            lines.unshift('');
+        lines.unshift(stringifyComment(doc.commentBefore, ''));
+    }
+    const ctx = createStringifyContext(doc, options);
+    let chompKeep = false;
+    let contentComment = null;
+    if (doc.contents) {
+        if (isNode(doc.contents)) {
+            if (doc.contents.spaceBefore && hasDirectives)
+                lines.push('');
+            if (doc.contents.commentBefore)
+                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;
+        }
+        const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
+        let body = stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
+        if (contentComment)
+            body = addComment(body, '', contentComment);
+        if ((body[0] === '|' || body[0] === '>') &&
+            lines[lines.length - 1] === '---') {
+            // Top-level block scalars with a preceding doc marker ought to use the
+            // same line for their header.
+            lines[lines.length - 1] = `--- ${body}`;
+        }
+        else
+            lines.push(body);
+    }
+    else {
+        lines.push(stringify(doc.contents, ctx));
+    }
+    let dc = doc.comment;
+    if (dc && chompKeep)
+        dc = dc.replace(/^\n+/, '');
+    if (dc) {
+        if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+            lines.push('');
+        lines.push(stringifyComment(dc, ''));
+    }
+    return lines.join('\n') + '\n';
+}
+
+export { stringifyDocument };

package/browser/dist/stringify/stringifyPair.js

@@ -0,0 +1,111 @@
+import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';
+import { Scalar } from '../nodes/Scalar.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;
+    let keyComment = (isNode(key) && key.comment) || null;
+    if (simpleKeys) {
+        if (keyComment) {
+            throw new Error('With simple keys, key nodes cannot have comments');
+        }
+        if (isCollection(key)) {
+            const msg = 'With simple keys, collection cannot be used as a key value';
+            throw new Error(msg);
+        }
+    }
+    let explicitKey = !simpleKeys &&
+        (!key ||
+            (keyComment && value == null && !ctx.inFlow) ||
+            isCollection(key) ||
+            (isScalar(key)
+                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL
+                : typeof key === 'object'));
+    ctx = Object.assign({}, ctx, {
+        allNullValues: false,
+        implicitKey: !explicitKey && (simpleKeys || !allNullValues),
+        indent: indent + indentStep
+    });
+    let keyCommentDone = false;
+    let chompKeep = false;
+    let str = stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));
+    if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+        if (simpleKeys)
+            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
+        explicitKey = true;
+    }
+    if (ctx.inFlow) {
+        if (allNullValues || value == null) {
+            if (keyCommentDone && onComment)
+                onComment();
+            return explicitKey ? `? ${str}` : str;
+        }
+    }
+    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
+        if (keyCommentDone)
+            keyComment = null;
+        if (chompKeep && !keyComment && onChompKeep)
+            onChompKeep();
+        return addComment(`? ${str}`, ctx.indent, keyComment);
+    }
+    if (keyCommentDone)
+        keyComment = null;
+    str = explicitKey
+        ? `? ${addComment(str, ctx.indent, keyComment)}\n${indent}:`
+        : addComment(`${str}:`, ctx.indent, keyComment);
+    let vcb = '';
+    let valueComment = null;
+    if (isNode(value)) {
+        if (value.spaceBefore)
+            vcb = '\n';
+        if (value.commentBefore)
+            vcb += `\n${stringifyComment(value.commentBefore, ctx.indent)}`;
+        valueComment = value.comment;
+    }
+    else if (value && typeof value === 'object') {
+        value = doc.createNode(value);
+    }
+    ctx.implicitKey = false;
+    if (!explicitKey && !keyComment && isScalar(value))
+        ctx.indentAtStart = str.length + 1;
+    chompKeep = false;
+    if (!indentSeq &&
+        indentStep.length >= 2 &&
+        !ctx.inFlow &&
+        !explicitKey &&
+        isSeq(value) &&
+        !value.flow &&
+        !value.tag &&
+        !value.anchor) {
+        // If indentSeq === false, consider '- ' as part of indentation where possible
+        ctx.indent = ctx.indent.substr(2);
+    }
+    let valueCommentDone = false;
+    const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
+    let ws = ' ';
+    if (vcb || keyComment) {
+        ws = `${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')
+        ws = '';
+    if (ctx.inFlow) {
+        if (valueCommentDone && onComment)
+            onComment();
+        return str + ws + valueStr;
+    }
+    else {
+        if (valueCommentDone)
+            valueComment = null;
+        if (chompKeep && !valueComment && onChompKeep)
+            onChompKeep();
+        return addComment(str + ws + valueStr, ctx.indent, valueComment);
+    }
+}
+
+export { stringifyPair };

package/browser/dist/stringify/stringifyString.js

@@ -1,5 +1,4 @@
 import { Scalar } from '../nodes/Scalar.js';
-import { addCommentBefore } from './addComment.js';
 import { foldFlowLines, FOLD_QUOTED, FOLD_FLOW, FOLD_BLOCK } from './foldFlowLines.js';
 
 const getFoldOptions = (ctx) => ({
@@ -142,70 +141,80 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const indentSize = indent ? '2' : '1'; // root is at -1
     const literal = type === Scalar.BLOCK_FOLDED
         ? false
         : type === Scalar.BLOCK_LITERAL
             ? true
             : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
-    let header = literal ? '|' : '>';
     if (!value)
-        return header + '\n';
-    let wsStart = '';
-    let wsEnd = '';
-    value = value
-        .replace(/[\n\t ]*$/, ws => {
-        const n = ws.indexOf('\n');
-        if (n === -1) {
-            header += '-'; // strip
-        }
-        else if (value === ws || n !== ws.length - 1) {
-            header += '+'; // keep
-            if (onChompKeep)
-                onChompKeep();
-        }
-        wsEnd = ws.replace(/\n$/, '');
-        return '';
-    })
-        .replace(/^[\n ]*/, ws => {
-        if (ws.indexOf(' ') !== -1)
-            header += indentSize;
-        const m = ws.match(/ +$/);
-        if (m) {
-            wsStart = ws.slice(0, -m[0].length);
-            return m[0];
-        }
-        else {
-            wsStart = ws;
-            return '';
-        }
-    });
-    if (wsEnd)
-        wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`);
-    if (wsStart)
-        wsStart = wsStart.replace(/\n+/g, `$&${indent}`);
+        return literal ? '|\n' : '>\n';
+    // determine chomping from whitespace at value end
+    let chomp;
+    let endStart;
+    for (endStart = value.length; endStart > 0; --endStart) {
+        const ch = value[endStart - 1];
+        if (ch !== '\n' && ch !== '\t' && ch !== ' ')
+            break;
+    }
+    let end = value.substring(endStart);
+    const endNlPos = end.indexOf('\n');
+    if (endNlPos === -1) {
+        chomp = '-'; // strip
+    }
+    else if (value === end || endNlPos !== end.length - 1) {
+        chomp = '+'; // keep
+        if (onChompKeep)
+            onChompKeep();
+    }
+    else {
+        chomp = ''; // clip
+    }
+    if (end) {
+        value = value.slice(0, -end.length);
+        if (end[end.length - 1] === '\n')
+            end = end.slice(0, -1);
+        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
+    }
+    // determine indent indicator from whitespace at value start
+    let startWithSpace = false;
+    let startEnd;
+    let startNlPos = -1;
+    for (startEnd = 0; startEnd < value.length; ++startEnd) {
+        const ch = value[startEnd];
+        if (ch === ' ')
+            startWithSpace = true;
+        else if (ch === '\n')
+            startNlPos = startEnd;
+        else
+            break;
+    }
+    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+    if (start) {
+        value = value.substring(start.length);
+        start = start.replace(/\n+/g, `$&${indent}`);
+    }
+    const indentSize = indent ? '2' : '1'; // root is at -1
+    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
         header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
         if (onComment)
             onComment();
     }
-    if (!value)
-        return `${header}${indentSize}\n${indent}${wsEnd}`;
     if (literal) {
         value = value.replace(/\n+/g, `$&${indent}`);
-        return `${header}\n${indent}${wsStart}${value}${wsEnd}`;
+        return `${header}\n${indent}${start}${value}${end}`;
     }
     value = value
         .replace(/\n+/g, '\n$&')
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
-        //         ^ ind.line  ^ empty     ^ capture next empty lines only at end of indent
+        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
     var _a;
-    const { comment, type, value } = item;
+    const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
@@ -261,17 +270,9 @@ function plainString(item, ctx, onComment, onChompKeep) {
                 return doubleQuotedString(value, ctx);
         }
     }
-    const body = implicitKey
+    return implicitKey
         ? str
         : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
-    if (comment &&
-        !inFlow &&
-        (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
-        if (onComment)
-            onComment();
-        return addCommentBefore(body, indent, comment);
-    }
-    return body;
 }
 function stringifyString(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;

package/browser/dist/visit.js

@@ -28,9 +28,28 @@ const REMOVE = Symbol('remove node');
  * If `visitor` is a single function, it will be called with all values
  * encountered in the tree, including e.g. `null` values. Alternatively,
  * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
- * `Alias` and `Scalar` node.
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
  */
 function visit(node, visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        visitor = Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
+    }
     if (isDocument(node)) {
         const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
         if (cd === REMOVE)

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

@@ -1,5 +1,5 @@
-import type { Document } from '../doc/Document.js';
 import { ParsedNode } from '../nodes/Node.js';
-import type { BlockMap, BlockSequence, FlowCollection } from '../parse/tokens.js';
-import type { ComposeNode } from './compose-node.js';
-export declare function composeCollection(CN: ComposeNode, doc: Document.Parsed, token: BlockMap | BlockSequence | FlowCollection, anchor: string | null, tagName: string | null, onError: (offset: number, message: string, warning?: boolean) => void): ParsedNode;
+import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst.js';
+import type { ComposeContext, ComposeNode } from './compose-node.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function composeCollection(CN: ComposeNode, ctx: ComposeContext, token: BlockMap | BlockSequence | FlowCollection, tagToken: SourceToken | null, onError: ComposeErrorHandler): ParsedNode;

package/dist/compose/compose-collection.js

@@ -6,22 +6,25 @@ var resolveBlockMap = require('./resolve-block-map.js');
 var resolveBlockSeq = require('./resolve-block-seq.js');
 var resolveFlowCollection = require('./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.resolveBlockMap(CN, doc, token, anchor, onError);
+            coll = resolveBlockMap.resolveBlockMap(CN, ctx, token, onError);
             break;
         }
         case 'block-seq': {
-            coll = resolveBlockSeq.resolveBlockSeq(CN, doc, token, anchor, onError);
+            coll = resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError);
             break;
         }
         case 'flow-collection': {
-            coll = resolveFlowCollection.resolveFlowCollection(CN, doc, token, anchor, onError);
+            coll = resolveFlowCollection.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
@@ -31,20 +34,20 @@ function composeCollection(CN, doc, token, anchor, tagName, onError) {
         return coll;
     }
     const expType = Node.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 = Node.isNode(res)
         ? res
         : new Scalar.Scalar(res);

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

@@ -1,5 +1,6 @@
 import type { Directives } from '../doc/directives.js';
 import { Document } from '../doc/Document.js';
-import type { Options } from '../options.js';
-import type * as Tokens from '../parse/tokens.js';
-export declare function composeDoc(options: Options, directives: Directives, { offset, start, value, end }: Tokens.Document, onError: (offset: number, message: string, warning?: boolean) => void): Document.Parsed<import("../index.js").ParsedNode>;
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
+import type * as CST from '../parse/cst.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function composeDoc(options: ParseOptions & DocumentOptions & SchemaOptions, directives: Directives, { offset, start, value, end }: CST.Document, onError: ComposeErrorHandler): Document.Parsed<import("../index.js").ParsedNode>;

package/dist/compose/compose-doc.js

@@ -8,16 +8,33 @@ var resolveProps = require('./resolve-props.js');
 function composeDoc(options, directives, { offset, start, value, end }, onError) {
     const opts = Object.assign({ directives }, options);
     const doc = new Document.Document(undefined, opts);
-    const props = resolveProps.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.resolveProps(start, {
+        indicator: 'doc-start',
+        next: value || (end === null || end === void 0 ? void 0 : end[0]),
+        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.composeNode(doc, value, props, onError)
-        : composeNode.composeEmptyNode(doc, offset + props.length, start, null, props, onError);
-    const re = resolveEnd.resolveEnd(end, doc.contents.range[1], false, onError);
+        ? composeNode.composeNode(ctx, value, props, onError)
+        : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd.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/dist/compose/compose-node.d.ts

@@ -1,17 +1,25 @@
-import type { Document } from '../doc/Document.js';
+import type { Directives } from '../doc/directives.js';
 import type { ParsedNode } from '../nodes/Node.js';
-import type { Token } from '../parse/tokens.js';
-export interface Props {
+import type { ParseOptions } from '../options.js';
+import type { SourceToken, Token } from '../parse/cst.js';
+import type { Schema } from '../schema/Schema.js';
+import type { ComposeErrorHandler } from './composer.js';
+export interface ComposeContext {
+    directives: Directives;
+    options: Readonly<Required<Omit<ParseOptions, 'lineCounter'>>>;
+    schema: Readonly<Schema>;
+}
+interface Props {
     spaceBefore: boolean;
     comment: string;
-    anchor: string;
-    tagName: string;
+    anchor: SourceToken | null;
+    tag: SourceToken | null;
 }
 declare const CN: {
     composeNode: typeof composeNode;
     composeEmptyNode: typeof composeEmptyNode;
 };
 export declare type ComposeNode = typeof CN;
-export declare function composeNode(doc: Document.Parsed, token: Token, props: Props, onError: (offset: number, message: string, warning?: boolean) => void): ParsedNode;
-export declare function composeEmptyNode(doc: Document.Parsed, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tagName }: Props, onError: (offset: number, message: string, warning?: boolean) => void): import("../index.js").Scalar.Parsed;
+export declare function composeNode(ctx: ComposeContext, token: Token, props: Props, onError: ComposeErrorHandler): ParsedNode;
+export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag }: Props, onError: ComposeErrorHandler): import("../index.js").Scalar.Parsed;
 export {};