cdk8s 2.7.62 → 2.7.63

package/node_modules/yaml/dist/stringify/stringifyString.js

@@ -3,8 +3,8 @@
 var Scalar = require('../nodes/Scalar.js');
 var foldFlowLines = require('./foldFlowLines.js');
 
-const getFoldOptions = (ctx) => ({
-    indentAtStart: ctx.indentAtStart,
+const getFoldOptions = (ctx, isBlock) => ({
+    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
     lineWidth: ctx.options.lineWidth,
     minContentWidth: ctx.options.minContentWidth
 });
@@ -117,37 +117,53 @@ function doubleQuotedString(value, ctx) {
     str = start ? str + json.slice(start) : json;
     return implicitKey
         ? str
-        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx));
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
 }
 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));
+        : foldFlowLines.foldFlowLines(res, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
+}
+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();
     }
@@ -211,70 +227,57 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
         //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx, true));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
-    var _a;
     const { type, value } = item;
-    const { actualString, implicitKey, indent, inFlow } = ctx;
+    const { actualString, implicitKey, indent, indentStep, 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);
     }
-    if (indent === '' && containsDocumentMarker(value)) {
-        ctx.forceBlockIndent = true;
-        return blockString(item, ctx, onComment, onChompKeep);
+    if (containsDocumentMarker(value)) {
+        if (indent === '') {
+            ctx.forceBlockIndent = true;
+            return blockString(item, ctx, onComment, onChompKeep);
+        }
+        else if (implicitKey && indent === indentStep) {
+            return quotedString(value, ctx);
+        }
     }
     const str = value.replace(/\n+/g, `$&\n${indent}`);
     // Verify that output will be parsed as a string, as e.g. plain numbers and
     // 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) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);
+        const { compat, tags } = ctx.doc.schema;
+        if (tags.some(test) || compat?.some(test))
+            return quotedString(value, ctx);
     }
     return implicitKey
         ? str
-        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx, false));
 }
 function stringifyString(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;
@@ -292,7 +295,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/node_modules/yaml/dist/test-events.d.ts

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

package/node_modules/yaml/dist/test-events.js

@@ -25,7 +25,6 @@ function anchorExists(doc, anchor) {
 }
 // test harness for yaml-test-suite event tests
 function testEvents(src) {
-    var _a;
     const docs = publicApi.parseAllDocuments(src);
     const errDoc = docs.find(doc => doc.errors.length > 0);
     const error = errDoc ? errDoc.errors[0].message : null;
@@ -36,29 +35,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);
+            addEvents(events, doc, error?.pos[0] ?? -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 ?? e };
     }
     events.push('-STR');
     return { events, error };
@@ -83,7 +81,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 +90,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/node_modules/yaml/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/node_modules/yaml/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/node_modules/yaml/dist/visit.d.ts

@@ -5,8 +5,8 @@ import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { YAMLMap } from './nodes/YAMLMap.js';
 import type { YAMLSeq } from './nodes/YAMLSeq.js';
-export declare type visitorFn<T> = (key: number | 'key' | 'value' | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair;
-export declare type visitor = visitorFn<unknown> | {
+export type visitorFn<T> = (key: number | 'key' | 'value' | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair;
+export type visitor = visitorFn<unknown> | {
     Alias?: visitorFn<Alias>;
     Collection?: visitorFn<YAMLMap | YAMLSeq>;
     Map?: visitorFn<YAMLMap>;
@@ -16,6 +16,17 @@ export declare type visitor = visitorFn<unknown> | {
     Seq?: visitorFn<YAMLSeq>;
     Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
 };
+export 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 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;
+}

package/node_modules/yaml/dist/visit.js

@@ -36,29 +36,14 @@ const REMOVE = Symbol('remove node');
  * specific defined one will be used for each node.
  */
 function visit(node, visitor) {
-    if (typeof visitor === 'object' &&
-        (visitor.Collection || visitor.Node || visitor.Value)) {
-        visitor = Object.assign({
-            Alias: visitor.Node,
-            Map: visitor.Node,
-            Scalar: visitor.Node,
-            Seq: visitor.Node
-        }, visitor.Value && {
-            Map: visitor.Value,
-            Scalar: visitor.Value,
-            Seq: visitor.Value
-        }, visitor.Collection && {
-            Map: visitor.Collection,
-            Seq: visitor.Collection
-        }, visitor);
-    }
+    const visitor_ = initVisitor(visitor);
     if (Node.isDocument(node)) {
-        const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
+        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
         if (cd === REMOVE)
             node.contents = null;
     }
     else
-        _visit(null, node, visitor, Object.freeze([]));
+        visit_(null, node, visitor_, Object.freeze([]));
 }
 // Without the `as symbol` casts, TS declares these in the `visit`
 // namespace using `var`, but then complains about that because
@@ -69,55 +54,104 @@ visit.BREAK = BREAK;
 visit.SKIP = SKIP;
 /** Remove the current node */
 visit.REMOVE = REMOVE;
-function _visit(key, node, visitor, path) {
-    let ctrl = undefined;
-    if (typeof visitor === 'function')
-        ctrl = visitor(key, node, path);
-    else if (Node.isMap(node)) {
-        if (visitor.Map)
-            ctrl = visitor.Map(key, node, path);
-    }
-    else if (Node.isSeq(node)) {
-        if (visitor.Seq)
-            ctrl = visitor.Seq(key, node, path);
-    }
-    else if (Node.isPair(node)) {
-        if (visitor.Pair)
-            ctrl = visitor.Pair(key, node, path);
+function visit_(key, node, visitor, path) {
+    const ctrl = callVisitor(key, node, visitor, path);
+    if (Node.isNode(ctrl) || Node.isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visit_(key, ctrl, visitor, path);
     }
-    else if (Node.isScalar(node)) {
-        if (visitor.Scalar)
-            ctrl = visitor.Scalar(key, node, path);
+    if (typeof ctrl !== 'symbol') {
+        if (Node.isCollection(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = visit_(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (Node.isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = visit_('key', node.key, visitor, path);
+            if (ck === BREAK)
+                return BREAK;
+            else if (ck === REMOVE)
+                node.key = null;
+            const cv = visit_('value', node.value, visitor, path);
+            if (cv === BREAK)
+                return BREAK;
+            else if (cv === REMOVE)
+                node.value = null;
+        }
     }
-    else if (Node.isAlias(node)) {
-        if (visitor.Alias)
-            ctrl = visitor.Alias(key, node, path);
+    return ctrl;
+}
+/**
+ * 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.
+ */
+async function visitAsync(node, visitor) {
+    const visitor_ = initVisitor(visitor);
+    if (Node.isDocument(node)) {
+        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));
+        if (cd === REMOVE)
+            node.contents = null;
     }
+    else
+        await visitAsync_(null, node, visitor_, Object.freeze([]));
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visitAsync.BREAK = BREAK;
+/** Do not visit the children of the current node */
+visitAsync.SKIP = SKIP;
+/** Remove the current node */
+visitAsync.REMOVE = REMOVE;
+async function visitAsync_(key, node, visitor, path) {
+    const ctrl = await callVisitor(key, node, visitor, path);
     if (Node.isNode(ctrl) || Node.isPair(ctrl)) {
-        const parent = path[path.length - 1];
-        if (Node.isCollection(parent)) {
-            parent.items[key] = ctrl;
-        }
-        else if (Node.isPair(parent)) {
-            if (key === 'key')
-                parent.key = ctrl;
-            else
-                parent.value = ctrl;
-        }
-        else if (Node.isDocument(parent)) {
-            parent.contents = ctrl;
-        }
-        else {
-            const pt = Node.isAlias(parent) ? 'alias' : 'scalar';
-            throw new Error(`Cannot replace node with ${pt} parent`);
-        }
-        return _visit(key, ctrl, visitor, path);
+        replaceNode(key, path, ctrl);
+        return visitAsync_(key, ctrl, visitor, path);
     }
     if (typeof ctrl !== 'symbol') {
         if (Node.isCollection(node)) {
             path = Object.freeze(path.concat(node));
             for (let i = 0; i < node.items.length; ++i) {
-                const ci = _visit(i, node.items[i], visitor, path);
+                const ci = await visitAsync_(i, node.items[i], visitor, path);
                 if (typeof ci === 'number')
                     i = ci - 1;
                 else if (ci === BREAK)
@@ -130,12 +164,12 @@ function _visit(key, node, visitor, path) {
         }
         else if (Node.isPair(node)) {
             path = Object.freeze(path.concat(node));
-            const ck = _visit('key', node.key, visitor, path);
+            const ck = await visitAsync_('key', node.key, visitor, path);
             if (ck === BREAK)
                 return BREAK;
             else if (ck === REMOVE)
                 node.key = null;
-            const cv = _visit('value', node.value, visitor, path);
+            const cv = await visitAsync_('value', node.value, visitor, path);
             if (cv === BREAK)
                 return BREAK;
             else if (cv === REMOVE)
@@ -144,5 +178,59 @@ function _visit(key, node, visitor, path) {
     }
     return ctrl;
 }
+function initVisitor(visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        return Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
+    }
+    return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+    if (typeof visitor === 'function')
+        return visitor(key, node, path);
+    if (Node.isMap(node))
+        return visitor.Map?.(key, node, path);
+    if (Node.isSeq(node))
+        return visitor.Seq?.(key, node, path);
+    if (Node.isPair(node))
+        return visitor.Pair?.(key, node, path);
+    if (Node.isScalar(node))
+        return visitor.Scalar?.(key, node, path);
+    if (Node.isAlias(node))
+        return visitor.Alias?.(key, node, path);
+    return undefined;
+}
+function replaceNode(key, path, node) {
+    const parent = path[path.length - 1];
+    if (Node.isCollection(parent)) {
+        parent.items[key] = node;
+    }
+    else if (Node.isPair(parent)) {
+        if (key === 'key')
+            parent.key = node;
+        else
+            parent.value = node;
+    }
+    else if (Node.isDocument(parent)) {
+        parent.contents = node;
+    }
+    else {
+        const pt = Node.isAlias(parent) ? 'alias' : 'scalar';
+        throw new Error(`Cannot replace node with ${pt} parent`);
+    }
+}
 
 exports.visit = visit;
+exports.visitAsync = visitAsync;