yaml 2.0.0-7 → 2.0.0

package/dist/schema/Schema.d.ts

@@ -1,16 +1,18 @@
 import { MAP, SCALAR, SEQ } from '../nodes/Node.js';
 import type { Pair } from '../nodes/Pair.js';
-import type { SchemaOptions } from '../options.js';
+import type { SchemaOptions, ToStringOptions } 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: SchemaName;
+    name: string;
     sortMapEntries: ((a: Pair, b: Pair) => number) | null;
     tags: Array<CollectionTag | ScalarTag>;
+    toStringOptions: Readonly<ToStringOptions> | null;
     [MAP]: CollectionTag;
     [SCALAR]: ScalarTag;
     [SEQ]: CollectionTag;
-    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }: SchemaOptions);
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }: SchemaOptions);
+    clone(): Schema;
 }

package/dist/schema/Schema.js

@@ -8,17 +8,32 @@ var tags = require('./tags.js');
 
 const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 class Schema {
-    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }) {
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+        this.compat = Array.isArray(compat)
+            ? tags.getTags(compat, 'compat')
+            : compat
+                ? tags.getTags(null, compat)
+                : null;
         this.merge = !!merge;
-        this.name = schema || 'core';
+        this.name = (typeof schema === 'string' && schema) || 'core';
         this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
         this.tags = tags.getTags(customTags, this.name);
+        this.toStringOptions = toStringDefaults !== null && toStringDefaults !== void 0 ? 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 });
         // Used by createMap()
         this.sortMapEntries =
-            sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
+            typeof sortMapEntries === 'function'
+                ? sortMapEntries
+                : sortMapEntries === true
+                    ? sortMapEntriesByKey
+                    : null;
+    }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
     }
 }
 

package/dist/schema/common/null.js

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

package/dist/schema/core/float.js

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

package/dist/schema/tags.d.ts

@@ -1,5 +1,4 @@
 import { SchemaOptions } from '../options.js';
-import type { SchemaName } from './Schema.js';
 import type { CollectionTag, ScalarTag } from './types.js';
 declare const tagsByName: {
     binary: ScalarTag;
@@ -37,5 +36,5 @@ export declare const coreKnownTags: {
         test: RegExp;
     };
 };
-export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: SchemaName): (ScalarTag | CollectionTag)[];
+export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: string): (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 = {
-    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 = 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 tagsByName = {
     binary: binary.binary,
     bool: bool.boolTag,
@@ -50,13 +50,17 @@ const coreKnownTags = {
     'tag:yaml.org,2002:timestamp': timestamp.timestamp
 };
 function getTags(customTags, schemaName) {
-    let tags = schemas[schemaName];
+    let tags = schemas.get(schemaName);
     if (!tags) {
-        const keys = Object.keys(schemas)
-            .filter(key => key !== 'yaml11')
-            .map(key => JSON.stringify(key))
-            .join(', ');
-        throw new Error(`Unknown schema "${schemaName}"; use one of ${keys}`);
+        if (Array.isArray(customTags))
+            tags = [];
+        else {
+            const keys = Array.from(schemas.keys())
+                .filter(key => key !== 'yaml11')
+                .map(key => JSON.stringify(key))
+                .join(', ');
+            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+        }
     }
     if (Array.isArray(customTags)) {
         for (const tag of customTags)

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

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

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

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

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

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

package/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,14 +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,
@@ -21,57 +20,88 @@ const createStringifyContext = (doc, options) => ({
         minContentWidth: 20,
         nullStr: 'null',
         simpleKeys: false,
-        singleQuote: false,
+        singleQuote: null,
         trueStr: 'true',
         verifyAliasOrder: true
-    }, options)
-});
+    }, doc.schema.toStringOptions, options);
+    let inFlow;
+    switch (opt.collectionStyle) {
+        case 'block':
+            inFlow = false;
+            break;
+        case 'flow':
+            inFlow = true;
+            break;
+        default:
+            inFlow = null;
+    }
+    return {
+        anchors: new Set(),
+        doc,
+        indent: '',
+        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
+        inFlow,
+        options: opt
+    };
+}
 function getTagObject(tags, item) {
+    var _a, _b, _c, _d;
     if (item.tag) {
         const match = tags.filter(t => t.tag === item.tag);
         if (match.length > 0)
-            return match.find(t => t.format === item.format) || match[0];
+            return (_a = match.find(t => t.format === item.format)) !== null && _a !== void 0 ? _a : match[0];
     }
     let tagObj = undefined;
     let obj;
     if (Node.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: 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) {
+    var _a, _b;
     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 ((_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 = Node.isNode(item)
         ? item
@@ -80,7 +110,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)
         : 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,150 @@ 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) {
+    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 (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;