yaml 2.0.0-5 → 2.0.0-9

package/browser/dist/compose/compose-doc.js

@@ -12,8 +12,8 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
         schema: doc.schema
     };
     const props = resolveProps(start, {
-        ctx,
         indicator: 'doc-start',
+        next: value || (end === null || end === void 0 ? void 0 : end[0]),
         offset,
         onError,
         startOnNewline: true

package/browser/dist/compose/compose-node.js

@@ -33,6 +33,8 @@ function composeNode(ctx, token, props, onError) {
             console.log(token);
             throw new Error(`Unsupporten token type: ${token.type}`);
     }
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment) {
@@ -41,6 +43,8 @@ function composeNode(ctx, token, props, onError) {
         else
             node.commentBefore = comment;
     }
+    if (ctx.options.keepSourceTokens)
+        node.srcToken = token;
     return node;
 }
 function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
@@ -51,8 +55,11 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
         source: ''
     };
     const node = composeScalar(ctx, token, tag, onError);
-    if (anchor)
+    if (anchor) {
         node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment)
@@ -61,6 +68,8 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
     const alias = new Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
     const valueEnd = offset + source.length;
     const re = resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];

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

@@ -19,7 +19,8 @@ function composeScalar(ctx, token, tagToken, onError) {
         scalar = isScalar(res) ? res : new Scalar(res);
     }
     catch (error) {
-        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg);
         scalar = new Scalar(value);
     }
     scalar.range = range;

package/browser/dist/compose/composer.js

@@ -15,6 +15,7 @@ function getErrorPos(src) {
     return [offset, offset + (typeof source === 'string' ? source.length : 1)];
 }
 function parsePrelude(prelude) {
+    var _a;
     let comment = '';
     let atComment = false;
     let afterEmptyLine = false;
@@ -24,12 +25,12 @@ function parsePrelude(prelude) {
             case '#':
                 comment +=
                     (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
-                        source.substring(1);
+                        (source.substring(1) || ' ');
                 atComment = true;
                 afterEmptyLine = false;
                 break;
             case '%':
-                if (prelude[i + 1][0] !== '#')
+                if (((_a = prelude[i + 1]) === null || _a === void 0 ? void 0 : _a[0]) !== '#')
                     i += 1;
                 atComment = false;
                 break;

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

@@ -2,17 +2,19 @@ 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 }, ctx, bm, onError) {
     var _a;
     const map = new YAMLMap(ctx.schema);
     let offset = bm.offset;
-    for (const { start, key, sep, value } of bm.items) {
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
         // key properties
         const keyProps = resolveProps(start, {
-            ctx,
             indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: true
@@ -46,10 +48,12 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
         const keyNode = key
             ? 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(sep || [], {
-            ctx,
             indicator: 'map-value-ind',
+            next: value,
             offset: keyNode.range[2],
             onError,
             startOnNewline: !key || key.type === 'block-scalar'
@@ -68,7 +72,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
             offset = valueNode.range[2];
-            map.items.push(new Pair(keyNode, valueNode));
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
         else {
             // key with no value
@@ -80,7 +87,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            map.items.push(new Pair(keyNode));
+            const pair = new Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
     }
     map.range = [bm.offset, offset, offset];

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

@@ -18,7 +18,7 @@ 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') : '';
+        const value = header.chomp === '+' ? '\n'.repeat(Math.max(0, lines.length - 1)) : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -149,7 +149,7 @@ 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(token, 'COMMENT_SPACE', message);
+                    onError(token, 'MISSING_CHAR', message);
                 }
                 length += token.source.length;
                 comment = token.source.substring(1);

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

@@ -6,8 +6,8 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
         const props = resolveProps(start, {
-            ctx,
             indicator: 'seq-item-ind',
+            next: value,
             offset,
             onError,
             startOnNewline: true

package/browser/dist/compose/resolve-end.js

@@ -11,8 +11,8 @@ function resolveEnd(end, offset, reqSpace, onError) {
                     break;
                 case 'comment': {
                     if (reqSpace && !hasSpace)
-                        onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
-                    const cb = source.substring(1);
+                        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

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

@@ -5,6 +5,7 @@ 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';
 
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
@@ -17,11 +18,12 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     coll.flow = true;
     let offset = fc.offset;
     for (let i = 0; i < fc.items.length; ++i) {
-        const { start, key, sep, value } = fc.items[i];
+        const collItem = fc.items[i];
+        const { start, key, sep, value } = collItem;
         const props = resolveProps(start, {
-            ctx,
             flow: fcName,
             indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: false
@@ -99,9 +101,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
             const valueProps = resolveProps(sep || [], {
-                ctx,
                 flow: fcName,
                 indicator: 'map-value-ind',
+                next: value,
                 offset: keyNode.range[2],
                 onError,
                 startOnNewline: false
@@ -144,8 +146,14 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair(keyNode, valueNode);
-            if (isMap)
-                coll.items.push(pair);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            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;
@@ -159,7 +167,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const [ce, ...ee] = fc.end;
     let cePos = offset;
     if (ce && ce.source === expectedEnd)
-        cePos += ce.source.length;
+        cePos = ce.offset + ce.source.length;
     else {
         onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
         if (ce && ce.source.length !== 1)

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

@@ -39,25 +39,31 @@ function resolveFlowScalar(scalar, strict, onError) {
     };
 }
 function plainValue(source, onError) {
-    let message = '';
+    let badChar = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            message = '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 '>': {
-            message = `Plain value cannot start with block scalar indicator ${source[0]}`;
+            badChar = `block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            message = `Plain value cannot start with reserved character ${source[0]}`;
+            badChar = `reserved character ${source[0]}`;
             break;
         }
     }
-    if (message)
-        onError(0, 'BAD_SCALAR_START', message);
+    if (badChar)
+        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
     return foldLines(source);
 }
 function singleQuotedValue(source, onError) {
@@ -129,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);
@@ -146,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 {

package/browser/dist/compose/resolve-props.js

@@ -1,16 +1,24 @@
-function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNewline }) {
+function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
     let comment = '';
     let commentSep = '';
     let hasNewline = false;
+    let reqSpace = false;
     let anchor = null;
     let tag = null;
     let comma = null;
     let found = null;
     let start = null;
     for (const token of tokens) {
+        if (reqSpace) {
+            if (token.type !== 'space' &&
+                token.type !== 'newline' &&
+                token.type !== 'comma')
+                onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+            reqSpace = false;
+        }
         switch (token.type) {
             case 'space':
                 // At the doc level, tabs at line start may be parsed
@@ -24,23 +32,29 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                 hasSpace = true;
                 break;
             case 'comment': {
-                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 (!hasSpace)
+                    onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                const cb = token.source.substring(1) || ' ';
                 if (!comment)
                     comment = cb;
                 else
                     comment += commentSep + cb;
                 commentSep = '';
+                atNewline = false;
                 break;
             }
             case 'newline':
-                if (atNewline && !comment)
-                    spaceBefore = true;
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
-                commentSep += token.source;
                 break;
             case 'anchor':
                 if (anchor)
@@ -50,6 +64,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             case 'tag': {
                 if (tag)
@@ -59,6 +74,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             }
             case indicator:
@@ -87,6 +103,13 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
     }
     const last = tokens[tokens.length - 1];
     const end = last ? last.offset + last.source.length : offset;
+    if (reqSpace &&
+        next &&
+        next.type !== 'space' &&
+        next.type !== 'newline' &&
+        next.type !== 'comma' &&
+        (next.type !== 'scalar' || next.source !== ''))
+        onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
     return {
         comma,
         found,

package/browser/dist/compose/util-map-includes.js

@@ -0,0 +1,17 @@
+import { isScalar } from '../nodes/Node.js';
+
+function mapIncludes(ctx, items, search) {
+    const { uniqueKeys } = ctx.options;
+    if (uniqueKeys === false)
+        return false;
+    const isEqual = typeof uniqueKeys === 'function'
+        ? uniqueKeys
+        : (a, b) => a === b ||
+            (isScalar(a) &&
+                isScalar(b) &&
+                a.value === b.value &&
+                !(a.value === '<<' && ctx.schema.merge));
+    return items.some(pair => isEqual(pair.key, search));
+}
+
+export { mapIncludes };

package/browser/dist/doc/Document.js

@@ -1,6 +1,6 @@
 import { Alias } from '../nodes/Alias.js';
 import { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';
-import { NODE_TYPE, DOC, isCollection, isScalar } from '../nodes/Node.js';
+import { NODE_TYPE, DOC, isNode, isCollection, isScalar } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
 import { toJS } from '../nodes/toJS.js';
 import { defaultOptions } from '../options.js';
@@ -48,6 +48,29 @@ class Document {
             this.contents = this.createNode(value, _replacer, options);
         }
     }
+    /**
+     * Create a deep copy of this Document and its contents.
+     *
+     * Custom Node values that inherit from `Object` still refer to their original instances.
+     */
+    clone() {
+        const copy = Object.create(Document.prototype, {
+            [NODE_TYPE]: { value: DOC }
+        });
+        copy.commentBefore = this.commentBefore;
+        copy.comment = this.comment;
+        copy.errors = this.errors.slice();
+        copy.warnings = this.warnings.slice();
+        copy.options = Object.assign({}, this.options);
+        copy.directives = this.directives.clone();
+        copy.schema = this.schema.clone();
+        copy.contents = isNode(this.contents)
+            ? this.contents.clone(copy.schema)
+            : this.contents;
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
     /** Adds a value to the document. */
     add(value) {
         if (assertCollection(this.contents))
@@ -92,9 +115,10 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
         const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || 'a');
         const ctx = {
+            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
             keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
             onAnchor,
             onTagObj,

package/browser/dist/doc/createNode.js

@@ -1,5 +1,5 @@
 import { Alias } from '../nodes/Alias.js';
-import { isNode, isPair, MAP, SEQ } from '../nodes/Node.js';
+import { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
@@ -15,6 +15,8 @@ function findTagObject(value, tagName, tags) {
 }
 function createNode(value, tagName, ctx) {
     var _a, _b;
+    if (isDocument(value))
+        value = value.contents;
     if (isNode(value))
         return value;
     if (isPair(value)) {
@@ -30,11 +32,11 @@ function createNode(value, tagName, ctx) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
     // Detect duplicate references to the same object & use Alias nodes for all
     // after first. The `ref` wrapper allows for circular references to resolve.
     let ref = undefined;
-    if (value && typeof value === 'object') {
+    if (aliasDuplicateObjects && value && typeof value === 'object') {
         ref = sourceObjects.get(value);
         if (ref) {
             if (!ref.anchor)
@@ -52,8 +54,12 @@ function createNode(value, tagName, ctx) {
     if (!tagObj) {
         if (value && typeof value.toJSON === 'function')
             value = value.toJSON();
-        if (!value || typeof value !== 'object')
-            return new Scalar(value);
+        if (!value || typeof value !== 'object') {
+            const node = new Scalar(value);
+            if (ref)
+                ref.node = node;
+            return node;
+        }
         tagObj =
             value instanceof Map
                 ? schema[MAP]

package/browser/dist/doc/directives.js

@@ -20,6 +20,11 @@ class Directives {
         this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
         this.tags = Object.assign({}, Directives.defaultTags, tags);
     }
+    clone() {
+        const copy = new Directives(this.yaml, this.tags);
+        copy.marker = this.marker;
+        return copy;
+    }
     /**
      * During parsing, get a Directives instance for the current document and
      * update the stream state according to the current version's spec.