yaml 2.0.0-4 → 2.0.0-5

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,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(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 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 = '';
@@ -112,7 +136,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;
             }
         }
@@ -130,7 +154,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 +202,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/browser/dist/compose/resolve-props.js

@@ -1,90 +1,102 @@
-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/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/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, 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,11 @@ 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);
+        }
     }
     /** Adds a value to the document. */
     add(value) {
@@ -59,48 +59,53 @@ 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;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
         }
-        if (typeof keepUndefined !== 'boolean')
-            keepUndefined = !!this.options.keepUndefined;
-        const aliasNodes = [];
+        const { 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;
-            },
+            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 +113,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 +228,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 +238,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 +263,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 };