yaml 2.0.0-4 → 2.0.0-5

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

@@ -3,10 +3,11 @@
 var Scalar = require('../nodes/Scalar.js');
 var resolveEnd = require('./resolve-end.js');
 
-function resolveFlowScalar({ offset, type, source, end }, strict, onError) {
+function resolveFlowScalar(scalar, strict, onError) {
+    const { offset, type, source, end } = scalar;
     let _type;
     let value;
-    const _onError = (rel, msg) => onError(offset + rel, msg);
+    const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
     switch (type) {
         case 'scalar':
             _type = Scalar.Scalar.PLAIN;
@@ -22,68 +23,91 @@ function resolveFlowScalar({ offset, type, source, end }, strict, onError) {
             break;
         /* istanbul ignore next should not happen */
         default:
-            onError(offset, `Expected a flow scalar value, but found: ${type}`);
+            onError(scalar, 'UNEXPECTED_TOKEN', `Expected a flow scalar value, but found: ${type}`);
             return {
                 value: '',
                 type: null,
                 comment: '',
-                length: source.length
+                range: [offset, offset + source.length, offset + source.length]
             };
     }
-    const re = resolveEnd.resolveEnd(end, 0, strict, _onError);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
     return {
         value,
         type: _type,
         comment: re.comment,
-        length: source.length + re.offset
+        range: [offset, valueEnd, re.offset]
     };
 }
 function plainValue(source, onError) {
+    let message = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            onError(0, 'Plain value cannot start with a tab character');
+            message = 'Plain value cannot start with a tab character';
             break;
         case '|':
         case '>': {
-            const message = `Plain value cannot start with block scalar indicator ${source[0]}`;
-            onError(0, message);
+            message = `Plain value cannot start with block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            const message = `Plain value cannot start with reserved character ${source[0]}`;
-            onError(0, message);
+            message = `Plain value cannot start with reserved character ${source[0]}`;
             break;
         }
     }
-    return foldLines(source.trim());
+    if (message)
+        onError(0, 'BAD_SCALAR_START', message);
+    return foldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
-        onError(source.length, "Missing closing 'quote");
+        onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
     return foldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
 function foldLines(source) {
-    const lines = source.split(/[ \t]*\r?\n[ \t]*/);
-    let res = lines[0];
+    /**
+     * The negative lookbehind here and in the `re` RegExp is to
+     * prevent causing a polynomial search time in certain cases.
+     *
+     * The try-catch is for Safari, which doesn't support this yet:
+     * https://caniuse.com/js-regexp-lookbehind
+     */
+    let first, line;
+    try {
+        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
+        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+    }
+    catch (_) {
+        first = /(.*?)[ \t]*\r?\n/sy;
+        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+    }
+    let match = first.exec(source);
+    if (!match)
+        return source;
+    let res = match[1];
     let sep = ' ';
-    for (let i = 1; i < lines.length - 1; ++i) {
-        const line = lines[i];
-        if (line === '') {
+    let pos = first.lastIndex;
+    line.lastIndex = pos;
+    while ((match = line.exec(source))) {
+        if (match[1] === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + line;
+            res += sep + match[1];
             sep = ' ';
         }
+        pos = line.lastIndex;
     }
-    if (lines.length > 1)
-        res += sep + lines[lines.length - 1];
-    return res;
+    const last = /[ \t]*(.*)/sy;
+    last.lastIndex = pos;
+    match = last.exec(source);
+    return res + sep + ((match && match[1]) || '');
 }
 function doubleQuotedValue(source, onError) {
     let res = '';
@@ -114,7 +138,7 @@ function doubleQuotedValue(source, onError) {
             }
             else {
                 const raw = source.substr(i - 1, 2);
-                onError(i - 1, `Invalid escape sequence ${raw}`);
+                onError(i - 1, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
                 res += raw;
             }
         }
@@ -132,7 +156,7 @@ function doubleQuotedValue(source, onError) {
         }
     }
     if (source[source.length - 1] !== '"' || source.length === 1)
-        onError(source.length, 'Missing closing "quote');
+        onError(source.length, 'MISSING_CHAR', 'Missing closing "quote');
     return res;
 }
 /**
@@ -180,7 +204,7 @@ function parseCharCode(source, offset, length, onError) {
     const code = ok ? parseInt(cc, 16) : NaN;
     if (isNaN(code)) {
         const raw = source.substr(offset - 2, length + 2);
-        onError(offset - 2, `Invalid escape sequence ${raw}`);
+        onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
         return raw;
     }
     return String.fromCodePoint(code);

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

@@ -1,15 +1,22 @@
-import type { Document } from '../doc/Document.js';
-import type { SourceToken } from '../parse/tokens.js';
-export declare function resolveProps(doc: Document.Parsed, tokens: SourceToken[], startOnNewline: boolean, indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind', offset: number, onError: (offset: number, message: string) => void): {
-    found: {
-        indent: number;
-        offset: number;
-    } | null;
+import type { SourceToken } from '../parse/cst.js';
+import type { ComposeContext } from './compose-node.js';
+import type { ComposeErrorHandler } from './composer.js';
+export interface ResolvePropsArg {
+    ctx: ComposeContext;
+    flow?: string;
+    indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';
+    offset: number;
+    onError: ComposeErrorHandler;
+    startOnNewline: boolean;
+}
+export declare function resolveProps(tokens: SourceToken[], { ctx, flow, indicator, offset, onError, startOnNewline }: ResolvePropsArg): {
+    comma: SourceToken | null;
+    found: SourceToken | null;
     spaceBefore: boolean;
     comment: string;
     hasNewline: boolean;
-    anchor: string;
-    tagName: string;
-    length: number;
+    anchor: SourceToken | null;
+    tag: SourceToken | null;
+    end: number;
     start: number;
 };

package/dist/compose/resolve-props.js

@@ -1,92 +1,104 @@
 'use strict';
 
-function resolveProps(doc, tokens, startOnNewline, indicator, offset, onError) {
-    let length = 0;
+function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
     let comment = '';
-    let hasComment = false;
+    let commentSep = '';
     let hasNewline = false;
-    let sep = '';
-    let anchor = '';
-    let tagName = '';
+    let anchor = null;
+    let tag = null;
+    let comma = null;
     let found = null;
     let start = null;
     for (const token of tokens) {
         switch (token.type) {
             case 'space':
-                // At the doc level, tabs at line start may be parsed as leading
-                // white space rather than indentation.
-                if (atNewline && indicator !== 'doc-start' && token.source[0] === '\t')
-                    onError(offset + length, 'Tabs are not allowed as indentation');
+                // At the doc level, tabs at line start may be parsed
+                // as leading white space rather than indentation.
+                // In a flow collection, only the parser handles indent.
+                if (!flow &&
+                    atNewline &&
+                    indicator !== 'doc-start' &&
+                    token.source[0] === '\t')
+                    onError(token, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
                 hasSpace = true;
                 break;
             case 'comment': {
-                if (doc.options.strict && !hasSpace)
-                    onError(offset + length, 'Comments must be separated from other tokens by white space characters');
+                if (ctx.options.strict && !hasSpace)
+                    onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
                 const cb = token.source.substring(1);
-                if (!hasComment)
+                if (!comment)
                     comment = cb;
                 else
-                    comment += sep + cb;
-                hasComment = true;
-                sep = '';
+                    comment += commentSep + cb;
+                commentSep = '';
                 break;
             }
             case 'newline':
-                if (atNewline && !hasComment)
+                if (atNewline && !comment)
                     spaceBefore = true;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
-                sep += token.source;
+                commentSep += token.source;
                 break;
             case 'anchor':
                 if (anchor)
-                    onError(offset + length, 'A node can have at most one anchor');
-                anchor = token.source.substring(1);
+                    onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor');
+                anchor = token;
                 if (start === null)
-                    start = offset + length;
+                    start = token.offset;
                 atNewline = false;
                 hasSpace = false;
                 break;
             case 'tag': {
-                if (tagName)
-                    onError(offset + length, 'A node can have at most one tag');
-                const tn = doc.directives.tagName(token.source, msg => onError(offset, msg));
-                if (tn)
-                    tagName = tn;
+                if (tag)
+                    onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
+                tag = token;
                 if (start === null)
-                    start = offset + length;
+                    start = token.offset;
                 atNewline = false;
                 hasSpace = false;
                 break;
             }
             case indicator:
                 // Could here handle preceding comments differently
-                found = { indent: token.indent, offset: offset + length };
+                if (anchor || tag)
+                    onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`);
+                found = token;
                 atNewline = false;
                 hasSpace = false;
                 break;
+            case 'comma':
+                if (flow) {
+                    if (comma)
+                        onError(token, 'UNEXPECTED_TOKEN', `Unexpected , in ${flow}`);
+                    comma = token;
+                    atNewline = false;
+                    hasSpace = false;
+                    break;
+                }
+            // else fallthrough
             default:
-                onError(offset + length, `Unexpected ${token.type} token`);
+                onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.type} token`);
                 atNewline = false;
                 hasSpace = false;
         }
-        /* istanbul ignore else should not happen */
-        if (token.source)
-            length += token.source.length;
     }
+    const last = tokens[tokens.length - 1];
+    const end = last ? last.offset + last.source.length : offset;
     return {
+        comma,
         found,
         spaceBefore,
         comment,
         hasNewline,
         anchor,
-        tagName,
-        length,
-        start: start !== null && start !== void 0 ? start : offset + length
+        tag,
+        end,
+        start: start !== null && start !== void 0 ? start : end
     };
 }
 

package/dist/compose/util-contains-newline.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/tokens.js';
+import type { Token } from '../parse/cst.js';
 export declare function containsNewline(key: Token | null | undefined): boolean | null;

package/dist/compose/util-contains-newline.js

@@ -8,21 +8,24 @@ function containsNewline(key) {
         case 'scalar':
         case 'double-quoted-scalar':
         case 'single-quoted-scalar':
-            return key.source.includes('\n');
+            if (key.source.includes('\n'))
+                return true;
+            if (key.end)
+                for (const st of key.end)
+                    if (st.type === 'newline')
+                        return true;
+            return false;
         case 'flow-collection':
-            for (const token of key.items) {
-                switch (token.type) {
-                    case 'newline':
+            for (const it of key.items) {
+                for (const st of it.start)
+                    if (st.type === 'newline')
                         return true;
-                    case 'alias':
-                    case 'scalar':
-                    case 'double-quoted-scalar':
-                    case 'single-quoted-scalar':
-                    case 'flow-collection':
-                        if (containsNewline(token))
+                if (it.sep)
+                    for (const st of it.sep)
+                        if (st.type === 'newline')
                             return true;
-                        break;
-                }
+                if (containsNewline(it.key) || containsNewline(it.value))
+                    return true;
             }
             return false;
         default:

package/dist/compose/util-empty-scalar-position.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/tokens.js';
+import type { Token } from '../parse/cst.js';
 export declare function emptyScalarPosition(offset: number, before: Token[] | undefined, pos: number | null): number;

package/dist/doc/Document.d.ts

@@ -1,25 +1,21 @@
 import type { YAMLError, YAMLWarning } from '../errors.js';
-import { Node, NODE_TYPE, ParsedNode } from '../nodes/Node.js';
+import { Alias } from '../nodes/Alias.js';
+import { Node, NODE_TYPE, ParsedNode, Range } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
-import { CreateNodeOptions, DocumentOptions, Options, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
-import { Anchors } from './Anchors.js';
-import { Schema } from './Schema.js';
+import type { Scalar } from '../nodes/Scalar.js';
+import type { YAMLMap } from '../nodes/YAMLMap.js';
+import type { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
+import { Schema } from '../schema/Schema.js';
 import { Directives } from './directives.js';
 export declare type Replacer = any[] | ((key: any, value: any) => unknown);
 export declare namespace Document {
     interface Parsed<T extends ParsedNode = ParsedNode> extends Document<T> {
-        range: [number, number];
-        /** The schema used with the document. */
-        schema: Schema;
+        range: Range;
     }
 }
 export declare class Document<T = unknown> {
     readonly [NODE_TYPE]: symbol;
-    /**
-     * Anchors associated with the document's nodes;
-     * also provides alias & merge node creators.
-     */
-    anchors: Anchors;
     /** A comment before this Document */
     commentBefore: string | null;
     /** A comment immediately after this Document */
@@ -30,6 +26,11 @@ export declare class Document<T = unknown> {
     /** Errors encountered during parsing. */
     errors: YAMLError[];
     options: Required<Omit<ParseOptions & DocumentOptions, 'lineCounter' | 'directives' | 'version'>>;
+    /**
+     * The [start, value-end, node-end] character offsets for the part of the
+     * source parsed into this document (undefined if not parsed).
+     */
+    range?: Range;
     /** The schema used with the document. Use `setSchema()` to change. */
     schema: Schema;
     /** Warnings encountered during parsing. */
@@ -38,17 +39,28 @@ export declare class Document<T = unknown> {
      * @param value - The initial value for the document, which will be wrapped
      *   in a Node container.
      */
-    constructor(value?: any, options?: Options);
-    constructor(value: any, replacer: null | Replacer, options?: Options);
+    constructor(value?: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+    constructor(value: any, replacer: null | Replacer, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
     /** Adds a value to the document. */
     add(value: any): void;
     /** Adds a value to the document. */
     addIn(path: Iterable<unknown>, value: unknown): void;
+    /**
+     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+     *
+     * If `node` already has an anchor, `name` is ignored.
+     * Otherwise, the `node.anchor` value will be set to `name`,
+     * or if an anchor with that name is already present in the document,
+     * `name` will be used as a prefix for a new unique anchor.
+     * If `name` is undefined, the generated anchor will use 'a' as a prefix.
+     */
+    createAlias(node: Scalar | YAMLMap | YAMLSeq, name?: string): Alias;
     /**
      * Convert any value into a `Node` using the current schema, recursively
      * turning objects into collections.
      */
-    createNode(value: unknown, { flow, keepUndefined, onTagObj, replacer, tag }?: CreateNodeOptions): Node;
+    createNode(value: unknown, options?: CreateNodeOptions): Node;
+    createNode(value: unknown, replacer: Replacer | CreateNodeOptions | null, options?: CreateNodeOptions): Node;
     /**
      * Convert a key and a value into a `Pair` using the current schema,
      * recursively wrapping all values as `Scalar` or `Collection` nodes.