yaml 2.0.0-4 → 2.0.0-8

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

@@ -1,229 +1,188 @@
-import { isNode, isPair } from '../nodes/Node.js';
+import { isPair } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.js';
+import { mapIncludes } from './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(doc.schema) : new YAMLSeq(doc.schema);
+    const fcName = isMap ? 'flow map' : 'flow sequence';
+    const coll = isMap
+        ? new YAMLMap(ctx.schema)
+        : new 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(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 && 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(key, value) : new 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(doc.schema);
-                map.flow = true;
-                map.items.push(new 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 (isPair(node))
-                            node = node.value || node.key;
-                        /* istanbul ignore else should not happen */
-                        if (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 (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(doc.schema);
-                        map.flow = true;
-                        map.items.push(new 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 (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(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(keyNode, valueNode);
+            if (isMap) {
+                const map = coll;
+                if (mapIncludes(ctx, map.items, keyNode))
+                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+                map.items.push(pair);
+            }
+            else {
+                const map = new 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(ee, offset, doc.options.strict, onError);
-        if (end.comment)
-            coll.comment = comment;
-        offset = end.offset;
+        const end = 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/browser/dist/compose/resolve-flow-scalar.js

@@ -1,10 +1,11 @@
 import { Scalar } from '../nodes/Scalar.js';
 import { resolveEnd } from './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.PLAIN;
@@ -20,68 +21,97 @@ 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(end, 0, strict, _onError);
+    const valueEnd = offset + source.length;
+    const re = 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 badChar = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            onError(0, 'Plain value cannot start with a tab character');
+            badChar = 'a tab character';
+            break;
+        case ',':
+            badChar = 'flow indicator character ,';
+            break;
+        case '%':
+            badChar = 'directive indicator character %';
             break;
         case '|':
         case '>': {
-            const message = `Plain value cannot start with block scalar indicator ${source[0]}`;
-            onError(0, message);
+            badChar = `block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            const message = `Plain value cannot start with reserved character ${source[0]}`;
-            onError(0, message);
+            badChar = `reserved character ${source[0]}`;
             break;
         }
     }
-    return foldLines(source.trim());
+    if (badChar)
+        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+    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 = '';
@@ -105,6 +135,12 @@ function doubleQuotedValue(source, onError) {
                 while (next === ' ' || next === '\t')
                     next = source[++i + 1];
             }
+            else if (next === '\r' && source[i + 1] === '\n') {
+                // skip escaped CRLF newlines, but still trim the following line
+                next = source[++i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
             else if (next === 'x' || next === 'u' || next === 'U') {
                 const length = { x: 2, u: 4, U: 8 }[next];
                 res += parseCharCode(source, i + 1, length, onError);
@@ -112,7 +148,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;
             }
         }
@@ -122,7 +158,7 @@ function doubleQuotedValue(source, onError) {
             let next = source[i + 1];
             while (next === ' ' || next === '\t')
                 next = source[++i + 1];
-            if (next !== '\n')
+            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
                 res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
         }
         else {
@@ -130,7 +166,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;
 }
 /**
@@ -178,7 +214,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);