yaml 2.0.0-4 → 2.0.0-8

package/browser/dist/compose/resolve-block-map.js

@@ -2,26 +2,31 @@ import { Pair } from '../nodes/Pair.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.js';
+import { mapIncludes } from './util-map-includes.js';
 
 const startColMsg = 'All mapping items must start at the same column';
-function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items, offset }, anchor, onError) {
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
-    const start = offset;
-    const map = new YAMLMap(doc.schema);
-    if (anchor)
-        doc.anchors.setAnchor(map, anchor);
-    for (const { start, key, sep, value } of items) {
+    const map = new YAMLMap(ctx.schema);
+    let offset = bm.offset;
+    for (const { start, key, sep, value } of bm.items) {
         // key properties
-        const keyProps = resolveProps(doc, start, true, 'explicit-key-ind', offset, onError);
+        const keyProps = resolveProps(start, {
+            indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            offset,
+            onError,
+            startOnNewline: true
+        });
         const implicitKey = !keyProps.found;
         if (implicitKey) {
             if (key) {
                 if (key.type === 'block-seq')
-                    onError(offset, 'A block sequence may not be used as an implicit map key');
-                else if ('indent' in key && key.indent !== indent)
-                    onError(offset, startColMsg);
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'A block sequence may not be used as an implicit map key');
+                else if ('indent' in key && key.indent !== bm.indent)
+                    onError(offset, 'BAD_INDENT', startColMsg);
             }
-            if (!keyProps.anchor && !keyProps.tagName && !sep) {
+            if (!keyProps.anchor && !keyProps.tag && !sep) {
                 // TODO: assert being at last item?
                 if (keyProps.comment) {
                     if (map.comment)
@@ -32,39 +37,46 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items
                 continue;
             }
         }
-        else if (((_a = keyProps.found) === null || _a === void 0 ? void 0 : _a.indent) !== indent)
-            onError(offset, startColMsg);
-        offset += keyProps.length;
+        else if (((_a = keyProps.found) === null || _a === void 0 ? void 0 : _a.indent) !== bm.indent)
+            onError(offset, 'BAD_INDENT', startColMsg);
         if (implicitKey && containsNewline(key))
-            onError(offset, 'Implicit keys need to be on a single line');
+            onError(key, // checked by containsNewline()
+            'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
         // key value
-        const keyStart = offset;
+        const keyStart = keyProps.end;
         const keyNode = key
-            ? composeNode(doc, key, keyProps, onError)
-            : composeEmptyNode(doc, offset, start, null, keyProps, onError);
-        offset = keyNode.range[1];
+            ? composeNode(ctx, key, keyProps, onError)
+            : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+        if (mapIncludes(ctx, map.items, keyNode))
+            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
-        const valueProps = resolveProps(doc, sep || [], !key || key.type === 'block-scalar', 'map-value-ind', offset, onError);
-        offset += valueProps.length;
+        const valueProps = resolveProps(sep || [], {
+            indicator: 'map-value-ind',
+            next: value,
+            offset: keyNode.range[2],
+            onError,
+            startOnNewline: !key || key.type === 'block-scalar'
+        });
+        offset = valueProps.end;
         if (valueProps.found) {
             if (implicitKey) {
                 if ((value === null || value === void 0 ? void 0 : value.type) === 'block-map' && !valueProps.hasNewline)
-                    onError(offset, 'Nested mappings are not allowed in compact mappings');
-                if (doc.options.strict &&
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings');
+                if (ctx.options.strict &&
                     keyProps.start < valueProps.found.offset - 1024)
-                    onError(offset, 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
+                    onError(keyNode.range, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
             }
             // value value
             const valueNode = value
-                ? composeNode(doc, value, valueProps, onError)
-                : composeEmptyNode(doc, offset, sep, null, valueProps, onError);
-            offset = valueNode.range[1];
+                ? composeNode(ctx, value, valueProps, onError)
+                : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+            offset = valueNode.range[2];
             map.items.push(new Pair(keyNode, valueNode));
         }
         else {
             // key with no value
             if (implicitKey)
-                onError(keyStart, 'Implicit map keys need to be followed by map values');
+                onError(keyNode.range, 'MISSING_CHAR', 'Implicit map keys need to be followed by map values');
             if (valueProps.comment) {
                 if (keyNode.comment)
                     keyNode.comment += '\n' + valueProps.comment;
@@ -74,7 +86,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, doc, { indent, items
             map.items.push(new Pair(keyNode));
         }
     }
-    map.range = [start, offset];
+    map.range = [bm.offset, offset, offset];
     return map;
 }
 

package/browser/dist/compose/resolve-block-scalar.js

@@ -1,9 +1,10 @@
 import { Scalar } from '../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.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
     const lines = scalar.source ? splitLines(scalar.source) : [];
     // determine the end of content & start of chomping
@@ -18,10 +19,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;
@@ -36,7 +37,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;
@@ -63,7 +64,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.BLOCK_LITERAL) {
@@ -105,17 +106,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];
@@ -136,7 +133,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;
@@ -152,19 +149,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/browser/dist/compose/resolve-block-seq.js

@@ -1,20 +1,24 @@
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveProps } from './resolve-props.js';
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, doc, { items, offset }, anchor, onError) {
-    const start = offset;
-    const seq = new YAMLSeq(doc.schema);
-    if (anchor)
-        doc.anchors.setAnchor(seq, anchor);
-    for (const { start, value } of items) {
-        const props = resolveProps(doc, start, true, 'seq-item-ind', offset, onError);
-        offset += props.length;
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
+    const seq = new YAMLSeq(ctx.schema);
+    let offset = bs.offset;
+    for (const { start, value } of bs.items) {
+        const props = 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?
@@ -24,12 +28,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/browser/dist/compose/resolve-end.js

@@ -2,32 +2,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;
         }