yaml 2.0.0-4 → 2.0.0-8

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, 'MISSING_CHAR', 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>;

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

@@ -3,20 +3,24 @@
 var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveProps = require('./resolve-props.js');
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, doc, { items, offset }, anchor, onError) {
-    const start = offset;
-    const seq = new YAMLSeq.YAMLSeq(doc.schema);
-    if (anchor)
-        doc.anchors.setAnchor(seq, anchor);
-    for (const { start, value } of items) {
-        const props = resolveProps.resolveProps(doc, start, true, 'seq-item-ind', offset, onError);
-        offset += props.length;
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
+    const seq = new YAMLSeq.YAMLSeq(ctx.schema);
+    let offset = bs.offset;
+    for (const { start, value } of bs.items) {
+        const props = resolveProps.resolveProps(start, {
+            indicator: 'seq-item-ind',
+            next: value,
+            offset,
+            onError,
+            startOnNewline: true
+        });
+        offset = props.end;
         if (!props.found) {
-            if (props.anchor || props.tagName || value) {
-                const msg = value && value.type === 'block-seq'
-                    ? 'All sequence items must start at the same column'
-                    : 'Sequence item without - indicator';
-                onError(offset, msg);
+            if (props.anchor || props.tag || value) {
+                if (value && value.type === 'block-seq')
+                    onError(offset, 'BAD_INDENT', 'All sequence items must start at the same column');
+                else
+                    onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
             }
             else {
                 // TODO: assert being at last item?
@@ -26,12 +30,12 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, doc, { items, offset
             }
         }
         const node = value
-            ? composeNode(doc, value, props, onError)
-            : composeEmptyNode(doc, offset, start, null, props, onError);
-        offset = node.range[1];
+            ? composeNode(ctx, value, props, onError)
+            : composeEmptyNode(ctx, offset, start, null, props, onError);
+        offset = node.range[2];
         seq.items.push(node);
     }
-    seq.range = [start, offset];
+    seq.range = [bs.offset, offset, offset];
     return seq;
 }
 

package/dist/compose/resolve-end.d.ts

@@ -1,5 +1,6 @@
-import type { SourceToken } from '../parse/tokens.js';
-export declare function resolveEnd(end: SourceToken[] | undefined, offset: number, reqSpace: boolean, onError: (offset: number, message: string) => void): {
+import type { SourceToken } from '../parse/cst.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function resolveEnd(end: SourceToken[] | undefined, offset: number, reqSpace: boolean, onError: ComposeErrorHandler): {
     comment: string;
     offset: number;
 };

package/dist/compose/resolve-end.js

@@ -4,32 +4,31 @@ function resolveEnd(end, offset, reqSpace, onError) {
     let comment = '';
     if (end) {
         let hasSpace = false;
-        let hasComment = false;
         let sep = '';
-        for (const { source, type } of end) {
+        for (const token of end) {
+            const { source, type } = token;
             switch (type) {
                 case 'space':
                     hasSpace = true;
                     break;
                 case 'comment': {
                     if (reqSpace && !hasSpace)
-                        onError(offset, 'Comments must be separated from other tokens by white space characters');
-                    const cb = source.substring(1);
-                    if (!hasComment)
+                        onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                    const cb = source.substring(1) || ' ';
+                    if (!comment)
                         comment = cb;
                     else
                         comment += sep + cb;
-                    hasComment = true;
                     sep = '';
                     break;
                 }
                 case 'newline':
-                    if (hasComment)
+                    if (comment)
                         sep += source;
                     hasSpace = true;
                     break;
                 default:
-                    onError(offset, `Unexpected ${type} at node end`);
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${type} at node end`);
             }
             offset += source.length;
         }

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

@@ -1,7 +1,6 @@
-import type { Document } from '../doc/Document.js';
-import { ParsedNode } from '../nodes/Node.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { FlowCollection } from '../parse/tokens.js';
-import type { ComposeNode } from './compose-node.js';
-export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, doc: Document.Parsed, fc: FlowCollection, _anchor: string | null, onError: (offset: number, message: string, warning?: boolean) => void): YAMLMap.Parsed<ParsedNode, ParsedNode | null> | YAMLSeq.Parsed<ParsedNode>;
+import type { FlowCollection } from '../parse/cst.js';
+import type { ComposeContext, ComposeNode } from './compose-node.js';
+import type { ComposeErrorHandler } from './composer.js';
+export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler): YAMLMap.Parsed<import("../nodes/Node.js").ParsedNode, import("../nodes/Node.js").ParsedNode | null> | YAMLSeq.Parsed<import("../nodes/Node.js").ParsedNode>;

package/dist/compose/resolve-flow-collection.js

@@ -5,227 +5,186 @@ var Pair = require('../nodes/Pair.js');
 var YAMLMap = require('../nodes/YAMLMap.js');
 var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveEnd = require('./resolve-end.js');
+var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
+var utilMapIncludes = require('./util-map-includes.js');
 
-function resolveFlowCollection({ composeNode, composeEmptyNode }, doc, fc, _anchor, onError) {
+const blockMsg = 'Block collections are not allowed within flow collections';
+const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
     const isMap = fc.start.source === '{';
-    const coll = isMap ? new YAMLMap.YAMLMap(doc.schema) : new YAMLSeq.YAMLSeq(doc.schema);
+    const fcName = isMap ? 'flow map' : 'flow sequence';
+    const coll = isMap
+        ? new YAMLMap.YAMLMap(ctx.schema)
+        : new YAMLSeq.YAMLSeq(ctx.schema);
     coll.flow = true;
-    if (_anchor)
-        doc.anchors.setAnchor(coll, _anchor);
-    let key = null;
-    let value = null;
-    let spaceBefore = false;
-    let comment = '';
-    let hasSpace = false;
-    let hasComment = false;
-    let newlines = '';
-    let anchor = '';
-    let tagName = '';
-    let offset = fc.offset + 1;
-    let atLineStart = false;
-    let atExplicitKey = false;
-    let atValueEnd = false;
-    let nlAfterValueInSeq = false;
-    let seqKeyToken = null;
-    function getProps() {
-        const props = { spaceBefore, comment, anchor, tagName };
-        spaceBefore = false;
-        comment = '';
-        hasComment = false;
-        newlines = '';
-        anchor = '';
-        tagName = '';
-        return props;
-    }
-    function addItem(pos) {
-        if (value) {
-            if (hasComment)
-                value.comment = comment;
-        }
-        else {
-            value = composeEmptyNode(doc, offset, fc.items, pos, getProps(), onError);
+    let offset = fc.offset;
+    for (let i = 0; i < fc.items.length; ++i) {
+        const { start, key, sep, value } = fc.items[i];
+        const props = resolveProps.resolveProps(start, {
+            flow: fcName,
+            indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            offset,
+            onError,
+            startOnNewline: false
+        });
+        if (!props.found) {
+            if (!props.anchor && !props.tag && !sep && !value) {
+                if (i === 0 && props.comma)
+                    onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+                else if (i < fc.items.length - 1)
+                    onError(props.start, 'UNEXPECTED_TOKEN', `Unexpected empty item in ${fcName}`);
+                if (props.comment) {
+                    if (coll.comment)
+                        coll.comment += '\n' + props.comment;
+                    else
+                        coll.comment = props.comment;
+                }
+                continue;
+            }
+            if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
+                onError(key, // checked by containsNewline()
+                'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
         }
-        if (isMap || atExplicitKey) {
-            coll.items.push(key ? new Pair.Pair(key, value) : new Pair.Pair(value));
+        if (i === 0) {
+            if (props.comma)
+                onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
         }
         else {
-            const seq = coll;
-            if (key) {
-                const map = new YAMLMap.YAMLMap(doc.schema);
-                map.flow = true;
-                map.items.push(new Pair.Pair(key, value));
-                seq.items.push(map);
-            }
-            else
-                seq.items.push(value);
-        }
-    }
-    for (let i = 0; i < fc.items.length; ++i) {
-        const token = fc.items[i];
-        let isSourceToken = true;
-        switch (token.type) {
-            case 'space':
-                hasSpace = true;
-                break;
-            case 'comment': {
-                if (doc.options.strict && !hasSpace)
-                    onError(offset, 'Comments must be separated from other tokens by white space characters');
-                const cb = token.source.substring(1);
-                if (!hasComment)
-                    comment = cb;
-                else
-                    comment += newlines + cb;
-                atLineStart = false;
-                hasComment = true;
-                newlines = '';
-                break;
-            }
-            case 'newline':
-                if (atLineStart && !hasComment)
-                    spaceBefore = true;
-                if (atValueEnd) {
-                    if (hasComment) {
-                        let node = coll.items[coll.items.length - 1];
-                        if (Node.isPair(node))
-                            node = node.value || node.key;
-                        /* istanbul ignore else should not happen */
-                        if (Node.isNode(node))
-                            node.comment = comment;
-                        else
-                            onError(offset, 'Error adding trailing comment to node');
-                        comment = '';
-                        hasComment = false;
+            if (!props.comma)
+                onError(props.start, 'MISSING_CHAR', `Missing , between ${fcName} items`);
+            if (props.comment) {
+                let prevItemComment = '';
+                loop: for (const st of start) {
+                    switch (st.type) {
+                        case 'comma':
+                        case 'space':
+                            break;
+                        case 'comment':
+                            prevItemComment = st.source.substring(1);
+                            break loop;
+                        default:
+                            break loop;
                     }
-                    atValueEnd = false;
                 }
-                else {
-                    newlines += token.source;
-                    if (!isMap && !key && value)
-                        nlAfterValueInSeq = true;
+                if (prevItemComment) {
+                    let prev = coll.items[coll.items.length - 1];
+                    if (Node.isPair(prev))
+                        prev = prev.value || prev.key;
+                    if (prev.comment)
+                        prev.comment += '\n' + prevItemComment;
+                    else
+                        prev.comment = prevItemComment;
+                    props.comment = props.comment.substring(prevItemComment.length + 1);
                 }
-                atLineStart = true;
-                hasSpace = true;
-                break;
-            case 'anchor':
-                if (anchor)
-                    onError(offset, 'A node can have at most one anchor');
-                anchor = token.source.substring(1);
-                atLineStart = false;
-                atValueEnd = false;
-                hasSpace = false;
-                break;
-            case 'tag': {
-                if (tagName)
-                    onError(offset, 'A node can have at most one tag');
-                const tn = doc.directives.tagName(token.source, m => onError(offset, m));
-                if (tn)
-                    tagName = tn;
-                atLineStart = false;
-                atValueEnd = false;
-                hasSpace = false;
-                break;
             }
-            case 'explicit-key-ind':
-                if (anchor || tagName)
-                    onError(offset, 'Anchors and tags must be after the ? indicator');
-                atExplicitKey = true;
-                atLineStart = false;
-                atValueEnd = false;
-                hasSpace = false;
-                break;
-            case 'map-value-ind': {
-                if (key) {
-                    if (value) {
-                        onError(offset, 'Missing {} around pair used as mapping key');
-                        const map = new YAMLMap.YAMLMap(doc.schema);
-                        map.flow = true;
-                        map.items.push(new Pair.Pair(key, value));
-                        map.range = [key.range[0], value.range[1]];
-                        key = map;
-                        value = null;
-                    } // else explicit key
-                }
-                else if (value) {
-                    if (doc.options.strict) {
-                        const slMsg = 'Implicit keys of flow sequence pairs need to be on a single line';
-                        if (nlAfterValueInSeq)
-                            onError(offset, slMsg);
-                        else if (seqKeyToken) {
-                            if (utilContainsNewline.containsNewline(seqKeyToken))
-                                onError(offset, slMsg);
-                            const start = 'offset' in seqKeyToken && seqKeyToken.offset;
-                            if (typeof start === 'number' && start < offset - 1024)
-                                onError(offset, 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key');
-                            seqKeyToken = null;
+        }
+        if (!isMap && !sep && !props.found) {
+            // item is a value in a seq
+            // → key & sep are empty, start does not include ? or :
+            const valueNode = value
+                ? composeNode(ctx, value, props, onError)
+                : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+            coll.items.push(valueNode);
+            offset = valueNode.range[2];
+            if (isBlock(value))
+                onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+        }
+        else {
+            // item is a key+value pair
+            // key value
+            const keyStart = props.end;
+            const keyNode = key
+                ? composeNode(ctx, key, props, onError)
+                : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+            if (isBlock(key))
+                onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            // value properties
+            const valueProps = resolveProps.resolveProps(sep || [], {
+                flow: fcName,
+                indicator: 'map-value-ind',
+                next: value,
+                offset: keyNode.range[2],
+                onError,
+                startOnNewline: false
+            });
+            if (valueProps.found) {
+                if (!isMap && !props.found && ctx.options.strict) {
+                    if (sep)
+                        for (const st of sep) {
+                            if (st === valueProps.found)
+                                break;
+                            if (st.type === 'newline') {
+                                onError(st, 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+                                break;
+                            }
                         }
-                    }
-                    key = value;
-                    value = null;
+                    if (props.start < valueProps.found.offset - 1024)
+                        onError(valueProps.found, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key');
                 }
-                else {
-                    key = composeEmptyNode(doc, offset, fc.items, i, getProps(), onError);
-                }
-                if (hasComment) {
-                    key.comment = comment;
-                    comment = '';
-                    hasComment = false;
-                }
-                atExplicitKey = false;
-                atValueEnd = false;
-                hasSpace = false;
-                break;
             }
-            case 'comma':
-                if (key || value || anchor || tagName || atExplicitKey)
-                    addItem(i);
+            else if (value) {
+                if ('source' in value && value.source && value.source[0] === ':')
+                    onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);
                 else
-                    onError(offset, `Unexpected , in flow ${isMap ? 'map' : 'sequence'}`);
-                key = null;
-                value = null;
-                atExplicitKey = false;
-                atValueEnd = true;
-                hasSpace = false;
-                nlAfterValueInSeq = false;
-                seqKeyToken = null;
-                break;
-            case 'block-map':
-            case 'block-seq':
-                onError(offset, 'Block collections are not allowed within flow collections');
-            // fallthrough
-            default: {
-                if (value)
-                    onError(offset, 'Missing , between flow collection items');
-                if (!isMap && !key && !atExplicitKey)
-                    seqKeyToken = token;
-                value = composeNode(doc, token, getProps(), onError);
-                offset = value.range[1];
-                atLineStart = false;
-                isSourceToken = false;
-                atValueEnd = false;
-                hasSpace = false;
+                    onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
             }
+            // value value
+            const valueNode = value
+                ? composeNode(ctx, value, valueProps, onError)
+                : valueProps.found
+                    ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError)
+                    : null;
+            if (valueNode) {
+                if (isBlock(value))
+                    onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            }
+            else if (valueProps.comment) {
+                if (keyNode.comment)
+                    keyNode.comment += '\n' + valueProps.comment;
+                else
+                    keyNode.comment = valueProps.comment;
+            }
+            const pair = new Pair.Pair(keyNode, valueNode);
+            if (isMap) {
+                const map = coll;
+                if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
+                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+                map.items.push(pair);
+            }
+            else {
+                const map = new YAMLMap.YAMLMap(ctx.schema);
+                map.flow = true;
+                map.items.push(pair);
+                coll.items.push(map);
+            }
+            offset = valueNode ? valueNode.range[2] : valueProps.end;
         }
-        if (isSourceToken)
-            offset += token.source.length;
     }
-    if (key || value || anchor || tagName || atExplicitKey)
-        addItem(fc.items.length);
     const expectedEnd = isMap ? '}' : ']';
     const [ce, ...ee] = fc.end;
-    if (!ce || ce.source !== expectedEnd) {
-        const cs = isMap ? 'map' : 'sequence';
-        onError(offset, `Expected flow ${cs} to end with ${expectedEnd}`);
+    let cePos = offset;
+    if (ce && ce.source === expectedEnd)
+        cePos = ce.offset + ce.source.length;
+    else {
+        onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
+        if (ce && ce.source.length !== 1)
+            ee.unshift(ce);
     }
-    if (ce)
-        offset += ce.source.length;
     if (ee.length > 0) {
-        const end = resolveEnd.resolveEnd(ee, offset, doc.options.strict, onError);
-        if (end.comment)
-            coll.comment = comment;
-        offset = end.offset;
+        const end = resolveEnd.resolveEnd(ee, cePos, ctx.options.strict, onError);
+        if (end.comment) {
+            if (coll.comment)
+                coll.comment += '\n' + end.comment;
+            else
+                coll.comment = end.comment;
+        }
+        coll.range = [fc.offset, cePos, end.offset];
+    }
+    else {
+        coll.range = [fc.offset, cePos, cePos];
     }
-    coll.range = [fc.offset, offset];
     return coll;
 }
 

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

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