yaml 2.0.0-7 → 2.0.0

package/dist/stringify/stringifyDocument.js

@@ -5,33 +5,38 @@ var stringify = require('./stringify.js');
 var stringifyComment = require('./stringifyComment.js');
 
 function stringifyDocument(doc, options) {
+    var _a;
     const lines = [];
     let hasDirectives = options.directives === true;
-    if (options.directives !== false) {
+    if (options.directives !== false && doc.directives) {
         const dir = doc.directives.toString(doc);
         if (dir) {
             lines.push(dir);
             hasDirectives = true;
         }
-        else if (doc.directives.marker)
+        else if (doc.directives.docStart)
             hasDirectives = true;
     }
     if (hasDirectives)
         lines.push('---');
+    const ctx = 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 +44,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 +57,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 ((_a = doc.directives) === null || _a === void 0 ? void 0 : _a.docEnd) {
+        if (doc.comment) {
+            const cs = commentString(doc.comment);
+            if (cs.includes('\n')) {
+                lines.push('...');
+                lines.push(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';
 }

package/dist/stringify/stringifyPair.js

@@ -6,7 +6,7 @@ var stringify = require('./stringify.js');
 var stringifyComment = require('./stringifyComment.js');
 
 function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
-    const { allNullValues, doc, indent, indentStep, options: { indentSeq, simpleKeys } } = ctx;
+    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
     let keyComment = (Node.isNode(key) && key.comment) || null;
     if (simpleKeys) {
         if (keyComment) {
@@ -41,28 +41,39 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
         if (allNullValues || value == null) {
             if (keyCommentDone && onComment)
                 onComment();
-            return explicitKey ? `? ${str}` : str;
+            return str === '' ? '?' : explicitKey ? `? ${str}` : str;
         }
     }
     else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
-        if (keyCommentDone)
-            keyComment = null;
-        if (chompKeep && !keyComment && onChompKeep)
+        str = `? ${str}`;
+        if (keyComment && !keyCommentDone) {
+            str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+        }
+        else if (chompKeep && onChompKeep)
             onChompKeep();
-        return stringifyComment.addComment(`? ${str}`, ctx.indent, keyComment);
+        return str;
     }
     if (keyCommentDone)
         keyComment = null;
-    str = explicitKey
-        ? `? ${stringifyComment.addComment(str, ctx.indent, keyComment)}\n${indent}:`
-        : stringifyComment.addComment(`${str}:`, ctx.indent, keyComment);
+    if (explicitKey) {
+        if (keyComment)
+            str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+        str = `? ${str}\n${indent}:`;
+    }
+    else {
+        str = `${str}:`;
+        if (keyComment)
+            str += stringifyComment.lineComment(str, ctx.indent, commentString(keyComment));
+    }
     let vcb = '';
     let valueComment = null;
     if (Node.isNode(value)) {
         if (value.spaceBefore)
             vcb = '\n';
-        if (value.commentBefore)
-            vcb += `\n${stringifyComment.stringifyComment(value.commentBefore, ctx.indent)}`;
+        if (value.commentBefore) {
+            const cs = commentString(value.commentBefore);
+            vcb += `\n${stringifyComment.indentComment(cs, ctx.indent)}`;
+        }
         valueComment = value.comment;
     }
     else if (value && typeof value === 'object') {
@@ -87,27 +98,30 @@ function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
     const valueStr = stringify.stringify(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
     let ws = ' ';
     if (vcb || keyComment) {
-        ws = `${vcb}\n${ctx.indent}`;
+        if (valueStr === '' && !ctx.inFlow)
+            ws = vcb === '\n' ? '\n\n' : vcb;
+        else
+            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')
+    else if (valueStr === '' || valueStr[0] === '\n')
         ws = '';
+    str += ws + valueStr;
     if (ctx.inFlow) {
         if (valueCommentDone && onComment)
             onComment();
-        return str + ws + valueStr;
     }
-    else {
-        if (valueCommentDone)
-            valueComment = null;
-        if (chompKeep && !valueComment && onChompKeep)
-            onChompKeep();
-        return stringifyComment.addComment(str + ws + valueStr, ctx.indent, valueComment);
+    else if (valueComment && !valueCommentDone) {
+        str += stringifyComment.lineComment(str, ctx.indent, commentString(valueComment));
+    }
+    else if (chompKeep && onChompKeep) {
+        onChompKeep();
     }
+    return str;
 }
 
 exports.stringifyPair = stringifyPair;

package/dist/stringify/stringifyString.js

@@ -120,34 +120,50 @@ function doubleQuotedString(value, ctx) {
         : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx));
 }
 function singleQuotedString(value, ctx) {
-    if (ctx.implicitKey) {
-        if (/\n/.test(value))
-            return doubleQuotedString(value, ctx);
-    }
-    else {
-        // single quoted string can't have leading or trailing whitespace around newline
-        if (/[ \t]\n|\n[ \t]/.test(value))
-            return doubleQuotedString(value, ctx);
-    }
+    if (ctx.options.singleQuote === false ||
+        (ctx.implicitKey && value.includes('\n')) ||
+        /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline
+    )
+        return doubleQuotedString(value, ctx);
     const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
     const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
     return ctx.implicitKey
         ? res
         : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
 }
+function quotedString(value, ctx) {
+    const { singleQuote } = ctx.options;
+    let qs;
+    if (singleQuote === false)
+        qs = doubleQuotedString;
+    else {
+        const hasDouble = value.includes('"');
+        const hasSingle = value.includes("'");
+        if (hasDouble && !hasSingle)
+            qs = singleQuotedString;
+        else if (hasSingle && !hasDouble)
+            qs = doubleQuotedString;
+        else
+            qs = singleQuote ? singleQuotedString : doubleQuotedString;
+    }
+    return qs(value, ctx);
+}
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+    const { blockQuote, commentString, lineWidth } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
     // 2. Strings consisting of only whitespace are best rendered explicitly.
-    if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
-        return doubleQuotedString(value, ctx);
+    if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
+        return quotedString(value, ctx);
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const literal = type === Scalar.Scalar.BLOCK_FOLDED
-        ? false
-        : type === Scalar.Scalar.BLOCK_LITERAL
-            ? true
-            : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
+    const literal = blockQuote === 'literal'
+        ? true
+        : blockQuote === 'folded' || type === Scalar.Scalar.BLOCK_FOLDED
+            ? false
+            : type === Scalar.Scalar.BLOCK_LITERAL
+                ? true
+                : !lineLengthOverLimit(value, lineWidth, indent.length);
     if (!value)
         return literal ? '|\n' : '>\n';
     // determine chomping from whitespace at value end
@@ -198,7 +214,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     const indentSize = indent ? '2' : '1'; // root is at -1
     let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
-        header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
+        header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
         if (onComment)
             onComment();
     }
@@ -215,44 +231,28 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
-    var _a;
     const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
-        return doubleQuotedString(value, ctx);
+        return quotedString(value, ctx);
     }
     if (!value ||
         /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
-        const hasDouble = value.indexOf('"') !== -1;
-        const hasSingle = value.indexOf("'") !== -1;
-        let quotedString;
-        if (hasDouble && !hasSingle) {
-            quotedString = singleQuotedString;
-        }
-        else if (hasSingle && !hasDouble) {
-            quotedString = doubleQuotedString;
-        }
-        else if (ctx.options.singleQuote) {
-            quotedString = singleQuotedString;
-        }
-        else {
-            quotedString = doubleQuotedString;
-        }
         // not allowed:
         // - empty string, '-' or '?'
         // - start with an indicator character (except [?:-]) or /[?-] /
         // - '\n ', ': ' or ' \n' anywhere
         // - '#' not preceded by a non-space char
         // - end with ' ' or ':'
-        return implicitKey || inFlow || value.indexOf('\n') === -1
+        return implicitKey || inFlow || !value.includes('\n')
             ? quotedString(value, ctx)
             : blockString(item, ctx, onComment, onChompKeep);
     }
     if (!implicitKey &&
         !inFlow &&
         type !== Scalar.Scalar.PLAIN &&
-        value.indexOf('\n') !== -1) {
+        value.includes('\n')) {
         // Where allowed & type not set explicitly, prefer block style for multiline strings
         return blockString(item, ctx, onComment, onChompKeep);
     }
@@ -265,12 +265,10 @@ function plainString(item, ctx, onComment, onChompKeep) {
     // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
     // and others in v1.1.
     if (actualString) {
-        for (const tag of ctx.doc.schema.tags) {
-            if (tag.default &&
-                tag.tag !== 'tag:yaml.org,2002:str' &&
-                ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)))
-                return doubleQuotedString(value, ctx);
-        }
+        const test = (tag) => { var _a; return tag.default && tag.tag !== 'tag:yaml.org,2002:str' && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)); };
+        const { compat, tags } = ctx.doc.schema;
+        if (tags.some(test) || (compat === null || compat === void 0 ? void 0 : compat.some(test)))
+            return quotedString(value, ctx);
     }
     return implicitKey
         ? str
@@ -292,7 +290,7 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
             case Scalar.Scalar.BLOCK_FOLDED:
             case Scalar.Scalar.BLOCK_LITERAL:
                 return implicitKey || inFlow
-                    ? doubleQuotedString(ss.value, ctx) // blocks are not valid inside flow containers
+                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
                     : blockString(ss, ctx, onComment, onChompKeep);
             case Scalar.Scalar.QUOTE_DOUBLE:
                 return doubleQuotedString(ss.value, ctx);

package/dist/test-events.d.ts

@@ -1,4 +1,4 @@
 export declare function testEvents(src: string): {
     events: string[];
-    error: any;
+    error: unknown;
 };

package/dist/test-events.js

@@ -36,29 +36,28 @@ function testEvents(src) {
             let root = doc.contents;
             if (Array.isArray(root))
                 root = root[0];
-            // eslint-disable-next-line no-sparse-arrays
-            const [rootStart, , rootEnd] = doc.range || [0, , 0];
+            const [rootStart] = doc.range || [0];
             const error = doc.errors[0];
             if (error && (!error.pos || error.pos[0] < rootStart))
                 throw new Error();
             let docStart = '+DOC';
-            if (doc.directives.marker)
+            if (doc.directives.docStart)
                 docStart += ' ---';
-            else if (doc.contents && doc.contents.range[2] === doc.contents.range[0])
+            else if (doc.contents &&
+                doc.contents.range[2] === doc.contents.range[0] &&
+                !doc.contents.anchor &&
+                !doc.contents.tag)
                 continue;
             events.push(docStart);
             addEvents(events, doc, (_a = error === null || error === void 0 ? void 0 : error.pos[0]) !== null && _a !== void 0 ? _a : -1, root);
             let docEnd = '-DOC';
-            if (rootEnd) {
-                const post = src.slice(rootStart, rootEnd);
-                if (/^\.\.\.($|\s)/m.test(post))
-                    docEnd += ' ...';
-            }
+            if (doc.directives.docEnd)
+                docEnd += ' ...';
             events.push(docEnd);
         }
     }
     catch (e) {
-        return { events, error: error || e };
+        return { events, error: error !== null && error !== void 0 ? error : e };
     }
     events.push('-STR');
     return { events, error };
@@ -83,7 +82,8 @@ function addEvents(events, doc, errPos, node) {
     if (Node.isNode(node) && node.tag)
         props += ` <${node.tag}>`;
     if (Node.isMap(node)) {
-        events.push(`+MAP${props}`);
+        const ev = node.flow ? '+MAP {}' : '+MAP';
+        events.push(`${ev}${props}`);
         node.items.forEach(({ key, value }) => {
             addEvents(events, doc, errPos, key);
             addEvents(events, doc, errPos, value);
@@ -91,7 +91,8 @@ function addEvents(events, doc, errPos, node) {
         events.push('-MAP');
     }
     else if (Node.isSeq(node)) {
-        events.push(`+SEQ${props}`);
+        const ev = node.flow ? '+SEQ []' : '+SEQ';
+        events.push(`${ev}${props}`);
         node.items.forEach(item => {
             addEvents(events, doc, errPos, item);
         });

package/dist/util.d.ts

@@ -1,6 +1,9 @@
 export { debug, LogLevelId, warn } from './log.js';
 export { findPair } from './nodes/YAMLMap.js';
 export { toJS, ToJSContext } from './nodes/toJS.js';
+export { map as mapTag } from './schema/common/map.js';
+export { seq as seqTag } from './schema/common/seq.js';
+export { string as stringTag } from './schema/common/string.js';
 export { foldFlowLines } from './stringify/foldFlowLines';
 export { stringifyNumber } from './stringify/stringifyNumber.js';
 export { stringifyString } from './stringify/stringifyString.js';

package/dist/util.js

@@ -3,6 +3,9 @@
 var log = require('./log.js');
 var YAMLMap = require('./nodes/YAMLMap.js');
 var toJS = require('./nodes/toJS.js');
+var map = require('./schema/common/map.js');
+var seq = require('./schema/common/seq.js');
+var string = require('./schema/common/string.js');
 var foldFlowLines = require('./stringify/foldFlowLines.js');
 var stringifyNumber = require('./stringify/stringifyNumber.js');
 var stringifyString = require('./stringify/stringifyString.js');
@@ -13,6 +16,9 @@ exports.debug = log.debug;
 exports.warn = log.warn;
 exports.findPair = YAMLMap.findPair;
 exports.toJS = toJS.toJS;
+exports.mapTag = map.map;
+exports.seqTag = seq.seq;
+exports.stringTag = string.string;
 exports.foldFlowLines = foldFlowLines.foldFlowLines;
 exports.stringifyNumber = stringifyNumber.stringifyNumber;
 exports.stringifyString = stringifyString.stringifyString;

package/dist/visit.d.ts

@@ -16,6 +16,17 @@ export declare type visitor = visitorFn<unknown> | {
     Seq?: visitorFn<YAMLSeq>;
     Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
 };
+export declare type asyncVisitorFn<T> = (key: number | 'key' | 'value' | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair | Promise<void | symbol | number | Node | Pair>;
+export declare type asyncVisitor = asyncVisitorFn<unknown> | {
+    Alias?: asyncVisitorFn<Alias>;
+    Collection?: asyncVisitorFn<YAMLMap | YAMLSeq>;
+    Map?: asyncVisitorFn<YAMLMap>;
+    Node?: asyncVisitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+    Pair?: asyncVisitorFn<Pair>;
+    Scalar?: asyncVisitorFn<Scalar>;
+    Seq?: asyncVisitorFn<YAMLSeq>;
+    Value?: asyncVisitorFn<Scalar | YAMLMap | YAMLSeq>;
+};
 /**
  * Apply a visitor to an AST node or document.
  *
@@ -46,18 +57,46 @@ export declare type visitor = visitorFn<unknown> | {
  * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
  * specific defined one will be used for each node.
  */
-export declare function visit(node: Node | Document | null, visitor: visitorFn<unknown> | {
-    Alias?: visitorFn<Alias>;
-    Collection?: visitorFn<YAMLMap | YAMLSeq>;
-    Map?: visitorFn<YAMLMap>;
-    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
-    Pair?: visitorFn<Pair>;
-    Scalar?: visitorFn<Scalar>;
-    Seq?: visitorFn<YAMLSeq>;
-    Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
-}): void;
+export declare function visit(node: Node | Document | null, visitor: visitor): void;
 export declare namespace visit {
     var BREAK: symbol;
     var SKIP: symbol;
     var REMOVE: symbol;
 }
+/**
+ * Apply an async visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `Promise`: Must resolve to one of the following values
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+export declare function visitAsync(node: Node | Document | null, visitor: asyncVisitor): Promise<void>;
+export declare namespace visitAsync {
+    var BREAK: symbol;
+    var SKIP: symbol;
+    var REMOVE: symbol;
+}