yaml 2.0.0-9 → 2.0.0

package/browser/dist/stringify/stringify.js

@@ -1,14 +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,
@@ -23,54 +21,85 @@ const createStringifyContext = (doc, options) => ({
         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
@@ -79,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)

package/browser/dist/stringify/stringifyCollection.js

@@ -1,122 +1,152 @@
 import { Collection } from '../nodes/Collection.js';
 import { isNode, isPair } from '../nodes/Node.js';
 import { stringify } from './stringify.js';
-import { addComment, stringifyComment } from './stringifyComment.js';
+import { lineComment, indentComment } from './stringifyComment.js';
 
-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;
+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 });
     let chompKeep = false; // flag for the preceding node's status
-    const nodes = items.reduce((nodes, item, i) => {
+    const lines = [];
+    for (let i = 0; i < items.length; ++i) {
+        const item = items[i];
         let comment = null;
         if (isNode(item)) {
             if (!chompKeep && item.spaceBefore)
-                nodes.push({ comment: true, str: '' });
-            let cb = item.commentBefore;
-            if (cb && chompKeep)
-                cb = cb.replace(/^\n+/, '');
-            if (cb) {
-                if (/^\n+$/.test(cb))
-                    cb = cb.substring(1);
-                // This match will always succeed on a non-empty string
-                for (const line of cb.match(/^.*$/gm)) {
-                    const str = line === ' ' ? '#' : line ? `#${line}` : '';
-                    nodes.push({ comment: true, str });
-                }
-            }
-            if (item.comment) {
+                lines.push('');
+            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+            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)
-                    nodes.push({ comment: true, str: '' });
-                let cb = ik.commentBefore;
-                if (cb && chompKeep)
-                    cb = cb.replace(/^\n+/, '');
-                if (cb) {
-                    if (/^\n+$/.test(cb))
-                        cb = cb.substring(1);
-                    // This match will always succeed on a non-empty string
-                    for (const line of cb.match(/^.*$/gm)) {
-                        const str = line === ' ' ? '#' : line ? `#${line}` : '';
-                        nodes.push({ comment: true, str });
-                    }
-                }
-                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;
-                }
+                    lines.push('');
+                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
             }
         }
         chompKeep = false;
-        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))
+        let str = stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));
+        if (comment)
+            str += lineComment(str, itemIndent, commentString(comment));
+        if (chompKeep && comment)
             chompKeep = false;
-        nodes.push({ comment: false, str });
-        return nodes;
-    }, []);
+        lines.push(blockItemPrefix + str);
+    }
     let str;
-    if (nodes.length === 0) {
+    if (lines.length === 0) {
         str = flowChars.start + flowChars.end;
     }
-    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;
+    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;
+            }
+            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;
             }
-            singleLineLength += node.str.length + 2;
         }
-        if (!singleLineOutput ||
-            singleLineLength > Collection.maxFlowStringSingleLineLength) {
+        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;
+        }
+        if (reqNewline) {
             str = start;
-            for (const s of strings) {
-                str += s ? `\n${indentStep}${indent}${s}` : '\n';
-            }
+            for (const line of lines)
+                str += line ? `\n${indentStep}${indent}${line}` : '\n';
             str += `\n${indent}${end}`;
         }
         else {
-            str = `${start} ${strings.join(' ')} ${end}`;
+            str = `${start} ${lines.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 += '\n' + stringifyComment(comment, indent);
+        str += lineComment(str, commentString(comment), 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/stringifyComment.js

@@ -1,14 +1,20 @@
-const stringifyComment = (comment, indent) => /^\n+$/.test(comment)
-    ? comment.substring(1)
-    : comment.replace(/^(?!$)(?: $)?/gm, `${indent}#`);
-function addComment(str, indent, comment) {
-    return !comment
-        ? str
-        : comment.includes('\n')
-            ? `${str}\n` + stringifyComment(comment, indent)
-            : str.endsWith(' ')
-                ? `${str}#${comment}`
-                : `${str} #${comment}`;
+/**
+ * Stringifies a comment.
+ *
+ * Empty comment lines are left empty,
+ * lines consisting of a single space are replaced by `#`,
+ * and all other lines are prefixed with a `#`.
+ */
+const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');
+function indentComment(comment, indent) {
+    if (/^\n+$/.test(comment))
+        return comment.substring(1);
+    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
 }
+const lineComment = (str, indent, comment) => str.endsWith('\n')
+    ? indentComment(comment, indent)
+    : comment.includes('\n')
+        ? '\n' + indentComment(comment, indent)
+        : (str.endsWith(' ') ? '' : ' ') + comment;
 
-export { addComment, stringifyComment };
+export { indentComment, lineComment, stringifyComment };

package/browser/dist/stringify/stringifyDocument.js

@@ -1,35 +1,40 @@
 import { isNode } from '../nodes/Node.js';
 import { createStringifyContext, stringify } from './stringify.js';
-import { stringifyComment, addComment } from './stringifyComment.js';
+import { indentComment, lineComment } from './stringifyComment.js';
 
 function stringifyDocument(doc, options) {
+    var _a;
     const lines = [];
     let hasDirectives = options.directives === true;
-    if (options.directives !== false) {
+    if (options.directives !== false && doc.directives) {
         const dir = doc.directives.toString(doc);
         if (dir) {
             lines.push(dir);
             hasDirectives = true;
         }
-        else if (doc.directives.marker)
+        else if (doc.directives.docStart)
             hasDirectives = true;
     }
     if (hasDirectives)
         lines.push('---');
+    const ctx = createStringifyContext(doc, options);
+    const { commentString } = ctx.options;
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        lines.unshift(stringifyComment(doc.commentBefore, ''));
+        const cs = commentString(doc.commentBefore);
+        lines.unshift(indentComment(cs, ''));
     }
-    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)
-                lines.push(stringifyComment(doc.contents.commentBefore, ''));
+            if (doc.contents.commentBefore) {
+                const cs = commentString(doc.contents.commentBefore);
+                lines.push(indentComment(cs, ''));
+            }
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
@@ -37,7 +42,7 @@ function stringifyDocument(doc, options) {
         const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
         let body = stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
         if (contentComment)
-            body = addComment(body, '', contentComment);
+            body += lineComment(body, '', commentString(contentComment));
         if ((body[0] === '|' || body[0] === '>') &&
             lines[lines.length - 1] === '---') {
             // Top-level block scalars with a preceding doc marker ought to use the
@@ -50,13 +55,30 @@ 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 ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
-            lines.push('');
-        lines.push(stringifyComment(dc, ''));
+    if ((_a = doc.directives) === null || _a === void 0 ? void 0 : _a.docEnd) {
+        if (doc.comment) {
+            const cs = commentString(doc.comment);
+            if (cs.includes('\n')) {
+                lines.push('...');
+                lines.push(indentComment(cs, ''));
+            }
+            else {
+                lines.push(`... ${cs}`);
+            }
+        }
+        else {
+            lines.push('...');
+        }
+    }
+    else {
+        let dc = doc.comment;
+        if (dc && chompKeep)
+            dc = dc.replace(/^\n+/, '');
+        if (dc) {
+            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+                lines.push('');
+            lines.push(indentComment(commentString(dc), ''));
+        }
     }
     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 { stringify } from './stringify.js';
-import { addComment, stringifyComment } from './stringifyComment.js';
+import { lineComment, indentComment } from './stringifyComment.js';
 
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
-    const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
+    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
     let keyComment = (isNode(key) && key.comment) || null;
     if (simpleKeys) {
         if (keyComment) {
@@ -39,28 +39,39 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         if (allNullValues || value == null) {
             if (keyCommentDone && onComment)
                 onComment();
-            return explicitKey ? `? ${str}` : str;
+            return str === '' ? '?' : explicitKey ? `? ${str}` : str;
         }
     }
     else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
-        if (keyCommentDone)
-            keyComment = null;
-        if (chompKeep && !keyComment && onChompKeep)
+        str = `? ${str}`;
+        if (keyComment && !keyCommentDone) {
+            str += lineComment(str, ctx.indent, commentString(keyComment));
+        }
+        else if (chompKeep && onChompKeep)
             onChompKeep();
-        return addComment(`? ${str}`, ctx.indent, keyComment);
+        return str;
     }
     if (keyCommentDone)
         keyComment = null;
-    str = explicitKey
-        ? `? ${addComment(str, ctx.indent, keyComment)}\n${indent}:`
-        : addComment(`${str}:`, ctx.indent, keyComment);
+    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));
+    }
     let vcb = '';
     let valueComment = null;
     if (isNode(value)) {
         if (value.spaceBefore)
             vcb = '\n';
-        if (value.commentBefore)
-            vcb += `\n${stringifyComment(value.commentBefore, ctx.indent)}`;
+        if (value.commentBefore) {
+            const cs = commentString(value.commentBefore);
+            vcb += `\n${indentComment(cs, ctx.indent)}`;
+        }
         valueComment = value.comment;
     }
     else if (value && typeof value === 'object') {
@@ -85,7 +96,10 @@ 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}`;
+        if (valueStr === '' && !ctx.inFlow)
+            ws = vcb === '\n' ? '\n\n' : vcb;
+        else
+            ws = `${vcb}\n${ctx.indent}`;
     }
     else if (!explicitKey && isCollection(value)) {
         const flow = valueStr[0] === '[' || valueStr[0] === '{';
@@ -94,18 +108,18 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     }
     else if (valueStr === '' || valueStr[0] === '\n')
         ws = '';
+    str += ws + valueStr;
     if (ctx.inFlow) {
         if (valueCommentDone && onComment)
             onComment();
-        return str + ws + valueStr;
     }
-    else {
-        if (valueCommentDone)
-            valueComment = null;
-        if (chompKeep && !valueComment && onChompKeep)
-            onChompKeep();
-        return addComment(str + ws + valueStr, ctx.indent, valueComment);
+    else if (valueComment && !valueCommentDone) {
+        str += lineComment(str, ctx.indent, commentString(valueComment));
+    }
+    else if (chompKeep && onChompKeep) {
+        onChompKeep();
     }
+    return str;
 }
 
 export { stringifyPair };

package/browser/dist/stringify/stringifyString.js

@@ -147,7 +147,7 @@ function quotedString(value, ctx) {
     return qs(value, ctx);
 }
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
-    const { lineWidth, blockQuote } = ctx.options;
+    const { blockQuote, commentString, lineWidth } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
     // 2. Strings consisting of only whitespace are best rendered explicitly.
     if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
@@ -212,7 +212,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     const indentSize = indent ? '2' : '1'; // root is at -1
     let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
-        header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
+        header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
         if (onComment)
             onComment();
     }
@@ -229,7 +229,6 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
-    var _a;
     const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
@@ -244,14 +243,14 @@ function plainString(item, ctx, onComment, onChompKeep) {
         // - '\n ', ': ' or ' \n' anywhere
         // - '#' not preceded by a non-space char
         // - end with ' ' or ':'
-        return implicitKey || inFlow || value.indexOf('\n') === -1
+        return implicitKey || inFlow || !value.includes('\n')
             ? quotedString(value, ctx)
             : blockString(item, ctx, onComment, onChompKeep);
     }
     if (!implicitKey &&
         !inFlow &&
         type !== Scalar.PLAIN &&
-        value.indexOf('\n') !== -1) {
+        value.includes('\n')) {
         // Where allowed & type not set explicitly, prefer block style for multiline strings
         return blockString(item, ctx, onComment, onChompKeep);
     }
@@ -264,12 +263,10 @@ function plainString(item, ctx, onComment, onChompKeep) {
     // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
     // and others in v1.1.
     if (actualString) {
-        for (const tag of ctx.doc.schema.tags) {
-            if (tag.default &&
-                tag.tag !== 'tag:yaml.org,2002:str' &&
-                ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)))
-                return quotedString(value, ctx);
-        }
+        const test = (tag) => { var _a; return tag.default && tag.tag !== 'tag:yaml.org,2002:str' && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)); };
+        const { compat, tags } = ctx.doc.schema;
+        if (tags.some(test) || (compat === null || compat === void 0 ? void 0 : compat.some(test)))
+            return quotedString(value, ctx);
     }
     return implicitKey
         ? str