yaml 2.0.0-10 → 2.0.0-5

package/dist/schema/Schema.d.ts

@@ -1,18 +1,16 @@
 import { MAP, SCALAR, SEQ } from '../nodes/Node.js';
 import type { Pair } from '../nodes/Pair.js';
-import type { SchemaOptions, ToStringOptions } from '../options.js';
+import type { SchemaOptions } from '../options.js';
 import type { CollectionTag, ScalarTag } from './types.js';
+export declare type SchemaName = 'core' | 'failsafe' | 'json' | 'yaml-1.1';
 export declare class Schema {
-    compat: Array<CollectionTag | ScalarTag> | null;
     knownTags: Record<string, CollectionTag | ScalarTag>;
     merge: boolean;
-    name: string;
+    name: SchemaName;
     sortMapEntries: ((a: Pair, b: Pair) => number) | null;
     tags: Array<CollectionTag | ScalarTag>;
-    toStringOptions: Readonly<ToStringOptions> | null;
     [MAP]: CollectionTag;
     [SCALAR]: ScalarTag;
     [SEQ]: CollectionTag;
-    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }: SchemaOptions);
-    clone(): Schema;
+    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }: SchemaOptions);
 }

package/dist/schema/Schema.js

@@ -8,17 +8,11 @@ var tags = require('./tags.js');
 
 const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 class Schema {
-    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
-        this.compat = Array.isArray(compat)
-            ? tags.getTags(compat, 'compat')
-            : compat
-                ? tags.getTags(null, compat)
-                : null;
+    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }) {
         this.merge = !!merge;
-        this.name = (typeof schema === 'string' && schema) || 'core';
+        this.name = schema || 'core';
         this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
         this.tags = tags.getTags(customTags, this.name);
-        this.toStringOptions = toStringDefaults || null;
         Object.defineProperty(this, Node.MAP, { value: map.map });
         Object.defineProperty(this, Node.SCALAR, { value: string.string });
         Object.defineProperty(this, Node.SEQ, { value: seq.seq });
@@ -26,11 +20,6 @@ class Schema {
         this.sortMapEntries =
             sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
     }
-    clone() {
-        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
-        copy.tags = this.tags.slice();
-        return copy;
-    }
 }
 
 exports.Schema = Schema;

package/dist/schema/core/float.js

@@ -22,10 +22,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.stringifyNumber(node);
-    }
+    stringify: ({ value }) => Number(value).toExponential()
 };
 const float = {
     identify: value => typeof value === 'number',

package/dist/schema/tags.d.ts

@@ -1,4 +1,5 @@
 import { SchemaOptions } from '../options.js';
+import type { SchemaName } from './Schema.js';
 import type { CollectionTag, ScalarTag } from './types.js';
 declare const tagsByName: {
     binary: ScalarTag;
@@ -36,5 +37,5 @@ export declare const coreKnownTags: {
         test: RegExp;
     };
 };
-export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: string): (ScalarTag | CollectionTag)[];
+export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: SchemaName): (ScalarTag | CollectionTag)[];
 export {};

package/dist/schema/tags.js

@@ -16,13 +16,13 @@ var schema$2 = require('./yaml-1.1/schema.js');
 var set = require('./yaml-1.1/set.js');
 var timestamp = require('./yaml-1.1/timestamp.js');
 
-const schemas = new Map([
-    ['core', schema.schema],
-    ['failsafe', [map.map, seq.seq, string.string]],
-    ['json', schema$1.schema],
-    ['yaml11', schema$2.schema],
-    ['yaml-1.1', schema$2.schema]
-]);
+const schemas = {
+    core: schema.schema,
+    failsafe: [map.map, seq.seq, string.string],
+    json: schema$1.schema,
+    yaml11: schema$2.schema,
+    'yaml-1.1': schema$2.schema
+};
 const tagsByName = {
     binary: binary.binary,
     bool: bool.boolTag,
@@ -50,17 +50,13 @@ const coreKnownTags = {
     'tag:yaml.org,2002:timestamp': 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/dist/schema/yaml-1.1/float.js

@@ -22,10 +22,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.stringifyNumber(node);
-    }
+    stringify: ({ value }) => Number(value).toExponential()
 };
 const float = {
     identify: value => typeof value === 'number',

package/dist/stringify/addComment.d.ts

@@ -0,0 +1,2 @@
+export declare function addCommentBefore(str: string, indent: string, comment?: string | null): string;
+export declare function addComment(str: string, indent: string, comment?: string | null): string;

package/dist/stringify/addComment.js

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

package/dist/stringify/stringify.d.ts

@@ -1,5 +1,4 @@
 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;
@@ -11,10 +10,9 @@ export declare type StringifyContext = {
     indent: string;
     indentStep: string;
     indentAtStart?: number;
-    inFlow: boolean | null;
+    inFlow?: boolean;
     inStringifyKey?: boolean;
-    options: Readonly<Required<Omit<ToStringOptions, 'collectionStyle' | 'indent'>>>;
-    resolvedAliases?: Set<Alias>;
+    options: Readonly<Required<Omit<ToStringOptions, 'indent'>>>;
 };
-export declare function createStringifyContext(doc: Document, options: ToStringOptions): StringifyContext;
+export declare const 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,13 +2,14 @@
 
 var anchors = require('../doc/anchors.js');
 var Node = require('../nodes/Node.js');
-var stringifyComment = require('./stringifyComment.js');
 var stringifyString = require('./stringifyString.js');
 
-function createStringifyContext(doc, options) {
-    const opt = Object.assign({
-        blockQuote: true,
-        commentString: stringifyComment.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,
@@ -20,30 +21,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);
@@ -71,37 +53,25 @@ function getTagObject(tags, item) {
 }
 // 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}`);
     }
-    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 (Node.isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
-    if (Node.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 (Node.isAlias(item))
+        return item.toString(ctx);
     let tagObj = undefined;
     const node = Node.isNode(item)
         ? item

package/dist/stringify/stringifyCollection.d.ts

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

package/dist/stringify/stringifyCollection.js

@@ -1,154 +1,110 @@
 'use strict';
 
 var Collection = require('../nodes/Collection.js');
-var Node = require('../nodes/Node.js');
+var addComment = require('./addComment.js');
 var stringify = require('./stringify.js');
-var stringifyComment = require('./stringifyComment.js');
+var Node = require('../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 (Node.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 (Node.isPair(item)) {
             const ik = Node.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 = 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;
+                }
             }
         }
         chompKeep = false;
-        let str = stringify.stringify(item, itemCtx, () => (comment = null), () => (chompKeep = true));
-        if (comment)
-            str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-        if (chompKeep && comment)
+        let str = stringify.stringify(item, ctx, () => (comment = null), () => (chompKeep = true));
+        if (inFlow && i < items.length - 1)
+            str += ',';
+        str = addComment.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' + 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;
+    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 = 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;
-            }
-        }
-        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;
+            singleLineLength += node.str.length + 2;
         }
-        if (reqNewline) {
+        if (!singleLineOutput ||
+            singleLineLength > Collection.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 += stringifyComment.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 = stringifyComment.indentComment(commentString(comment), indent);
-        lines.push(ic.trimStart()); // Avoid double indent on first line
-    }
-}
 
 exports.stringifyCollection = stringifyCollection;

package/dist/stringify/stringifyDocument.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var Node = require('../nodes/Node.js');
+var addComment = require('./addComment.js');
 var stringify = require('./stringify.js');
-var stringifyComment = require('./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);
@@ -18,24 +18,20 @@ function stringifyDocument(doc, options) {
     }
     if (hasDirectives)
         lines.push('---');
-    const ctx = stringify.createStringifyContext(doc, options);
-    const { commentString } = ctx.options;
     if (doc.commentBefore) {
         if (lines.length !== 1)
             lines.unshift('');
-        const cs = commentString(doc.commentBefore);
-        lines.unshift(stringifyComment.indentComment(cs, ''));
+        lines.unshift(doc.commentBefore.replace(/^/gm, '#'));
     }
+    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) {
-                const cs = commentString(doc.contents.commentBefore);
-                lines.push(stringifyComment.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;
@@ -43,7 +39,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.lineComment(body, '', commentString(contentComment));
+            body = addComment.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
@@ -56,13 +52,10 @@ 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 (doc.comment) {
         if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
             lines.push('');
-        lines.push(stringifyComment.indentComment(commentString(dc), ''));
+        lines.push(doc.comment.replace(/^/gm, '#'));
     }
     return lines.join('\n') + '\n';
 }