yaml 2.0.0-10 → 2.0.0-5

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

@@ -20,10 +20,7 @@ const floatExp = {
     format: 'EXP',
     test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
     resolve: str => parseFloat(str),
-    stringify(node) {
-        const num = Number(node.value);
-        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
-    }
+    stringify: ({ value }) => Number(value).toExponential()
 };
 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 = new Map([
-    ['core', schema],
-    ['failsafe', [map, seq, string]],
-    ['json', schema$1],
-    ['yaml11', schema$2],
-    ['yaml-1.1', schema$2]
-]);
+const schemas = {
+    core: schema,
+    failsafe: [map, seq, string],
+    json: schema$1,
+    yaml11: schema$2,
+    'yaml-1.1': schema$2
+};
 const tagsByName = {
     binary,
     bool: boolTag,
@@ -48,17 +48,13 @@ const coreKnownTags = {
     'tag:yaml.org,2002:timestamp': timestamp
 };
 function getTags(customTags, schemaName) {
-    let tags = schemas.get(schemaName);
+    let tags = schemas[schemaName];
     if (!tags) {
-        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`);
-        }
+        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)) {
         for (const tag of customTags)

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

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

package/browser/dist/stringify/addComment.js

@@ -0,0 +1,11 @@
+function addComment(str, indent, comment) {
+    return !comment
+        ? str
+        : comment.includes('\n')
+            ? `${str}\n` + comment.replace(/^/gm, `${indent || ''}#`)
+            : str.endsWith(' ')
+                ? `${str}#${comment}`
+                : `${str} #${comment}`;
+}
+
+export { addComment };

package/browser/dist/stringify/stringify.js

@@ -1,12 +1,13 @@
 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';
 
-function createStringifyContext(doc, options) {
-    const opt = Object.assign({
-        blockQuote: true,
-        commentString: stringifyComment,
+const createStringifyContext = (doc, options) => ({
+    anchors: new Set(),
+    doc,
+    indent: '',
+    indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
+    options: Object.assign({
         defaultKeyType: null,
         defaultStringType: 'PLAIN',
         directives: null,
@@ -18,30 +19,11 @@ function createStringifyContext(doc, options) {
         minContentWidth: 20,
         nullStr: 'null',
         simpleKeys: false,
-        singleQuote: null,
+        singleQuote: false,
         trueStr: 'true',
         verifyAliasOrder: true
-    }, 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
-    };
-}
+    }, options)
+});
 function getTagObject(tags, item) {
     if (item.tag) {
         const match = tags.filter(t => t.tag === item.tag);
@@ -69,37 +51,25 @@ function getTagObject(tags, item) {
 }
 // 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}`);
     }
-    const tag = node.tag || (tagObj.default ? null : tagObj.tag);
-    if (tag)
-        props.push(doc.directives.tagString(tag));
+    if (node.tag) {
+        props.push(doc.directives.tagString(node.tag));
+    }
+    else if (!tagObj.default) {
+        props.push(doc.directives.tagString(tagObj.tag));
+    }
     return props.join(' ');
 }
 function stringify(item, ctx, onComment, onChompKeep) {
-    var _a;
     if (isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
-    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);
-        }
-    }
+    if (isAlias(item))
+        return item.toString(ctx);
     let tagObj = undefined;
     const node = isNode(item)
         ? item

package/browser/dist/stringify/stringifyCollection.js

@@ -1,152 +1,108 @@
 import { Collection } from '../nodes/Collection.js';
-import { isNode, isPair } from '../nodes/Node.js';
+import { addComment } from './addComment.js';
 import { stringify } from './stringify.js';
-import { lineComment, indentComment } from './stringifyComment.js';
+import { isNode, isPair } from '../nodes/Node.js';
 
-function stringifyCollection(collection, ctx, options) {
-    var _a;
-    const flow = (_a = ctx.inFlow) !== null && _a !== void 0 ? _a : collection.flow;
-    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;
-    return stringify(collection, ctx, options);
-}
-function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
-    const { indent, options: { commentString } } = ctx;
-    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });
+function stringifyCollection({ comment, flow, items }, ctx, { blockItem, flowChars, itemIndent, onChompKeep, onComment }) {
+    const { indent, indentStep } = ctx;
+    const inFlow = flow || ctx.inFlow;
+    if (inFlow)
+        itemIndent += indentStep;
+    ctx = Object.assign({}, ctx, { indent: itemIndent, inFlow, type: null });
+    let singleLineOutput = true;
     let chompKeep = false; // flag for the preceding node's status
-    const lines = [];
-    for (let i = 0; i < items.length; ++i) {
-        const item = items[i];
+    const nodes = items.reduce((nodes, item, i) => {
         let comment = null;
         if (isNode(item)) {
             if (!chompKeep && item.spaceBefore)
-                lines.push('');
-            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
-            if (item.comment)
+                nodes.push({ comment: true, str: '' });
+            if (item.commentBefore) {
+                // This match will always succeed on a non-empty string
+                for (const line of item.commentBefore.match(/^.*$/gm))
+                    nodes.push({ comment: true, str: `#${line}` });
+            }
+            if (item.comment) {
                 comment = item.comment;
+                singleLineOutput = false;
+            }
         }
         else if (isPair(item)) {
             const ik = isNode(item.key) ? item.key : null;
             if (ik) {
                 if (!chompKeep && ik.spaceBefore)
-                    lines.push('');
-                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
+                    nodes.push({ comment: true, str: '' });
+                if (ik.commentBefore) {
+                    // This match will always succeed on a non-empty string
+                    for (const line of ik.commentBefore.match(/^.*$/gm))
+                        nodes.push({ comment: true, str: `#${line}` });
+                }
+                if (ik.comment)
+                    singleLineOutput = false;
+            }
+            if (inFlow) {
+                const iv = isNode(item.value) ? item.value : null;
+                if (iv) {
+                    if (iv.comment)
+                        comment = iv.comment;
+                    if (iv.comment || iv.commentBefore)
+                        singleLineOutput = false;
+                }
+                else if (item.value == null && ik && ik.comment) {
+                    comment = ik.comment;
+                }
             }
         }
         chompKeep = false;
-        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));
-        if (comment)
-            str += lineComment(str, itemIndent, commentString(comment));
-        if (chompKeep && comment)
+        let str = stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
+        if (inFlow && i < items.length - 1)
+            str += ',';
+        str = addComment(str, itemIndent, comment);
+        if (chompKeep && (comment || inFlow))
             chompKeep = false;
-        lines.push(blockItemPrefix + str);
-    }
+        nodes.push({ comment: false, str });
+        return nodes;
+    }, []);
     let str;
-    if (lines.length === 0) {
+    if (nodes.length === 0) {
         str = flowChars.start + flowChars.end;
     }
-    else {
-        str = lines[0];
-        for (let i = 1; i < lines.length; ++i) {
-            const line = lines[i];
-            str += line ? `\n${indent}${line}` : '\n';
-        }
-    }
-    if (comment) {
-        str += '\n' + indentComment(commentString(comment), indent);
-        if (onComment)
-            onComment();
-    }
-    else if (chompKeep && onChompKeep)
-        onChompKeep();
-    return str;
-}
-function stringifyFlowCollection({ comment, items }, ctx, { flowChars, itemIndent, onComment }) {
-    const { indent, indentStep, options: { commentString } } = ctx;
-    itemIndent += indentStep;
-    const itemCtx = Object.assign({}, ctx, {
-        indent: itemIndent,
-        inFlow: true,
-        type: null
-    });
-    let reqNewline = false;
-    let linesAtValue = 0;
-    const lines = [];
-    for (let i = 0; i < items.length; ++i) {
-        const item = items[i];
-        let comment = null;
-        if (isNode(item)) {
-            if (item.spaceBefore)
-                lines.push('');
-            addCommentBefore(ctx, lines, item.commentBefore, false);
-            if (item.comment)
-                comment = item.comment;
-        }
-        else if (isPair(item)) {
-            const ik = isNode(item.key) ? item.key : null;
-            if (ik) {
-                if (ik.spaceBefore)
-                    lines.push('');
-                addCommentBefore(ctx, lines, ik.commentBefore, false);
-                if (ik.comment)
-                    reqNewline = true;
+    else if (inFlow) {
+        const { start, end } = flowChars;
+        const strings = nodes.map(n => n.str);
+        let singleLineLength = 2;
+        for (const node of nodes) {
+            if (node.comment || node.str.includes('\n')) {
+                singleLineOutput = false;
+                break;
             }
-            const iv = isNode(item.value) ? item.value : null;
-            if (iv) {
-                if (iv.comment)
-                    comment = iv.comment;
-                if (iv.commentBefore)
-                    reqNewline = true;
-            }
-            else if (item.value == null && ik && ik.comment) {
-                comment = ik.comment;
-            }
-        }
-        if (comment)
-            reqNewline = true;
-        let str = stringify(item, itemCtx, () => (comment = null));
-        if (i < items.length - 1)
-            str += ',';
-        if (comment)
-            str += lineComment(str, itemIndent, commentString(comment));
-        if (!reqNewline && (lines.length > linesAtValue || str.includes('\n')))
-            reqNewline = true;
-        lines.push(str);
-        linesAtValue = lines.length;
-    }
-    let str;
-    const { start, end } = flowChars;
-    if (lines.length === 0) {
-        str = start + end;
-    }
-    else {
-        if (!reqNewline) {
-            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
-            reqNewline = len > Collection.maxFlowStringSingleLineLength;
+            singleLineLength += node.str.length + 2;
         }
-        if (reqNewline) {
+        if (!singleLineOutput ||
+            singleLineLength > Collection.maxFlowStringSingleLineLength) {
             str = start;
-            for (const line of lines)
-                str += line ? `\n${indentStep}${indent}${line}` : '\n';
+            for (const s of strings) {
+                str += s ? `\n${indentStep}${indent}${s}` : '\n';
+            }
             str += `\n${indent}${end}`;
         }
         else {
-            str = `${start} ${lines.join(' ')} ${end}`;
+            str = `${start} ${strings.join(' ')} ${end}`;
         }
     }
+    else {
+        const strings = nodes.map(blockItem);
+        str = strings.shift() || '';
+        for (const s of strings)
+            str += s ? `\n${indent}${s}` : '\n';
+    }
     if (comment) {
-        str += lineComment(str, commentString(comment), indent);
+        str += '\n' + comment.replace(/^/gm, `${indent}#`);
         if (onComment)
             onComment();
     }
+    else if (chompKeep && onChompKeep)
+        onChompKeep();
     return str;
 }
-function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
-    if (comment && chompKeep)
-        comment = comment.replace(/^\n+/, '');
-    if (comment) {
-        const ic = indentComment(commentString(comment), indent);
-        lines.push(ic.trimStart()); // Avoid double indent on first line
-    }
-}
 
 export { stringifyCollection };

package/browser/dist/stringify/stringifyDocument.js

@@ -1,11 +1,11 @@
 import { isNode } from '../nodes/Node.js';
+import { addComment } from './addComment.js';
 import { createStringifyContext, stringify } from './stringify.js';
-import { indentComment, lineComment } from './stringifyComment.js';
 
 function stringifyDocument(doc, options) {
     const lines = [];
     let hasDirectives = options.directives === true;
-    if (options.directives !== false && doc.directives) {
+    if (options.directives !== false) {
         const dir = doc.directives.toString(doc);
         if (dir) {
             lines.push(dir);
@@ -16,24 +16,20 @@ function stringifyDocument(doc, options) {
     }
     if (hasDirectives)
         lines.push('---');
-    const ctx = createStringifyContext(doc, options);
-    const { commentString } = ctx.options;
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        const cs = commentString(doc.commentBefore);
-        lines.unshift(indentComment(cs, ''));
+        lines.unshift(doc.commentBefore.replace(/^/gm, '#'));
     }
+    const ctx = createStringifyContext(doc, options);
     let chompKeep = false;
     let contentComment = null;
     if (doc.contents) {
         if (isNode(doc.contents)) {
             if (doc.contents.spaceBefore && hasDirectives)
                 lines.push('');
-            if (doc.contents.commentBefore) {
-                const cs = commentString(doc.contents.commentBefore);
-                lines.push(indentComment(cs, ''));
-            }
+            if (doc.contents.commentBefore)
+                lines.push(doc.contents.commentBefore.replace(/^/gm, '#'));
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
@@ -41,7 +37,7 @@ function stringifyDocument(doc, options) {
         const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
         let body = stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
         if (contentComment)
-            body += lineComment(body, '', commentString(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
@@ -54,13 +50,10 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(stringify(doc.contents, ctx));
     }
-    let dc = doc.comment;
-    if (dc && chompKeep)
-        dc = dc.replace(/^\n+/, '');
-    if (dc) {
+    if (doc.comment) {
         if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
             lines.push('');
-        lines.push(indentComment(commentString(dc), ''));
+        lines.push(doc.comment.replace(/^/gm, '#'));
     }
     return lines.join('\n') + '\n';
 }

package/browser/dist/stringify/stringifyPair.js

@@ -1,10 +1,10 @@
 import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
+import { addComment } from './addComment.js';
 import { stringify } from './stringify.js';
-import { lineComment, indentComment } from './stringifyComment.js';
 
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
-    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
+    const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
     let keyComment = (isNode(key) && key.comment) || null;
     if (simpleKeys) {
         if (keyComment) {
@@ -43,34 +43,25 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         }
     }
     else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
-        str = `? ${str}`;
-        if (keyComment && !keyCommentDone) {
-            str += lineComment(str, ctx.indent, commentString(keyComment));
-        }
-        else if (chompKeep && onChompKeep)
+        if (keyCommentDone)
+            keyComment = null;
+        if (chompKeep && !keyComment && onChompKeep)
             onChompKeep();
-        return str;
+        return addComment(`? ${str}`, ctx.indent, keyComment);
     }
     if (keyCommentDone)
         keyComment = null;
-    if (explicitKey) {
-        if (keyComment)
-            str += lineComment(str, ctx.indent, commentString(keyComment));
-        str = `? ${str}\n${indent}:`;
-    }
-    else {
-        str = `${str}:`;
-        if (keyComment)
-            str += lineComment(str, ctx.indent, commentString(keyComment));
-    }
+    str = explicitKey
+        ? `? ${addComment(str, ctx.indent, keyComment)}\n${indent}:`
+        : addComment(`${str}:`, ctx.indent, keyComment);
     let vcb = '';
     let valueComment = null;
     if (isNode(value)) {
         if (value.spaceBefore)
             vcb = '\n';
         if (value.commentBefore) {
-            const cs = commentString(value.commentBefore);
-            vcb += `\n${indentComment(cs, ctx.indent)}`;
+            const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
+            vcb += `\n${cs}`;
         }
         valueComment = value.comment;
     }
@@ -96,27 +87,27 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     const valueStr = stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
     let ws = ' ';
     if (vcb || keyComment) {
-        ws = valueStr === '' && !ctx.inFlow ? vcb : `${vcb}\n${ctx.indent}`;
+        ws = `${vcb}\n${ctx.indent}`;
     }
     else if (!explicitKey && isCollection(value)) {
         const flow = valueStr[0] === '[' || valueStr[0] === '{';
         if (!flow || valueStr.includes('\n'))
             ws = `\n${ctx.indent}`;
     }
-    else if (valueStr === '' || valueStr[0] === '\n')
+    else if (valueStr[0] === '\n')
         ws = '';
-    str += ws + valueStr;
     if (ctx.inFlow) {
         if (valueCommentDone && onComment)
             onComment();
+        return str + ws + valueStr;
     }
-    else if (valueComment && !valueCommentDone) {
-        str += lineComment(str, ctx.indent, commentString(valueComment));
-    }
-    else if (chompKeep && onChompKeep) {
-        onChompKeep();
+    else {
+        if (valueCommentDone)
+            valueComment = null;
+        if (chompKeep && !valueComment && onChompKeep)
+            onChompKeep();
+        return addComment(str + ws + valueStr, ctx.indent, valueComment);
     }
-    return str;
 }
 
 export { stringifyPair };