yaml 2.0.0-8 → 2.0.1

package/browser/dist/parse/parser.js

@@ -7,7 +7,7 @@ function includesToken(list, type) {
             return true;
     return false;
 }
-function includesNonEmpty(list) {
+function findNonEmptyIndex(list) {
     for (let i = 0; i < list.length; ++i) {
         switch (list[i].type) {
             case 'space':
@@ -15,10 +15,10 @@ function includesNonEmpty(list) {
             case 'newline':
                 break;
             default:
-                return true;
+                return i;
         }
     }
-    return false;
+    return -1;
 }
 function isFlowToken(token) {
     switch (token === null || token === void 0 ? void 0 : token.type) {
@@ -33,12 +33,13 @@ function isFlowToken(token) {
     }
 }
 function getPrevProps(parent) {
+    var _a;
     switch (parent.type) {
         case 'document':
             return parent.start;
         case 'block-map': {
             const it = parent.items[parent.items.length - 1];
-            return it.sep || it.start;
+            return (_a = it.sep) !== null && _a !== void 0 ? _a : it.start;
         }
         case 'block-seq':
             return parent.items[parent.items.length - 1].start;
@@ -203,6 +204,7 @@ class Parser {
                         this.indent += source.length;
                     break;
                 case 'doc-mode':
+                case 'flow-error-end':
                     return;
                 default:
                     this.atNewLine = false;
@@ -264,7 +266,7 @@ class Parser {
         return this.stack[this.stack.length - n];
     }
     *pop(error) {
-        const token = error || this.stack.pop();
+        const token = error !== null && error !== void 0 ? error : this.stack.pop();
         /* istanbul ignore if should not happen */
         if (!token) {
             const message = 'Tried to pop an empty stack';
@@ -275,9 +277,14 @@ class Parser {
         }
         else {
             const top = this.peek(1);
-            // For these, parent indent is needed instead of own
-            if (token.type === 'block-scalar' || token.type === 'flow-collection')
-                token.indent = 'indent' in top ? top.indent : -1;
+            if (token.type === 'block-scalar') {
+                // Block scalars use their parent rather than header indent
+                token.indent = 'indent' in top ? top.indent : 0;
+            }
+            else if (token.type === 'flow-collection' && top.type === 'document') {
+                // Ignore all indent for top-level flow collections
+                token.indent = 0;
+            }
             if (token.type === 'flow-collection')
                 fixFlowSeqItems(token);
             switch (top.type) {
@@ -336,7 +343,7 @@ class Parser {
                     !last.sep &&
                     !last.value &&
                     last.start.length > 0 &&
-                    !includesNonEmpty(last.start) &&
+                    findNonEmptyIndex(last.start) === -1 &&
                     (token.indent === 0 ||
                         last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) {
                     if (top.type === 'document')
@@ -384,7 +391,7 @@ class Parser {
             return yield* this.lineEnd(doc);
         switch (this.type) {
             case 'doc-start': {
-                if (includesNonEmpty(doc.start)) {
+                if (findNonEmptyIndex(doc.start) !== -1) {
                     yield* this.pop();
                     yield* this.step();
                 }
@@ -478,17 +485,21 @@ class Parser {
                     else
                         map.items.push({ start: [this.sourceToken] });
                 }
-                else if (it.sep)
+                else if (it.sep) {
                     it.sep.push(this.sourceToken);
-                else
+                }
+                else {
                     it.start.push(this.sourceToken);
+                }
                 return;
             case 'space':
             case 'comment':
-                if (it.value)
+                if (it.value) {
                     map.items.push({ start: [this.sourceToken] });
-                else if (it.sep)
+                }
+                else if (it.sep) {
                     it.sep.push(this.sourceToken);
+                }
                 else {
                     if (this.atIndentedComment(it.start, map.indent)) {
                         const prev = map.items[map.items.length - 2];
@@ -505,66 +516,132 @@ class Parser {
                 return;
         }
         if (this.indent >= map.indent) {
-            const atNextItem = !this.onKeyLine &&
-                this.indent === map.indent &&
-                (it.sep || includesNonEmpty(it.start));
+            const atNextItem = !this.onKeyLine && this.indent === map.indent && it.sep;
+            // For empty nodes, assign newline-separated not indented empty tokens to following node
+            let start = [];
+            if (atNextItem && it.sep && !it.value) {
+                const nl = [];
+                for (let i = 0; i < it.sep.length; ++i) {
+                    const st = it.sep[i];
+                    switch (st.type) {
+                        case 'newline':
+                            nl.push(i);
+                            break;
+                        case 'space':
+                            break;
+                        case 'comment':
+                            if (st.indent > map.indent)
+                                nl.length = 0;
+                            break;
+                        default:
+                            nl.length = 0;
+                    }
+                }
+                if (nl.length >= 2)
+                    start = it.sep.splice(nl[1]);
+            }
             switch (this.type) {
                 case 'anchor':
                 case 'tag':
                     if (atNextItem || it.value) {
-                        map.items.push({ start: [this.sourceToken] });
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
                         this.onKeyLine = true;
                     }
-                    else if (it.sep)
+                    else if (it.sep) {
                         it.sep.push(this.sourceToken);
-                    else
+                    }
+                    else {
                         it.start.push(this.sourceToken);
+                    }
                     return;
                 case 'explicit-key-ind':
-                    if (!it.sep && !includesToken(it.start, 'explicit-key-ind'))
+                    if (!it.sep && !includesToken(it.start, 'explicit-key-ind')) {
                         it.start.push(this.sourceToken);
-                    else if (atNextItem || it.value)
-                        map.items.push({ start: [this.sourceToken] });
-                    else
+                    }
+                    else if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
+                    }
+                    else {
                         this.stack.push({
                             type: 'block-map',
                             offset: this.offset,
                             indent: this.indent,
                             items: [{ start: [this.sourceToken] }]
                         });
+                    }
                     this.onKeyLine = true;
                     return;
                 case 'map-value-ind':
-                    if (!it.sep)
-                        Object.assign(it, { key: null, sep: [this.sourceToken] });
-                    else if (it.value ||
-                        (atNextItem && !includesToken(it.start, 'explicit-key-ind')))
-                        map.items.push({ start: [], key: null, sep: [this.sourceToken] });
-                    else if (includesToken(it.sep, 'map-value-ind'))
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start: [], key: null, sep: [this.sourceToken] }]
-                        });
-                    else if (includesToken(it.start, 'explicit-key-ind') &&
-                        isFlowToken(it.key) &&
-                        !includesToken(it.sep, 'newline')) {
-                        const start = getFirstKeyStartProps(it.start);
-                        const key = it.key;
-                        const sep = it.sep;
-                        sep.push(this.sourceToken);
-                        // @ts-ignore type guard is wrong here
-                        delete it.key, delete it.sep;
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start, key, sep }]
-                        });
+                    if (includesToken(it.start, 'explicit-key-ind')) {
+                        if (!it.sep) {
+                            if (includesToken(it.start, 'newline')) {
+                                Object.assign(it, { key: null, sep: [this.sourceToken] });
+                            }
+                            else {
+                                const start = getFirstKeyStartProps(it.start);
+                                this.stack.push({
+                                    type: 'block-map',
+                                    offset: this.offset,
+                                    indent: this.indent,
+                                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                                });
+                            }
+                        }
+                        else if (it.value) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else if (isFlowToken(it.key) &&
+                            !includesToken(it.sep, 'newline')) {
+                            const start = getFirstKeyStartProps(it.start);
+                            const key = it.key;
+                            const sep = it.sep;
+                            sep.push(this.sourceToken);
+                            // @ts-expect-error type guard is wrong here
+                            delete it.key, delete it.sep;
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key, sep }]
+                            });
+                        }
+                        else if (start.length > 0) {
+                            // Not actually at next item
+                            it.sep = it.sep.concat(start, this.sourceToken);
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    else {
+                        if (!it.sep) {
+                            Object.assign(it, { key: null, sep: [this.sourceToken] });
+                        }
+                        else if (it.value || atNextItem) {
+                            map.items.push({ start, key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
                     }
-                    else
-                        it.sep.push(this.sourceToken);
                     this.onKeyLine = true;
                     return;
                 case 'alias':
@@ -573,7 +650,7 @@ class Parser {
                 case 'double-quoted-scalar': {
                     const fs = this.flowScalar(this.type);
                     if (atNextItem || it.value) {
-                        map.items.push({ start: [], key: fs, sep: [] });
+                        map.items.push({ start, key: fs, sep: [] });
                         this.onKeyLine = true;
                     }
                     else if (it.sep) {
@@ -590,8 +667,9 @@ class Parser {
                     if (bv) {
                         if (atNextItem &&
                             bv.type !== 'block-seq' &&
-                            includesToken(it.start, 'explicit-key-ind'))
-                            map.items.push({ start: [] });
+                            includesToken(it.start, 'explicit-key-ind')) {
+                            map.items.push({ start });
+                        }
                         this.stack.push(bv);
                         return;
                     }
@@ -728,7 +806,7 @@ class Parser {
         else {
             const parent = this.peek(2);
             if (parent.type === 'block-map' &&
-                (this.type === 'map-value-ind' ||
+                ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
                     (this.type === 'newline' &&
                         !parent.items[parent.items.length - 1].sep))) {
                 yield* this.pop();

package/browser/dist/public-api.js

@@ -6,10 +6,8 @@ import { LineCounter } from './parse/line-counter.js';
 import { Parser } from './parse/parser.js';
 
 function parseOptions(options) {
-    const prettyErrors = !options || options.prettyErrors !== false;
-    const lineCounter = (options && options.lineCounter) ||
-        (prettyErrors && new LineCounter()) ||
-        null;
+    const prettyErrors = options.prettyErrors !== false;
+    const lineCounter = options.lineCounter || (prettyErrors && new LineCounter()) || null;
     return { lineCounter, prettyErrors };
 }
 /**
@@ -77,6 +75,7 @@ function parse(src, reviver, options) {
     return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
 function stringify(value, replacer, options) {
+    var _a;
     let _replacer = null;
     if (typeof replacer === 'function' || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -91,7 +90,7 @@ function stringify(value, replacer, options) {
         options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };
     }
     if (value === undefined) {
-        const { keepUndefined } = options || replacer || {};
+        const { keepUndefined } = (_a = options !== null && options !== void 0 ? options : replacer) !== null && _a !== void 0 ? _a : {};
         if (!keepUndefined)
             return undefined;
     }

package/browser/dist/schema/Schema.js

@@ -2,21 +2,31 @@ import { MAP, SCALAR, SEQ } from '../nodes/Node.js';
 import { map } from './common/map.js';
 import { seq } from './common/seq.js';
 import { string } from './common/string.js';
-import { coreKnownTags, getTags } from './tags.js';
+import { getTags, coreKnownTags } from './tags.js';
 
 const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 class Schema {
-    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }) {
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+        this.compat = Array.isArray(compat)
+            ? getTags(compat, 'compat')
+            : compat
+                ? getTags(null, compat)
+                : null;
         this.merge = !!merge;
-        this.name = schema || 'core';
+        this.name = (typeof schema === 'string' && schema) || 'core';
         this.knownTags = resolveKnownTags ? coreKnownTags : {};
         this.tags = getTags(customTags, this.name);
+        this.toStringOptions = toStringDefaults !== null && toStringDefaults !== void 0 ? toStringDefaults : null;
         Object.defineProperty(this, MAP, { value: map });
         Object.defineProperty(this, SCALAR, { value: string });
         Object.defineProperty(this, SEQ, { value: seq });
         // Used by createMap()
         this.sortMapEntries =
-            sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
+            typeof sortMapEntries === 'function'
+                ? sortMapEntries
+                : sortMapEntries === true
+                    ? sortMapEntriesByKey
+                    : null;
     }
     clone() {
         const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));

package/browser/dist/schema/common/null.js

@@ -7,7 +7,9 @@ const nullTag = {
     tag: 'tag:yaml.org,2002:null',
     test: /^(?:~|[Nn]ull|NULL)?$/,
     resolve: () => new Scalar(null),
-    stringify: ({ source }, ctx) => source && nullTag.test.test(source) ? source : ctx.options.nullStr
+    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)
+        ? source
+        : ctx.options.nullStr
 };
 
 export { nullTag };

package/browser/dist/schema/core/float.js

@@ -20,7 +20,10 @@ const floatExp = {
     format: 'EXP',
     test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
     resolve: str => parseFloat(str),
-    stringify: ({ value }) => Number(value).toExponential()
+    stringify(node) {
+        const num = Number(node.value);
+        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+    }
 };
 const float = {
     identify: value => typeof value === 'number',

package/browser/dist/schema/tags.js

@@ -14,13 +14,13 @@ import { schema as schema$2 } from './yaml-1.1/schema.js';
 import { set } from './yaml-1.1/set.js';
 import { floatTime, intTime, timestamp } from './yaml-1.1/timestamp.js';
 
-const schemas = {
-    core: schema,
-    failsafe: [map, seq, string],
-    json: schema$1,
-    yaml11: schema$2,
-    'yaml-1.1': schema$2
-};
+const schemas = new Map([
+    ['core', schema],
+    ['failsafe', [map, seq, string]],
+    ['json', schema$1],
+    ['yaml11', schema$2],
+    ['yaml-1.1', schema$2]
+]);
 const tagsByName = {
     binary,
     bool: boolTag,
@@ -48,13 +48,17 @@ const coreKnownTags = {
     'tag:yaml.org,2002:timestamp': timestamp
 };
 function getTags(customTags, schemaName) {
-    let tags = schemas[schemaName];
+    let tags = schemas.get(schemaName);
     if (!tags) {
-        const keys = Object.keys(schemas)
-            .filter(key => key !== 'yaml11')
-            .map(key => JSON.stringify(key))
-            .join(', ');
-        throw new Error(`Unknown schema "${schemaName}"; use one of ${keys}`);
+        if (Array.isArray(customTags))
+            tags = [];
+        else {
+            const keys = Array.from(schemas.keys())
+                .filter(key => key !== 'yaml11')
+                .map(key => JSON.stringify(key))
+                .join(', ');
+            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+        }
     }
     if (Array.isArray(customTags)) {
         for (const tag of customTags)

package/browser/dist/schema/yaml-1.1/float.js

@@ -20,7 +20,10 @@ const floatExp = {
     format: 'EXP',
     test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
     resolve: (str) => parseFloat(str.replace(/_/g, '')),
-    stringify: ({ value }) => Number(value).toExponential()
+    stringify(node) {
+        const num = Number(node.value);
+        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+    }
 };
 const float = {
     identify: value => typeof value === 'number',

package/browser/dist/schema/yaml-1.1/omap.js

@@ -22,7 +22,7 @@ class YAMLOMap extends YAMLSeq {
         if (!ctx)
             return super.toJSON(_);
         const map = new Map();
-        if (ctx && ctx.onCreate)
+        if (ctx === null || ctx === void 0 ? void 0 : ctx.onCreate)
             ctx.onCreate(map);
         for (const pair of this.items) {
             let key, value;

package/browser/dist/schema/yaml-1.1/pairs.js

@@ -4,6 +4,7 @@ import { Scalar } from '../../nodes/Scalar.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
 
 function resolvePairs(seq, onError) {
+    var _a;
     if (isSeq(seq)) {
         for (let i = 0; i < seq.items.length; ++i) {
             let item = seq.items[i];
@@ -18,7 +19,7 @@ function resolvePairs(seq, onError) {
                         ? `${item.commentBefore}\n${pair.key.commentBefore}`
                         : item.commentBefore;
                 if (item.comment) {
-                    const cn = pair.value || pair.key;
+                    const cn = (_a = pair.value) !== null && _a !== void 0 ? _a : pair.key;
                     cn.comment = cn.comment
                         ? `${item.comment}\n${cn.comment}`
                         : item.comment;

package/browser/dist/stringify/stringify.js

@@ -1,13 +1,12 @@
 import { anchorIsValid } from '../doc/anchors.js';
 import { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/Node.js';
+import { stringifyComment } from './stringifyComment.js';
 import { stringifyString } from './stringifyString.js';
 
-const createStringifyContext = (doc, options) => ({
-    anchors: new Set(),
-    doc,
-    indent: '',
-    indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
-    options: Object.assign({
+function createStringifyContext(doc, options) {
+    const opt = Object.assign({
+        blockQuote: true,
+        commentString: stringifyComment,
         defaultKeyType: null,
         defaultStringType: 'PLAIN',
         directives: null,
@@ -19,57 +18,88 @@ const createStringifyContext = (doc, options) => ({
         minContentWidth: 20,
         nullStr: 'null',
         simpleKeys: false,
-        singleQuote: false,
+        singleQuote: null,
         trueStr: 'true',
         verifyAliasOrder: true
-    }, options)
-});
+    }, doc.schema.toStringOptions, options);
+    let inFlow;
+    switch (opt.collectionStyle) {
+        case 'block':
+            inFlow = false;
+            break;
+        case 'flow':
+            inFlow = true;
+            break;
+        default:
+            inFlow = null;
+    }
+    return {
+        anchors: new Set(),
+        doc,
+        indent: '',
+        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
+        inFlow,
+        options: opt
+    };
+}
 function getTagObject(tags, item) {
+    var _a, _b, _c, _d;
     if (item.tag) {
         const match = tags.filter(t => t.tag === item.tag);
         if (match.length > 0)
-            return match.find(t => t.format === item.format) || match[0];
+            return (_a = match.find(t => t.format === item.format)) !== null && _a !== void 0 ? _a : match[0];
     }
     let tagObj = undefined;
     let obj;
     if (isScalar(item)) {
         obj = item.value;
-        const match = tags.filter(t => t.identify && t.identify(obj));
+        const match = tags.filter(t => { var _a; return (_a = t.identify) === null || _a === void 0 ? void 0 : _a.call(t, obj); });
         tagObj =
-            match.find(t => t.format === item.format) || match.find(t => !t.format);
+            (_b = match.find(t => t.format === item.format)) !== null && _b !== void 0 ? _b : match.find(t => !t.format);
     }
     else {
         obj = item;
         tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
     }
     if (!tagObj) {
-        // @ts-ignore
-        const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
+        const name = (_d = (_c = obj === null || obj === void 0 ? void 0 : obj.constructor) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : typeof obj;
         throw new Error(`Tag not resolved for ${name} value`);
     }
     return tagObj;
 }
 // needs to be called before value stringifier to allow for circular anchor refs
 function stringifyProps(node, tagObj, { anchors, doc }) {
+    if (!doc.directives)
+        return '';
     const props = [];
     const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
     if (anchor && anchorIsValid(anchor)) {
         anchors.add(anchor);
         props.push(`&${anchor}`);
     }
-    if (node.tag) {
-        props.push(doc.directives.tagString(node.tag));
-    }
-    else if (!tagObj.default) {
-        props.push(doc.directives.tagString(tagObj.tag));
-    }
+    const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
+    if (tag)
+        props.push(doc.directives.tagString(tag));
     return props.join(' ');
 }
 function stringify(item, ctx, onComment, onChompKeep) {
+    var _a, _b;
     if (isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
-    if (isAlias(item))
-        return item.toString(ctx);
+    if (isAlias(item)) {
+        if (ctx.doc.directives)
+            return item.toString(ctx);
+        if ((_a = ctx.resolvedAliases) === null || _a === void 0 ? void 0 : _a.has(item)) {
+            throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+        }
+        else {
+            if (ctx.resolvedAliases)
+                ctx.resolvedAliases.add(item);
+            else
+                ctx.resolvedAliases = new Set([item]);
+            item = item.resolve(ctx.doc);
+        }
+    }
     let tagObj = undefined;
     const node = isNode(item)
         ? item
@@ -78,7 +108,7 @@ function stringify(item, ctx, onComment, onChompKeep) {
         tagObj = getTagObject(ctx.doc.schema.tags, node);
     const props = stringifyProps(node, tagObj, ctx);
     if (props.length > 0)
-        ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
+        ctx.indentAtStart = ((_b = ctx.indentAtStart) !== null && _b !== void 0 ? _b : 0) + props.length + 1;
     const str = typeof tagObj.stringify === 'function'
         ? tagObj.stringify(node, ctx, onComment, onChompKeep)
         : isScalar(node)