yaml 2.0.0-4 → 2.0.0-5

package/dist/{tags → schema}/yaml-1.1/pairs.d.ts

@@ -1,9 +1,10 @@
 import type { CreateNodeContext } from '../../doc/createNode.js';
-import type { Schema } from '../../doc/Schema.js';
+import { ParsedNode } from '../../nodes/Node.js';
 import { Pair } from '../../nodes/Pair.js';
 import { YAMLMap } from '../../nodes/YAMLMap.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
+import type { Schema } from '../../schema/Schema.js';
 import type { CollectionTag } from '../types.js';
-export declare function resolvePairs(seq: YAMLSeq | YAMLMap, onError: (message: string) => void): YAMLSeq<Pair<unknown, unknown>>;
+export declare function resolvePairs(seq: YAMLSeq.Parsed<ParsedNode | Pair<ParsedNode, ParsedNode | null>> | YAMLMap.Parsed, onError: (message: string) => void): YAMLSeq.Parsed<Pair<ParsedNode, ParsedNode | null>>;
 export declare function createPairs(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLSeq<unknown>;
 export declare const pairs: CollectionTag;

package/dist/{tags → schema}/yaml-1.1/pairs.js

@@ -2,6 +2,7 @@
 
 var Node = require('../../nodes/Node.js');
 var Pair = require('../../nodes/Pair.js');
+var Scalar = require('../../nodes/Scalar.js');
 var YAMLSeq = require('../../nodes/YAMLSeq.js');
 
 function resolvePairs(seq, onError) {
@@ -13,15 +14,17 @@ function resolvePairs(seq, onError) {
             else if (Node.isMap(item)) {
                 if (item.items.length > 1)
                     onError('Each pair must have its own sequence indicator');
-                const pair = item.items[0] || new Pair.Pair(null);
+                const pair = item.items[0] || new Pair.Pair(new Scalar.Scalar(null));
                 if (item.commentBefore)
-                    pair.commentBefore = pair.commentBefore
-                        ? `${item.commentBefore}\n${pair.commentBefore}`
+                    pair.key.commentBefore = pair.key.commentBefore
+                        ? `${item.commentBefore}\n${pair.key.commentBefore}`
                         : item.commentBefore;
-                if (item.comment)
-                    pair.comment = pair.comment
-                        ? `${item.comment}\n${pair.comment}`
+                if (item.comment) {
+                    const cn = pair.value || pair.key;
+                    cn.comment = cn.comment
+                        ? `${item.comment}\n${cn.comment}`
                         : item.comment;
+                }
                 item = pair;
             }
             seq.items[i] = Node.isPair(item) ? item : new Pair.Pair(item);

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

@@ -0,0 +1 @@
+export declare const schema: (import("../types.js").ScalarTag | import("../types.js").CollectionTag)[];

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

@@ -0,0 +1,39 @@
+'use strict';
+
+var map = require('../common/map.js');
+var _null = require('../common/null.js');
+var seq = require('../common/seq.js');
+var string = require('../common/string.js');
+var binary = require('./binary.js');
+var bool = require('./bool.js');
+var float = require('./float.js');
+var int = require('./int.js');
+var omap = require('./omap.js');
+var pairs = require('./pairs.js');
+var set = require('./set.js');
+var timestamp = require('./timestamp.js');
+
+const schema = [
+    map.map,
+    seq.seq,
+    string.string,
+    _null.nullTag,
+    bool.trueTag,
+    bool.falseTag,
+    int.intBin,
+    int.intOct,
+    int.int,
+    int.intHex,
+    float.floatNaN,
+    float.floatExp,
+    float.float,
+    binary.binary,
+    omap.omap,
+    pairs.pairs,
+    set.set,
+    timestamp.intTime,
+    timestamp.floatTime,
+    timestamp.timestamp
+];
+
+exports.schema = schema;

package/dist/{tags → schema}/yaml-1.1/set.d.ts

@@ -1,4 +1,4 @@
-import type { Schema } from '../../doc/Schema.js';
+import type { Schema } from '../../schema/Schema.js';
 import { Pair } from '../../nodes/Pair.js';
 import { Scalar } from '../../nodes/Scalar.js';
 import { ToJSContext } from '../../nodes/toJS.js';

package/dist/stringify/addComment.js

@@ -1,11 +1,5 @@
 'use strict';
 
-function addCommentBefore(str, indent, comment) {
-    if (!comment)
-        return str;
-    const cc = comment.replace(/[\s\S]^/gm, `$&${indent}#`);
-    return `#${cc}\n${indent}${str}`;
-}
 function addComment(str, indent, comment) {
     return !comment
         ? str
@@ -17,4 +11,3 @@ function addComment(str, indent, comment) {
 }
 
 exports.addComment = addComment;
-exports.addCommentBefore = addCommentBefore;

package/dist/stringify/stringify.d.ts

@@ -1,10 +1,9 @@
 import type { Document } from '../doc/Document.js';
-import { Node } from '../nodes/Node.js';
 import type { ToStringOptions } from '../options.js';
 export declare type StringifyContext = {
     actualString?: boolean;
     allNullValues?: boolean;
-    anchors: Record<string, Node>;
+    anchors: Set<string>;
     doc: Document;
     forceBlockIndent?: boolean;
     implicitKey?: boolean;

package/dist/stringify/stringify.js

@@ -1,10 +1,11 @@
 'use strict';
 
+var anchors = require('../doc/anchors.js');
 var Node = require('../nodes/Node.js');
 var stringifyString = require('./stringifyString.js');
 
 const createStringifyContext = (doc, options) => ({
-    anchors: Object.create(null),
+    anchors: new Set(),
     doc,
     indent: '',
     indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
@@ -21,7 +22,8 @@ const createStringifyContext = (doc, options) => ({
         nullStr: 'null',
         simpleKeys: false,
         singleQuote: false,
-        trueStr: 'true'
+        trueStr: 'true',
+        verifyAliasOrder: true
     }, options)
 });
 function getTagObject(tags, item) {
@@ -50,11 +52,11 @@ function getTagObject(tags, item) {
     return tagObj;
 }
 // needs to be called before value stringifier to allow for circular anchor refs
-function stringifyProps(node, tagObj, { anchors, doc }) {
+function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) {
     const props = [];
-    const anchor = doc.anchors.getName(node);
-    if (anchor) {
-        anchors[anchor] = node;
+    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) {

package/dist/stringify/stringifyCollection.d.ts

@@ -0,0 +1,21 @@
+import { Collection } from '../nodes/Collection.js';
+import { StringifyContext } from '../stringify/stringify.js';
+declare type StringifyNode = {
+    comment: boolean;
+    str: string;
+};
+interface StringifyCollectionOptions {
+    blockItem(node: StringifyNode): string;
+    flowChars: {
+        start: '{';
+        end: '}';
+    } | {
+        start: '[';
+        end: ']';
+    };
+    itemIndent: string;
+    onChompKeep?: () => void;
+    onComment?: () => void;
+}
+export declare function stringifyCollection({ comment, flow, items }: Readonly<Collection>, ctx: StringifyContext, { blockItem, flowChars, itemIndent, onChompKeep, onComment }: StringifyCollectionOptions): string;
+export {};

package/dist/stringify/stringifyCollection.js

@@ -0,0 +1,110 @@
+'use strict';
+
+var Collection = require('../nodes/Collection.js');
+var addComment = require('./addComment.js');
+var stringify = require('./stringify.js');
+var Node = require('../nodes/Node.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;
+    let chompKeep = false; // flag for the preceding node's status
+    const nodes = items.reduce((nodes, item, i) => {
+        let comment = null;
+        if (Node.isNode(item)) {
+            if (!chompKeep && item.spaceBefore)
+                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)
+                    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, ctx, () => (comment = null), () => (chompKeep = true));
+        if (inFlow && i < items.length - 1)
+            str += ',';
+        str = addComment.addComment(str, itemIndent, comment);
+        if (chompKeep && (comment || inFlow))
+            chompKeep = false;
+        nodes.push({ comment: false, str });
+        return nodes;
+    }, []);
+    let str;
+    if (nodes.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;
+            }
+            singleLineLength += node.str.length + 2;
+        }
+        if (!singleLineOutput ||
+            singleLineLength > Collection.Collection.maxFlowStringSingleLineLength) {
+            str = start;
+            for (const s of strings) {
+                str += s ? `\n${indentStep}${indent}${s}` : '\n';
+            }
+            str += `\n${indent}${end}`;
+        }
+        else {
+            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 += '\n' + comment.replace(/^/gm, `${indent}#`);
+        if (onComment)
+            onComment();
+    }
+    else if (chompKeep && onChompKeep)
+        onChompKeep();
+    return str;
+}
+
+exports.stringifyCollection = stringifyCollection;

package/dist/stringify/stringifyDocument.d.ts

@@ -0,0 +1,3 @@
+import { Document } from '../doc/Document.js';
+import { ToStringOptions } from '../options.js';
+export declare function stringifyDocument(doc: Readonly<Document>, options: ToStringOptions): string;

package/dist/stringify/stringifyDocument.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var addComment = require('./addComment.js');
+var stringify = require('./stringify.js');
+
+function stringifyDocument(doc, options) {
+    const lines = [];
+    let hasDirectives = options.directives === true;
+    if (options.directives !== false) {
+        const dir = doc.directives.toString(doc);
+        if (dir) {
+            lines.push(dir);
+            hasDirectives = true;
+        }
+        else if (doc.directives.marker)
+            hasDirectives = true;
+    }
+    if (hasDirectives)
+        lines.push('---');
+    if (doc.commentBefore) {
+        if (lines.length !== 1)
+            lines.unshift('');
+        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)
+                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;
+        }
+        const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
+        let body = stringify.stringify(doc.contents, ctx, () => (contentComment = null), onChompKeep);
+        if (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
+            // same line for their header.
+            lines[lines.length - 1] = `--- ${body}`;
+        }
+        else
+            lines.push(body);
+    }
+    else {
+        lines.push(stringify.stringify(doc.contents, ctx));
+    }
+    if (doc.comment) {
+        if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+            lines.push('');
+        lines.push(doc.comment.replace(/^/gm, '#'));
+    }
+    return lines.join('\n') + '\n';
+}
+
+exports.stringifyDocument = stringifyDocument;

package/dist/stringify/stringifyPair.d.ts

@@ -0,0 +1,3 @@
+import type { Pair } from '../nodes/Pair.js';
+import { StringifyContext } from './stringify.js';
+export declare function stringifyPair({ key, value }: Readonly<Pair>, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;

package/dist/stringify/stringifyPair.js

@@ -0,0 +1,115 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var Scalar = require('../nodes/Scalar.js');
+var addComment = require('./addComment.js');
+var stringify = require('./stringify.js');
+
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+    const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
+    let keyComment = (Node.isNode(key) && key.comment) || null;
+    if (simpleKeys) {
+        if (keyComment) {
+            throw new Error('With simple keys, key nodes cannot have comments');
+        }
+        if (Node.isCollection(key)) {
+            const msg = 'With simple keys, collection cannot be used as a key value';
+            throw new Error(msg);
+        }
+    }
+    let explicitKey = !simpleKeys &&
+        (!key ||
+            (keyComment && value == null && !ctx.inFlow) ||
+            Node.isCollection(key) ||
+            (Node.isScalar(key)
+                ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL
+                : typeof key === 'object'));
+    ctx = Object.assign({}, ctx, {
+        allNullValues: false,
+        implicitKey: !explicitKey && (simpleKeys || !allNullValues),
+        indent: indent + indentStep
+    });
+    let keyCommentDone = false;
+    let chompKeep = false;
+    let str = stringify.stringify(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));
+    if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+        if (simpleKeys)
+            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
+        explicitKey = true;
+    }
+    if (ctx.inFlow) {
+        if (allNullValues || value == null) {
+            if (keyCommentDone && onComment)
+                onComment();
+            return explicitKey ? `? ${str}` : str;
+        }
+    }
+    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
+        if (keyCommentDone)
+            keyComment = null;
+        if (chompKeep && !keyComment && onChompKeep)
+            onChompKeep();
+        return addComment.addComment(`? ${str}`, ctx.indent, keyComment);
+    }
+    if (keyCommentDone)
+        keyComment = null;
+    str = explicitKey
+        ? `? ${addComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
+        : addComment.addComment(`${str}:`, ctx.indent, keyComment);
+    let vcb = '';
+    let valueComment = null;
+    if (Node.isNode(value)) {
+        if (value.spaceBefore)
+            vcb = '\n';
+        if (value.commentBefore) {
+            const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
+            vcb += `\n${cs}`;
+        }
+        valueComment = value.comment;
+    }
+    else if (value && typeof value === 'object') {
+        value = doc.createNode(value);
+    }
+    ctx.implicitKey = false;
+    if (!explicitKey && !keyComment && Node.isScalar(value))
+        ctx.indentAtStart = str.length + 1;
+    chompKeep = false;
+    if (!indentSeq &&
+        indentStep.length >= 2 &&
+        !ctx.inFlow &&
+        !explicitKey &&
+        Node.isSeq(value) &&
+        !value.flow &&
+        !value.tag &&
+        !value.anchor) {
+        // If indentSeq === false, consider '- ' as part of indentation where possible
+        ctx.indent = ctx.indent.substr(2);
+    }
+    let valueCommentDone = false;
+    const valueStr = stringify.stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
+    let ws = ' ';
+    if (vcb || keyComment) {
+        ws = `${vcb}\n${ctx.indent}`;
+    }
+    else if (!explicitKey && Node.isCollection(value)) {
+        const flow = valueStr[0] === '[' || valueStr[0] === '{';
+        if (!flow || valueStr.includes('\n'))
+            ws = `\n${ctx.indent}`;
+    }
+    else if (valueStr[0] === '\n')
+        ws = '';
+    if (ctx.inFlow) {
+        if (valueCommentDone && onComment)
+            onComment();
+        return str + ws + valueStr;
+    }
+    else {
+        if (valueCommentDone)
+            valueComment = null;
+        if (chompKeep && !valueComment && onChompKeep)
+            onChompKeep();
+        return addComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
+    }
+}
+
+exports.stringifyPair = stringifyPair;

package/dist/stringify/stringifyString.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var Scalar = require('../nodes/Scalar.js');
-var addComment = require('./addComment.js');
 var foldFlowLines = require('./foldFlowLines.js');
 
 const getFoldOptions = (ctx) => ({
@@ -144,70 +143,80 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const indentSize = indent ? '2' : '1'; // root is at -1
     const literal = type === Scalar.Scalar.BLOCK_FOLDED
         ? false
         : type === Scalar.Scalar.BLOCK_LITERAL
             ? true
             : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
-    let header = literal ? '|' : '>';
     if (!value)
-        return header + '\n';
-    let wsStart = '';
-    let wsEnd = '';
-    value = value
-        .replace(/[\n\t ]*$/, ws => {
-        const n = ws.indexOf('\n');
-        if (n === -1) {
-            header += '-'; // strip
-        }
-        else if (value === ws || n !== ws.length - 1) {
-            header += '+'; // keep
-            if (onChompKeep)
-                onChompKeep();
-        }
-        wsEnd = ws.replace(/\n$/, '');
-        return '';
-    })
-        .replace(/^[\n ]*/, ws => {
-        if (ws.indexOf(' ') !== -1)
-            header += indentSize;
-        const m = ws.match(/ +$/);
-        if (m) {
-            wsStart = ws.slice(0, -m[0].length);
-            return m[0];
-        }
-        else {
-            wsStart = ws;
-            return '';
-        }
-    });
-    if (wsEnd)
-        wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`);
-    if (wsStart)
-        wsStart = wsStart.replace(/\n+/g, `$&${indent}`);
+        return literal ? '|\n' : '>\n';
+    // determine chomping from whitespace at value end
+    let chomp;
+    let endStart;
+    for (endStart = value.length; endStart > 0; --endStart) {
+        const ch = value[endStart - 1];
+        if (ch !== '\n' && ch !== '\t' && ch !== ' ')
+            break;
+    }
+    let end = value.substring(endStart);
+    const endNlPos = end.indexOf('\n');
+    if (endNlPos === -1) {
+        chomp = '-'; // strip
+    }
+    else if (value === end || endNlPos !== end.length - 1) {
+        chomp = '+'; // keep
+        if (onChompKeep)
+            onChompKeep();
+    }
+    else {
+        chomp = ''; // clip
+    }
+    if (end) {
+        value = value.slice(0, -end.length);
+        if (end[end.length - 1] === '\n')
+            end = end.slice(0, -1);
+        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
+    }
+    // determine indent indicator from whitespace at value start
+    let startWithSpace = false;
+    let startEnd;
+    let startNlPos = -1;
+    for (startEnd = 0; startEnd < value.length; ++startEnd) {
+        const ch = value[startEnd];
+        if (ch === ' ')
+            startWithSpace = true;
+        else if (ch === '\n')
+            startNlPos = startEnd;
+        else
+            break;
+    }
+    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+    if (start) {
+        value = value.substring(start.length);
+        start = start.replace(/\n+/g, `$&${indent}`);
+    }
+    const indentSize = indent ? '2' : '1'; // root is at -1
+    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
         header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
         if (onComment)
             onComment();
     }
-    if (!value)
-        return `${header}${indentSize}\n${indent}${wsEnd}`;
     if (literal) {
         value = value.replace(/\n+/g, `$&${indent}`);
-        return `${header}\n${indent}${wsStart}${value}${wsEnd}`;
+        return `${header}\n${indent}${start}${value}${end}`;
     }
     value = value
         .replace(/\n+/g, '\n$&')
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
-        //         ^ ind.line  ^ empty     ^ capture next empty lines only at end of indent
+        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines.foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
     var _a;
-    const { comment, type, value } = item;
+    const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
@@ -263,17 +272,9 @@ function plainString(item, ctx, onComment, onChompKeep) {
                 return doubleQuotedString(value, ctx);
         }
     }
-    const body = implicitKey
+    return implicitKey
         ? str
         : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
-    if (comment &&
-        !inFlow &&
-        (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
-        if (onComment)
-            onComment();
-        return addComment.addCommentBefore(body, indent, comment);
-    }
-    return body;
 }
 function stringifyString(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;

package/dist/test-events.d.ts

@@ -1,5 +1,4 @@
-import type { Options } from './options.js';
-export declare function testEvents(src: string, options?: Options): {
+export declare function testEvents(src: string): {
     events: string[];
     error: any;
 };