yaml 2.0.0-4 → 2.0.0-5

package/browser/dist/stringify/stringifyDocument.js

@@ -0,0 +1,61 @@
+import { isNode } from '../nodes/Node.js';
+import { addComment } from './addComment.js';
+import { createStringifyContext, stringify } from './stringify.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(doc.commentBefore.replace(/^/gm, '#'));
+    }
+    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(doc.contents.commentBefore.replace(/^/gm, '#'));
+            // 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));
+    }
+    if (doc.comment) {
+        if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+            lines.push('');
+        lines.push(doc.comment.replace(/^/gm, '#'));
+    }
+    return lines.join('\n') + '\n';
+}
+
+export { stringifyDocument };

package/browser/dist/stringify/stringifyPair.js

@@ -0,0 +1,113 @@
+import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { addComment } from './addComment.js';
+import { stringify } from './stringify.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) {
+            const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
+            vcb += `\n${cs}`;
+        }
+        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, {
+        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.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 {};

package/dist/compose/compose-node.js

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

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

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