yaml 2.0.0-9 → 2.1.0

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

@@ -20,7 +20,7 @@ function resolvePairs(seq, onError) {
                         ? `${item.commentBefore}\n${pair.key.commentBefore}`
                         : item.commentBefore;
                 if (item.comment) {
-                    const cn = pair.value || pair.key;
+                    const cn = pair.value ?? pair.key;
                     cn.comment = cn.comment
                         ? `${item.comment}\n${cn.comment}`
                         : item.comment;

package/dist/schema/yaml-1.1/set.d.ts

@@ -12,9 +12,13 @@ export declare class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null
         key: T;
         value: Scalar<null> | null;
     }): void;
-    get(key?: T, keepPair?: boolean): unknown;
+    /**
+     * If `keepPair` is `true`, returns the Pair matching `key`.
+     * Otherwise, returns the value of that Pair's key.
+     */
+    get(key: unknown, keepPair?: boolean): any;
     set(key: T, value: boolean): void;
-    /** Will throw; `value` must be boolean */
+    /** @deprecated Will throw; `value` must be boolean */
     set(key: T, value: null): void;
     toJSON(_?: unknown, ctx?: ToJSContext): any;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;

package/dist/schema/yaml-1.1/set.js

@@ -24,6 +24,10 @@ class YAMLSet extends YAMLMap.YAMLMap {
         if (!prev)
             this.items.push(pair);
     }
+    /**
+     * If `keepPair` is `true`, returns the Pair matching `key`.
+     * Otherwise, returns the value of that Pair's key.
+     */
     get(key, keepPair) {
         const pair = YAMLMap.findPair(this.items, key);
         return !keepPair && Node.isPair(pair)

package/dist/stringify/stringify.d.ts

@@ -1,4 +1,5 @@
 import type { Document } from '../doc/Document.js';
+import type { Alias } from '../nodes/Alias.js';
 import type { ToStringOptions } from '../options.js';
 export declare type StringifyContext = {
     actualString?: boolean;
@@ -10,9 +11,10 @@ export declare type StringifyContext = {
     indent: string;
     indentStep: string;
     indentAtStart?: number;
-    inFlow?: boolean;
+    inFlow: boolean | null;
     inStringifyKey?: boolean;
-    options: Readonly<Required<Omit<ToStringOptions, 'indent'>>>;
+    options: Readonly<Required<Omit<ToStringOptions, 'collectionStyle' | 'indent'>>>;
+    resolvedAliases?: Set<Alias>;
 };
-export declare const createStringifyContext: (doc: Document, options: ToStringOptions) => StringifyContext;
+export declare function createStringifyContext(doc: Document, options: ToStringOptions): StringifyContext;
 export declare function stringify(item: unknown, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;

package/dist/stringify/stringify.js

@@ -2,15 +2,13 @@
 
 var anchors = require('../doc/anchors.js');
 var Node = require('../nodes/Node.js');
+var stringifyComment = require('./stringifyComment.js');
 var stringifyString = require('./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.stringifyComment,
         defaultKeyType: null,
         defaultStringType: 'PLAIN',
         directives: null,
@@ -25,54 +23,83 @@ 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) {
     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 match.find(t => t.format === item.format) ?? match[0];
     }
     let tagObj = undefined;
     let obj;
     if (Node.isScalar(item)) {
         obj = item.value;
-        const match = tags.filter(t => t.identify && t.identify(obj));
+        const match = tags.filter(t => t.identify?.(obj));
         tagObj =
-            match.find(t => t.format === item.format) || match.find(t => !t.format);
+            match.find(t => t.format === item.format) ?? 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 = obj?.constructor?.name ?? 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: anchors$1, doc }) {
+    if (!doc.directives)
+        return '';
     const props = [];
     const anchor = (Node.isScalar(node) || Node.isCollection(node)) && node.anchor;
     if (anchor && anchors.anchorIsValid(anchor)) {
         anchors$1.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) {
     if (Node.isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
-    if (Node.isAlias(item))
-        return item.toString(ctx);
+    if (Node.isAlias(item)) {
+        if (ctx.doc.directives)
+            return item.toString(ctx);
+        if (ctx.resolvedAliases?.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 = Node.isNode(item)
         ? item
@@ -81,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 = (ctx.indentAtStart ?? 0) + props.length + 1;
     const str = typeof tagObj.stringify === 'function'
         ? tagObj.stringify(node, ctx, onComment, onChompKeep)
         : Node.isScalar(node)

package/dist/stringify/stringifyCollection.d.ts

@@ -1,11 +1,7 @@
 import { Collection } from '../nodes/Collection.js';
 import { StringifyContext } from './stringify.js';
-declare type StringifyNode = {
-    comment: boolean;
-    str: string;
-};
 interface StringifyCollectionOptions {
-    blockItem(node: StringifyNode): string;
+    blockItemPrefix: string;
     flowChars: {
         start: '{';
         end: '}';
@@ -17,5 +13,5 @@ interface StringifyCollectionOptions {
     onChompKeep?: () => void;
     onComment?: () => void;
 }
-export declare function stringifyCollection({ comment, flow, items }: Readonly<Collection>, ctx: StringifyContext, { blockItem, flowChars, itemIndent, onChompKeep, onComment }: StringifyCollectionOptions): string;
+export declare function stringifyCollection(collection: Readonly<Collection>, ctx: StringifyContext, options: StringifyCollectionOptions): string;
 export {};

package/dist/stringify/stringifyCollection.js

@@ -5,120 +5,149 @@ var Node = require('../nodes/Node.js');
 var stringify = require('./stringify.js');
 var stringifyComment = require('./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) {
+    const flow = ctx.inFlow ?? 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 (Node.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 (Node.isPair(item)) {
             const ik = Node.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 = Node.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.stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
-        if (inFlow && i < items.length - 1)
-            str += ',';
-        str = stringifyComment.addComment(str, itemIndent, comment);
-        if (chompKeep && (comment || inFlow))
+        let str = stringify.stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));
+        if (comment)
+            str += stringifyComment.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' + stringifyComment.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 (Node.isNode(item)) {
+            if (item.spaceBefore)
+                lines.push('');
+            addCommentBefore(ctx, lines, item.commentBefore, false);
+            if (item.comment)
+                comment = item.comment;
+        }
+        else if (Node.isPair(item)) {
+            const ik = Node.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 = Node.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.Collection.maxFlowStringSingleLineLength) {
+        if (comment)
+            reqNewline = true;
+        let str = stringify.stringify(item, itemCtx, () => (comment = null));
+        if (i < items.length - 1)
+            str += ',';
+        if (comment)
+            str += stringifyComment.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.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.stringifyComment(comment, indent);
+        str += stringifyComment.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 = stringifyComment.indentComment(commentString(comment), indent);
+        lines.push(ic.trimStart()); // Avoid double indent on first line
+    }
+}
 
 exports.stringifyCollection = stringifyCollection;

package/dist/stringify/stringifyComment.d.ts

@@ -1,2 +1,10 @@
-export declare const stringifyComment: (comment: string, indent: string) => string;
-export declare function addComment(str: string, indent: string, comment?: string | null): string;
+/**
+ * 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 `#`.
+ */
+export declare const stringifyComment: (str: string) => string;
+export declare function indentComment(comment: string, indent: string): string;
+export declare const lineComment: (str: string, indent: string, comment: string) => string;

package/dist/stringify/stringifyComment.js

@@ -1,17 +1,24 @@
 'use strict';
 
-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;
 
-exports.addComment = addComment;
+exports.indentComment = indentComment;
+exports.lineComment = lineComment;
 exports.stringifyComment = stringifyComment;

package/dist/stringify/stringifyDocument.js

@@ -7,31 +7,35 @@ var stringifyComment = require('./stringifyComment.js');
 function stringifyDocument(doc, options) {
     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 = stringify.createStringifyContext(doc, options);
+    const { commentString } = ctx.options;
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        lines.unshift(stringifyComment.stringifyComment(doc.commentBefore, ''));
+        const cs = commentString(doc.commentBefore);
+        lines.unshift(stringifyComment.indentComment(cs, ''));
     }
-    const ctx = stringify.createStringifyContext(doc, options);
     let chompKeep = false;
     let contentComment = null;
     if (doc.contents) {
         if (Node.isNode(doc.contents)) {
             if (doc.contents.spaceBefore && hasDirectives)
                 lines.push('');
-            if (doc.contents.commentBefore)
-                lines.push(stringifyComment.stringifyComment(doc.contents.commentBefore, ''));
+            if (doc.contents.commentBefore) {
+                const cs = commentString(doc.contents.commentBefore);
+                lines.push(stringifyComment.indentComment(cs, ''));
+            }
             // top-level block scalars need to be indented if followed by a comment
             ctx.forceBlockIndent = !!doc.comment;
             contentComment = doc.contents.comment;
@@ -39,7 +43,7 @@ function stringifyDocument(doc, options) {
         const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
         let body = stringify.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
         if (contentComment)
-            body = stringifyComment.addComment(body, '', contentComment);
+            body += stringifyComment.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
@@ -52,13 +56,30 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(stringify.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.stringifyComment(dc, ''));
+    if (doc.directives?.docEnd) {
+        if (doc.comment) {
+            const cs = commentString(doc.comment);
+            if (cs.includes('\n')) {
+                lines.push('...');
+                lines.push(stringifyComment.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(stringifyComment.indentComment(commentString(dc), ''));
+        }
     }
     return lines.join('\n') + '\n';
 }