yaml 2.0.0-4 → 2.0.0-8

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

@@ -1,90 +1,125 @@
-function resolveProps(doc, tokens, startOnNewline, indicator, offset, onError) {
-    let length = 0;
+function resolveProps(tokens, { flow, indicator, next, 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 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 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');
-                const cb = token.source.substring(1);
-                if (!hasComment)
+                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 += sep + cb;
-                hasComment = true;
-                sep = '';
+                    comment += commentSep + cb;
+                commentSep = '';
+                atNewline = false;
                 break;
             }
             case 'newline':
-                if (atNewline && !hasComment)
-                    spaceBefore = true;
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
-                sep += 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;
+                reqSpace = true;
                 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;
+                reqSpace = true;
                 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;
+    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,
         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/browser/dist/compose/util-contains-newline.js

@@ -6,21 +6,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/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,13 +1,13 @@
 import { Alias } from '../nodes/Alias.js';
 import { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';
-import { NODE_TYPE, DOC, isCollection, isScalar, isNode } 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';
-import { addComment } from '../stringify/addComment.js';
-import { createStringifyContext, stringify } from '../stringify/stringify.js';
-import { Anchors } from './Anchors.js';
-import { Schema } from './Schema.js';
+import { Schema } from '../schema/Schema.js';
+import { stringify } from '../stringify/stringify.js';
+import { stringifyDocument } from '../stringify/stringifyDocument.js';
+import { anchorNames, findNewAnchor, createNodeAnchors } from './anchors.js';
 import { applyReviver } from './applyReviver.js';
 import { createNode } from './createNode.js';
 import { Directives } from './directives.js';
@@ -23,7 +23,7 @@ class Document {
         /** Warnings encountered during parsing. */
         this.warnings = [];
         Object.defineProperty(this, NODE_TYPE, { value: DOC });
-        let _replacer = undefined;
+        let _replacer = null;
         if (typeof replacer === 'function' || Array.isArray(replacer)) {
             _replacer = replacer;
         }
@@ -33,7 +33,6 @@ class Document {
         }
         const opt = Object.assign({}, defaultOptions, options);
         this.options = opt;
-        this.anchors = new Anchors(this.options.anchorPrefix);
         let { version } = opt;
         if (options === null || options === void 0 ? void 0 : options.directives) {
             this.directives = options.directives.atDocument();
@@ -43,10 +42,34 @@ class Document {
         else
             this.directives = new Directives({ version });
         this.setSchema(version, options);
-        this.contents =
-            value === undefined
-                ? null
-                : this.createNode(value, { replacer: _replacer });
+        if (value === undefined)
+            this.contents = null;
+        else {
+            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) {
@@ -59,48 +82,54 @@ class Document {
             this.contents.addIn(path, value);
     }
     /**
-     * Convert any value into a `Node` using the current schema, recursively
-     * turning objects into collections.
+     * 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.
      */
-    createNode(value, { flow, keepUndefined, onTagObj, replacer, tag } = {}) {
-        if (typeof replacer === 'function')
+    createAlias(node, name) {
+        if (!node.anchor) {
+            const prev = anchorNames(this);
+            node.anchor =
+                !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;
+        }
+        return new Alias(node.anchor);
+    }
+    createNode(value, replacer, options) {
+        let _replacer = undefined;
+        if (typeof replacer === 'function') {
             value = replacer.call({ '': value }, '', value);
+            _replacer = replacer;
+        }
         else if (Array.isArray(replacer)) {
             const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;
             const asStr = replacer.filter(keyToStr).map(String);
             if (asStr.length > 0)
                 replacer = replacer.concat(asStr);
+            _replacer = replacer;
         }
-        if (typeof keepUndefined !== 'boolean')
-            keepUndefined = !!this.options.keepUndefined;
-        const aliasNodes = [];
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || 'a');
         const ctx = {
-            keepUndefined,
-            onAlias(source) {
-                // These get fixed later in createNode()
-                const alias = new Alias(source);
-                aliasNodes.push(alias);
-                return alias;
-            },
+            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
+            keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
+            onAnchor,
             onTagObj,
-            prevObjects: new Map(),
-            replacer,
-            schema: this.schema
+            replacer: _replacer,
+            schema: this.schema,
+            sourceObjects
         };
         const node = createNode(value, tag, ctx);
-        for (const alias of aliasNodes) {
-            // With circular references, the source node is only resolved after all of
-            // its child nodes are. This is why anchors are set only after all of the
-            // nodes have been created.
-            alias.source = alias.source.node;
-            let name = this.anchors.getName(alias.source);
-            if (!name) {
-                name = this.anchors.newName();
-                this.anchors.map[name] = alias.source;
-            }
-        }
         if (flow && isCollection(node))
             node.flow = true;
+        setAnchors();
         return node;
     }
     /**
@@ -108,8 +137,8 @@ class Document {
      * recursively wrapping all values as `Scalar` or `Collection` nodes.
      */
     createPair(key, value, options = {}) {
-        const k = this.createNode(key, options);
-        const v = this.createNode(value, options);
+        const k = this.createNode(key, null, options);
+        const v = this.createNode(value, null, options);
         return new Pair(k, v);
     }
     /**
@@ -223,10 +252,8 @@ class Document {
     }
     // json & jsonArg are only used from toJSON()
     toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
-        const anchorNodes = Object.values(this.anchors.map).map(node => [node, { alias: [], aliasCount: 0, count: 1 }]);
-        const anchors = anchorNodes.length > 0 ? new Map(anchorNodes) : null;
         const ctx = {
-            anchors,
+            anchors: new Map(),
             doc: this,
             keep: !json,
             mapAsMap: mapAsMap === true,
@@ -235,8 +262,8 @@ class Document {
             stringify
         };
         const res = toJS(this.contents, jsonArg || '', ctx);
-        if (typeof onAnchor === 'function' && anchors)
-            for (const { count, res } of anchors.values())
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
                 onAnchor(res, count);
         return typeof reviver === 'function'
             ? applyReviver(reviver, { '': res }, '', res)
@@ -260,59 +287,7 @@ class Document {
             const s = JSON.stringify(options.indent);
             throw new Error(`"indent" option must be a positive integer, not ${s}`);
         }
-        const lines = [];
-        let hasDirectives = options.directives === true;
-        if (options.directives !== false) {
-            const dir = this.directives.toString(this);
-            if (dir) {
-                lines.push(dir);
-                hasDirectives = true;
-            }
-            else if (this.directives.marker)
-                hasDirectives = true;
-        }
-        if (hasDirectives)
-            lines.push('---');
-        if (this.commentBefore) {
-            if (lines.length !== 1)
-                lines.unshift('');
-            lines.unshift(this.commentBefore.replace(/^/gm, '#'));
-        }
-        const ctx = createStringifyContext(this, options);
-        let chompKeep = false;
-        let contentComment = null;
-        if (this.contents) {
-            if (isNode(this.contents)) {
-                if (this.contents.spaceBefore && hasDirectives)
-                    lines.push('');
-                if (this.contents.commentBefore)
-                    lines.push(this.contents.commentBefore.replace(/^/gm, '#'));
-                // top-level block scalars need to be indented if followed by a comment
-                ctx.forceBlockIndent = !!this.comment;
-                contentComment = this.contents.comment;
-            }
-            const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
-            let body = stringify(this.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(this.contents, ctx));
-        }
-        if (this.comment) {
-            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
-                lines.push('');
-            lines.push(this.comment.replace(/^/gm, '#'));
-        }
-        return lines.join('\n') + '\n';
+        return stringifyDocument(this, options);
     }
 }
 function assertCollection(contents) {

package/browser/dist/doc/anchors.js

@@ -0,0 +1,72 @@
+import { isScalar, isCollection } from '../nodes/Node.js';
+import { visit } from '../visit.js';
+
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+function anchorIsValid(anchor) {
+    if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+        const sa = JSON.stringify(anchor);
+        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;
+        throw new Error(msg);
+    }
+    return true;
+}
+function anchorNames(root) {
+    const anchors = new Set();
+    visit(root, {
+        Value(_key, node) {
+            if (node.anchor)
+                anchors.add(node.anchor);
+        }
+    });
+    return anchors;
+}
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+function findNewAnchor(prefix, exclude) {
+    for (let i = 1; true; ++i) {
+        const name = `${prefix}${i}`;
+        if (!exclude.has(name))
+            return name;
+    }
+}
+function createNodeAnchors(doc, prefix) {
+    const aliasObjects = [];
+    const sourceObjects = new Map();
+    let prevAnchors = null;
+    return {
+        onAnchor(source) {
+            aliasObjects.push(source);
+            if (!prevAnchors)
+                prevAnchors = anchorNames(doc);
+            const anchor = findNewAnchor(prefix, prevAnchors);
+            prevAnchors.add(anchor);
+            return anchor;
+        },
+        /**
+         * With circular references, the source node is only resolved after all
+         * of its child nodes are. This is why anchors are set only after all of
+         * the nodes have been created.
+         */
+        setAnchors() {
+            for (const source of aliasObjects) {
+                const ref = sourceObjects.get(source);
+                if (typeof ref === 'object' &&
+                    ref.anchor &&
+                    (isScalar(ref.node) || isCollection(ref.node))) {
+                    ref.node.anchor = ref.anchor;
+                }
+                else {
+                    const error = new Error('Failed to resolve repeated object (this should not happen)');
+                    error.source = source;
+                    throw error;
+                }
+            }
+        },
+        sourceObjects
+    };
+}
+
+export { anchorIsValid, anchorNames, createNodeAnchors, findNewAnchor };

package/browser/dist/doc/createNode.js

@@ -1,4 +1,5 @@
-import { isNode, isPair } from '../nodes/Node.js';
+import { Alias } from '../nodes/Alias.js';
+import { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
@@ -14,10 +15,12 @@ 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)) {
-        const map = (_b = (_a = ctx.schema.map).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
+        const map = (_b = (_a = ctx.schema[MAP]).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
         map.items.push(value);
         return map;
     }
@@ -29,39 +32,52 @@ function createNode(value, tagName, ctx) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { onAlias, onTagObj, prevObjects } = ctx;
-    const { map, seq, tags } = ctx.schema;
+    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 (aliasDuplicateObjects && value && typeof value === 'object') {
+        ref = sourceObjects.get(value);
+        if (ref) {
+            if (!ref.anchor)
+                ref.anchor = onAnchor(value);
+            return new Alias(ref.anchor);
+        }
+        else {
+            ref = { anchor: null, node: null };
+            sourceObjects.set(value, ref);
+        }
+    }
     if (tagName && tagName.startsWith('!!'))
         tagName = defaultTagPrefix + tagName.slice(2);
-    let tagObj = findTagObject(value, tagName, tags);
+    let tagObj = findTagObject(value, tagName, schema.tags);
     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 ? map : Symbol.iterator in Object(value) ? seq : map;
+            value instanceof Map
+                ? schema[MAP]
+                : Symbol.iterator in Object(value)
+                    ? schema[SEQ]
+                    : schema[MAP];
     }
     if (onTagObj) {
         onTagObj(tagObj);
         delete ctx.onTagObj;
     }
-    // Detect duplicate references to the same object & use Alias nodes for all
-    // after first. The `ref` wrapper allows for circular references to resolve.
-    const ref = { value: undefined, node: undefined };
-    if (value && typeof value === 'object') {
-        const prev = prevObjects.get(value);
-        if (prev)
-            return onAlias(prev);
-        ref.value = value;
-        prevObjects.set(value, ref);
-    }
     const node = (tagObj === null || tagObj === void 0 ? void 0 : tagObj.createNode)
         ? tagObj.createNode(ctx.schema, value, ctx)
         : new Scalar(value);
     if (tagName)
         node.tag = tagName;
-    ref.node = node;
+    if (ref)
+        ref.node = node;
     return node;
 }
 

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.