@crouton-kit/crouter 0.3.33 → 0.3.34

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/stringify/stringifyString.js

@@ -0,0 +1,338 @@
+'use strict';
+
+var Scalar = require('../nodes/Scalar.js');
+var foldFlowLines = require('./foldFlowLines.js');
+
+const getFoldOptions = (ctx, isBlock) => ({
+    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
+    lineWidth: ctx.options.lineWidth,
+    minContentWidth: ctx.options.minContentWidth
+});
+// Also checks for lines starting with %, as parsing the output as YAML 1.1 will
+// presume that's starting a new document.
+const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
+function lineLengthOverLimit(str, lineWidth, indentLength) {
+    if (!lineWidth || lineWidth < 0)
+        return false;
+    const limit = lineWidth - indentLength;
+    const strLen = str.length;
+    if (strLen <= limit)
+        return false;
+    for (let i = 0, start = 0; i < strLen; ++i) {
+        if (str[i] === '\n') {
+            if (i - start > limit)
+                return true;
+            start = i + 1;
+            if (strLen - start <= limit)
+                return false;
+        }
+    }
+    return true;
+}
+function doubleQuotedString(value, ctx) {
+    const json = JSON.stringify(value);
+    if (ctx.options.doubleQuotedAsJSON)
+        return json;
+    const { implicitKey } = ctx;
+    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
+    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
+    let str = '';
+    let start = 0;
+    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
+        if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') {
+            // space before newline needs to be escaped to not be folded
+            str += json.slice(start, i) + '\\ ';
+            i += 1;
+            start = i;
+            ch = '\\';
+        }
+        if (ch === '\\')
+            switch (json[i + 1]) {
+                case 'u':
+                    {
+                        str += json.slice(start, i);
+                        const code = json.substr(i + 2, 4);
+                        switch (code) {
+                            case '0000':
+                                str += '\\0';
+                                break;
+                            case '0007':
+                                str += '\\a';
+                                break;
+                            case '000b':
+                                str += '\\v';
+                                break;
+                            case '001b':
+                                str += '\\e';
+                                break;
+                            case '0085':
+                                str += '\\N';
+                                break;
+                            case '00a0':
+                                str += '\\_';
+                                break;
+                            case '2028':
+                                str += '\\L';
+                                break;
+                            case '2029':
+                                str += '\\P';
+                                break;
+                            default:
+                                if (code.substr(0, 2) === '00')
+                                    str += '\\x' + code.substr(2);
+                                else
+                                    str += json.substr(i, 6);
+                        }
+                        i += 5;
+                        start = i + 1;
+                    }
+                    break;
+                case 'n':
+                    if (implicitKey ||
+                        json[i + 2] === '"' ||
+                        json.length < minMultiLineLength) {
+                        i += 1;
+                    }
+                    else {
+                        // folding will eat first newline
+                        str += json.slice(start, i) + '\n\n';
+                        while (json[i + 2] === '\\' &&
+                            json[i + 3] === 'n' &&
+                            json[i + 4] !== '"') {
+                            str += '\n';
+                            i += 2;
+                        }
+                        str += indent;
+                        // space after newline needs to be escaped to not be folded
+                        if (json[i + 2] === ' ')
+                            str += '\\';
+                        i += 1;
+                        start = i + 1;
+                    }
+                    break;
+                default:
+                    i += 1;
+            }
+    }
+    str = start ? str + json.slice(start) : json;
+    return implicitKey
+        ? str
+        : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_QUOTED, getFoldOptions(ctx, false));
+}
+function singleQuotedString(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, 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);
+}
+// The negative lookbehind avoids a polynomial search,
+// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind
+let blockEndNewlines;
+try {
+    blockEndNewlines = new RegExp('(^|(?<!\n))\n+(?!\n|$)', 'g');
+}
+catch {
+    blockEndNewlines = /\n+(?!\n|$)/g;
+}
+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 (!blockQuote || /\n[\t ]+$/.test(value)) {
+        return quotedString(value, ctx);
+    }
+    const indent = ctx.indent ||
+        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
+    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
+    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(blockEndNewlines, `$&${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
+    // Leading | or > is added later
+    let header = (startWithSpace ? indentSize : '') + chomp;
+    if (comment) {
+        header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
+        if (onComment)
+            onComment();
+    }
+    if (!literal) {
+        const foldedValue = value
+            .replace(/\n+/g, '\n$&')
+            .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}`);
+        let literalFallback = false;
+        const foldOptions = getFoldOptions(ctx, true);
+        if (blockQuote !== 'folded' && type !== Scalar.Scalar.BLOCK_FOLDED) {
+            foldOptions.onOverflow = () => {
+                literalFallback = true;
+            };
+        }
+        const body = foldFlowLines.foldFlowLines(`${start}${foldedValue}${end}`, indent, foldFlowLines.FOLD_BLOCK, foldOptions);
+        if (!literalFallback)
+            return `>${header}\n${indent}${body}`;
+    }
+    value = value.replace(/\n+/g, `$&${indent}`);
+    return `|${header}\n${indent}${start}${value}${end}`;
+}
+function plainString(item, ctx, onComment, onChompKeep) {
+    const { type, value } = item;
+    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+    if ((implicitKey && value.includes('\n')) ||
+        (inFlow && /[[\]{},]/.test(value))) {
+        return quotedString(value, ctx);
+    }
+    if (/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
+        // not allowed:
+        // - '-' 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.includes('\n')
+            ? quotedString(value, ctx)
+            : blockString(item, ctx, onComment, onChompKeep);
+    }
+    if (!implicitKey &&
+        !inFlow &&
+        type !== Scalar.Scalar.PLAIN &&
+        value.includes('\n')) {
+        // Where allowed & type not set explicitly, prefer block style for multiline strings
+        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) {
+        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, false));
+}
+function stringifyString(item, ctx, onComment, onChompKeep) {
+    const { implicitKey, inFlow } = ctx;
+    const ss = typeof item.value === 'string'
+        ? item
+        : Object.assign({}, item, { value: String(item.value) });
+    let { type } = item;
+    if (type !== Scalar.Scalar.QUOTE_DOUBLE) {
+        // force double quotes on control characters & unpaired surrogates
+        if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value))
+            type = Scalar.Scalar.QUOTE_DOUBLE;
+    }
+    const _stringify = (_type) => {
+        switch (_type) {
+            case Scalar.Scalar.BLOCK_FOLDED:
+            case Scalar.Scalar.BLOCK_LITERAL:
+                return implicitKey || inFlow
+                    ? 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);
+            case Scalar.Scalar.QUOTE_SINGLE:
+                return singleQuotedString(ss.value, ctx);
+            case Scalar.Scalar.PLAIN:
+                return plainString(ss, ctx, onComment, onChompKeep);
+            default:
+                return null;
+        }
+    };
+    let res = _stringify(type);
+    if (res === null) {
+        const { defaultKeyType, defaultStringType } = ctx.options;
+        const t = (implicitKey && defaultKeyType) || defaultStringType;
+        res = _stringify(t);
+        if (res === null)
+            throw new Error(`Unsupported default string type ${t}`);
+    }
+    return res;
+}
+
+exports.stringifyString = stringifyString;

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/test-events.d.ts

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

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/test-events.js

@@ -0,0 +1,134 @@
+'use strict';
+
+var identity = require('./nodes/identity.js');
+var publicApi = require('./public-api.js');
+var visit = require('./visit.js');
+
+const scalarChar = {
+    BLOCK_FOLDED: '>',
+    BLOCK_LITERAL: '|',
+    PLAIN: ':',
+    QUOTE_DOUBLE: '"',
+    QUOTE_SINGLE: "'"
+};
+function anchorExists(doc, anchor) {
+    let found = false;
+    visit.visit(doc, {
+        Value(_key, node) {
+            if (node.anchor === anchor) {
+                found = true;
+                return visit.visit.BREAK;
+            }
+        }
+    });
+    return found;
+}
+// test harness for yaml-test-suite event tests
+function testEvents(src) {
+    const docs = publicApi.parseAllDocuments(src);
+    const errDoc = docs.find(doc => doc.errors.length > 0);
+    const error = errDoc ? errDoc.errors[0].message : null;
+    const events = ['+STR'];
+    try {
+        for (let i = 0; i < docs.length; ++i) {
+            const doc = docs[i];
+            let root = doc.contents;
+            if (Array.isArray(root))
+                root = root[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.docStart)
+                docStart += ' ---';
+            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, error?.pos[0] ?? -1, root);
+            let docEnd = '-DOC';
+            if (doc.directives.docEnd)
+                docEnd += ' ...';
+            events.push(docEnd);
+        }
+    }
+    catch (e) {
+        return { events, error: error ?? e };
+    }
+    events.push('-STR');
+    return { events, error };
+}
+function addEvents(events, doc, errPos, node) {
+    if (!node) {
+        events.push('=VAL :');
+        return;
+    }
+    if (errPos !== -1 && identity.isNode(node) && node.range[0] >= errPos)
+        throw new Error();
+    let props = '';
+    let anchor = identity.isScalar(node) || identity.isCollection(node) ? node.anchor : undefined;
+    if (anchor) {
+        if (/\d$/.test(anchor)) {
+            const alt = anchor.replace(/\d$/, '');
+            if (anchorExists(doc, alt))
+                anchor = alt;
+        }
+        props = ` &${anchor}`;
+    }
+    if (identity.isNode(node) && node.tag)
+        props += ` <${node.tag}>`;
+    if (identity.isMap(node)) {
+        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);
+        });
+        events.push('-MAP');
+    }
+    else if (identity.isSeq(node)) {
+        const ev = node.flow ? '+SEQ []' : '+SEQ';
+        events.push(`${ev}${props}`);
+        node.items.forEach(item => {
+            addEvents(events, doc, errPos, item);
+        });
+        events.push('-SEQ');
+    }
+    else if (identity.isPair(node)) {
+        events.push(`+MAP${props}`);
+        addEvents(events, doc, errPos, node.key);
+        addEvents(events, doc, errPos, node.value);
+        events.push('-MAP');
+    }
+    else if (identity.isAlias(node)) {
+        let alias = node.source;
+        if (alias && /\d$/.test(alias)) {
+            const alt = alias.replace(/\d$/, '');
+            if (anchorExists(doc, alt))
+                alias = alt;
+        }
+        events.push(`=ALI${props} *${alias}`);
+    }
+    else {
+        const scalar = scalarChar[String(node.type)];
+        if (!scalar)
+            throw new Error(`Unexpected node type ${node.type}`);
+        const value = node.source
+            .replace(/\\/g, '\\\\')
+            .replace(/\0/g, '\\0')
+            .replace(/\x07/g, '\\a')
+            .replace(/\x08/g, '\\b')
+            .replace(/\t/g, '\\t')
+            .replace(/\n/g, '\\n')
+            .replace(/\v/g, '\\v')
+            .replace(/\f/g, '\\f')
+            .replace(/\r/g, '\\r')
+            .replace(/\x1b/g, '\\e');
+        events.push(`=VAL${props} ${scalar}${value}`);
+    }
+}
+
+exports.testEvents = testEvents;

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/util.d.ts

@@ -0,0 +1,16 @@
+export { createNode } from './doc/createNode';
+export type { CreateNodeContext } from './doc/createNode';
+export { debug, warn } from './log';
+export type { LogLevelId } from './log';
+export { createPair } from './nodes/Pair';
+export { toJS } from './nodes/toJS';
+export type { ToJSContext } from './nodes/toJS';
+export { findPair } from './nodes/YAMLMap';
+export { map as mapTag } from './schema/common/map';
+export { seq as seqTag } from './schema/common/seq';
+export { string as stringTag } from './schema/common/string';
+export { foldFlowLines } from './stringify/foldFlowLines';
+export type { FoldOptions } from './stringify/foldFlowLines';
+export type { StringifyContext } from './stringify/stringify';
+export { stringifyNumber } from './stringify/stringifyNumber';
+export { stringifyString } from './stringify/stringifyString';

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/util.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var createNode = require('./doc/createNode.js');
+var log = require('./log.js');
+var Pair = require('./nodes/Pair.js');
+var toJS = require('./nodes/toJS.js');
+var YAMLMap = require('./nodes/YAMLMap.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');
+
+
+
+exports.createNode = createNode.createNode;
+exports.debug = log.debug;
+exports.warn = log.warn;
+exports.createPair = Pair.createPair;
+exports.toJS = toJS.toJS;
+exports.findPair = YAMLMap.findPair;
+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/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/dist/visit.d.ts

@@ -0,0 +1,102 @@
+import type { Document } from './doc/Document';
+import type { Alias } from './nodes/Alias';
+import type { Node } from './nodes/Node';
+import type { Pair } from './nodes/Pair';
+import type { Scalar } from './nodes/Scalar';
+import type { YAMLMap } from './nodes/YAMLMap';
+import type { YAMLSeq } from './nodes/YAMLSeq';
+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>;
+    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+    Pair?: visitorFn<Pair>;
+    Scalar?: visitorFn<Scalar>;
+    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.
+ *
+ * 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:
+ *   - `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 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;
+}