projen 0.53.8 → 0.53.11

package/node_modules/yaml/browser/dist/parse/parser.js

@@ -541,36 +541,70 @@ class Parser {
                     this.onKeyLine = true;
                     return;
                 case 'map-value-ind':
-                    if (!it.sep)
-                        Object.assign(it, { key: null, sep: [this.sourceToken] });
-                    else if (it.value ||
-                        (atNextItem && !includesToken(it.start, 'explicit-key-ind')))
-                        map.items.push({ start: [], key: null, sep: [this.sourceToken] });
-                    else if (includesToken(it.sep, 'map-value-ind'))
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start: [], key: null, sep: [this.sourceToken] }]
-                        });
-                    else if (includesToken(it.start, 'explicit-key-ind') &&
-                        isFlowToken(it.key) &&
-                        !includesToken(it.sep, 'newline')) {
-                        const start = getFirstKeyStartProps(it.start);
-                        const key = it.key;
-                        const sep = it.sep;
-                        sep.push(this.sourceToken);
-                        // @ts-ignore type guard is wrong here
-                        delete it.key, delete it.sep;
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start, key, sep }]
-                        });
+                    if (includesToken(it.start, 'explicit-key-ind')) {
+                        if (!it.sep) {
+                            if (includesToken(it.start, 'newline')) {
+                                Object.assign(it, { key: null, sep: [this.sourceToken] });
+                            }
+                            else {
+                                const start = getFirstKeyStartProps(it.start);
+                                this.stack.push({
+                                    type: 'block-map',
+                                    offset: this.offset,
+                                    indent: this.indent,
+                                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                                });
+                            }
+                        }
+                        else if (it.value) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else if (isFlowToken(it.key) &&
+                            !includesToken(it.sep, 'newline')) {
+                            const start = getFirstKeyStartProps(it.start);
+                            const key = it.key;
+                            const sep = it.sep;
+                            sep.push(this.sourceToken);
+                            // @ts-expect-error type guard is wrong here
+                            delete it.key, delete it.sep;
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key, sep }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    else {
+                        if (!it.sep) {
+                            Object.assign(it, { key: null, sep: [this.sourceToken] });
+                        }
+                        else if (it.value || atNextItem) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
                     }
-                    else
-                        it.sep.push(this.sourceToken);
                     this.onKeyLine = true;
                     return;
                 case 'alias':
@@ -734,7 +768,7 @@ class Parser {
         else {
             const parent = this.peek(2);
             if (parent.type === 'block-map' &&
-                (this.type === 'map-value-ind' ||
+                ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
                     (this.type === 'newline' &&
                         !parent.items[parent.items.length - 1].sep))) {
                 yield* this.pop();

package/node_modules/yaml/browser/dist/schema/common/null.js

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

package/node_modules/yaml/browser/dist/stringify/stringifyDocument.js

@@ -3,6 +3,7 @@ import { createStringifyContext, stringify } from './stringify.js';
 import { indentComment, lineComment } from './stringifyComment.js';
 
 function stringifyDocument(doc, options) {
+    var _a;
     const lines = [];
     let hasDirectives = options.directives === true;
     if (options.directives !== false && doc.directives) {
@@ -11,7 +12,7 @@ function stringifyDocument(doc, options) {
             lines.push(dir);
             hasDirectives = true;
         }
-        else if (doc.directives.marker)
+        else if (doc.directives.docStart)
             hasDirectives = true;
     }
     if (hasDirectives)
@@ -54,13 +55,30 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(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(indentComment(commentString(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(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(indentComment(commentString(dc), ''));
+        }
     }
     return lines.join('\n') + '\n';
 }

package/node_modules/yaml/browser/dist/stringify/stringifyPair.js

@@ -39,7 +39,7 @@ 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)) {

package/node_modules/yaml/browser/dist/visit.js

@@ -1,4 +1,4 @@
-import { isDocument, isMap, isSeq, isPair, isScalar, isAlias, isNode, isCollection } from './nodes/Node.js';
+import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/Node.js';
 
 const BREAK = Symbol('break visit');
 const SKIP = Symbol('skip children');
@@ -34,29 +34,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 (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
@@ -67,55 +52,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 (isMap(node)) {
-        if (visitor.Map)
-            ctrl = visitor.Map(key, node, path);
-    }
-    else if (isSeq(node)) {
-        if (visitor.Seq)
-            ctrl = visitor.Seq(key, node, path);
-    }
-    else if (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 (isNode(ctrl) || isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visit_(key, ctrl, visitor, path);
     }
-    else if (isScalar(node)) {
-        if (visitor.Scalar)
-            ctrl = visitor.Scalar(key, node, path);
+    if (typeof ctrl !== 'symbol') {
+        if (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 (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 (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 (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 (isNode(ctrl) || isPair(ctrl)) {
-        const parent = path[path.length - 1];
-        if (isCollection(parent)) {
-            parent.items[key] = ctrl;
-        }
-        else if (isPair(parent)) {
-            if (key === 'key')
-                parent.key = ctrl;
-            else
-                parent.value = ctrl;
-        }
-        else if (isDocument(parent)) {
-            parent.contents = ctrl;
-        }
-        else {
-            const pt = 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 (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)
@@ -128,12 +162,12 @@ function _visit(key, node, visitor, path) {
         }
         else if (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)
@@ -142,5 +176,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) {
+    var _a, _b, _c, _d, _e;
+    if (typeof visitor === 'function')
+        return visitor(key, node, path);
+    if (isMap(node))
+        return (_a = visitor.Map) === null || _a === void 0 ? void 0 : _a.call(visitor, key, node, path);
+    if (isSeq(node))
+        return (_b = visitor.Seq) === null || _b === void 0 ? void 0 : _b.call(visitor, key, node, path);
+    if (isPair(node))
+        return (_c = visitor.Pair) === null || _c === void 0 ? void 0 : _c.call(visitor, key, node, path);
+    if (isScalar(node))
+        return (_d = visitor.Scalar) === null || _d === void 0 ? void 0 : _d.call(visitor, key, node, path);
+    if (isAlias(node))
+        return (_e = visitor.Alias) === null || _e === void 0 ? void 0 : _e.call(visitor, key, node, path);
+    return undefined;
+}
+function replaceNode(key, path, node) {
+    const parent = path[path.length - 1];
+    if (isCollection(parent)) {
+        parent.items[key] = node;
+    }
+    else if (isPair(parent)) {
+        if (key === 'key')
+            parent.key = node;
+        else
+            parent.value = node;
+    }
+    else if (isDocument(parent)) {
+        parent.contents = node;
+    }
+    else {
+        const pt = isAlias(parent) ? 'alias' : 'scalar';
+        throw new Error(`Cannot replace node with ${pt} parent`);
+    }
+}
 
-export { visit };
+export { visit, visitAsync };

package/node_modules/yaml/dist/compose/compose-doc.js

@@ -22,7 +22,7 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
         startOnNewline: true
     });
     if (props.found) {
-        doc.directives.marker = true;
+        doc.directives.docStart = true;
         if (value &&
             (value.type === 'block-map' || value.type === 'block-seq') &&
             !props.hasNewline)

package/node_modules/yaml/dist/compose/compose-node.js

@@ -10,6 +10,7 @@ const CN = { composeNode, composeEmptyNode };
 function composeNode(ctx, token, props, onError) {
     const { spaceBefore, comment, anchor, tag } = props;
     let node;
+    let isSrcToken = true;
     switch (token.type) {
         case 'alias':
             node = composeAlias(ctx, token, onError);
@@ -31,9 +32,14 @@ function composeNode(ctx, token, props, onError) {
             if (anchor)
                 node.anchor = anchor.source.substring(1);
             break;
-        default:
-            console.log(token);
-            throw new Error(`Unsupporten token type: ${token.type}`);
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
+            isSrcToken = false;
+        }
     }
     if (anchor && node.anchor === '')
         onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
@@ -45,7 +51,8 @@ function composeNode(ctx, token, props, onError) {
         else
             node.commentBefore = comment;
     }
-    if (ctx.options.keepSourceTokens)
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
         node.srcToken = token;
     return node;
 }
@@ -72,6 +79,8 @@ function composeAlias({ options }, { offset, source, end }, onError) {
     const alias = new Alias.Alias(source.substring(1));
     if (alias.source === '')
         onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
     const valueEnd = offset + source.length;
     const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];

package/node_modules/yaml/dist/compose/composer.d.ts

@@ -2,7 +2,7 @@ import { Directives } from '../doc/directives.js';
 import { Document } from '../doc/Document.js';
 import { ErrorCode, YAMLParseError, YAMLWarning } from '../errors.js';
 import { Range } from '../nodes/Node.js';
-import { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
 import type { Token } from '../parse/cst.js';
 declare type ErrorSource = number | [number, number] | Range | {
     offset: number;

package/node_modules/yaml/dist/compose/composer.js

@@ -4,7 +4,6 @@ var directives = require('../doc/directives.js');
 var Document = require('../doc/Document.js');
 var errors = require('../errors.js');
 var Node = require('../nodes/Node.js');
-var options = require('../options.js');
 var composeDoc = require('./compose-doc.js');
 var resolveEnd = require('./resolve-end.js');
 
@@ -57,7 +56,7 @@ function parsePrelude(prelude) {
  * ```
  */
 class Composer {
-    constructor(options$1 = {}) {
+    constructor(options = {}) {
         this.doc = null;
         this.atDirectives = false;
         this.prelude = [];
@@ -70,10 +69,8 @@ class Composer {
             else
                 this.errors.push(new errors.YAMLParseError(pos, code, message));
         };
-        this.directives = new directives.Directives({
-            version: options$1.version || options.defaultOptions.version
-        });
-        this.options = options$1;
+        this.directives = new directives.Directives({ version: options.version || '1.2' });
+        this.options = options;
     }
     decorate(doc, afterDoc) {
         const { comment, afterEmptyLine } = parsePrelude(this.prelude);
@@ -83,7 +80,7 @@ class Composer {
             if (afterDoc) {
                 doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment;
             }
-            else if (afterEmptyLine || doc.directives.marker || !dc) {
+            else if (afterEmptyLine || doc.directives.docStart || !dc) {
                 doc.commentBefore = comment;
             }
             else if (Node.isCollection(dc) && !dc.flow && dc.items.length > 0) {
@@ -150,8 +147,8 @@ class Composer {
                 break;
             case 'document': {
                 const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError);
-                if (this.atDirectives && !doc.directives.marker)
-                    this.onError(token, 'MISSING_CHAR', 'Missing directives-end indicator line');
+                if (this.atDirectives && !doc.directives.docStart)
+                    this.onError(token, 'MISSING_CHAR', 'Missing directives-end/doc-start indicator line');
                 this.decorate(doc, false);
                 if (this.doc)
                     yield this.doc;
@@ -183,6 +180,7 @@ class Composer {
                     this.errors.push(new errors.YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
                     break;
                 }
+                this.doc.directives.docEnd = true;
                 const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
                 this.decorate(this.doc, true);
                 if (end.comment) {

package/node_modules/yaml/dist/compose/resolve-block-scalar.js

@@ -19,8 +19,10 @@ function resolveBlockScalar(scalar, strict, onError) {
             break;
     }
     // shortcut for empty contents
-    if (!scalar.source || chompStart === 0) {
-        const value = header.chomp === '+' ? '\n'.repeat(Math.max(0, lines.length - 1)) : '';
+    if (chompStart === 0) {
+        const value = header.chomp === '+' && lines.length > 0
+            ? '\n'.repeat(Math.max(1, lines.length - 1))
+            : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -48,6 +50,11 @@ function resolveBlockScalar(scalar, strict, onError) {
         }
         offset += indent.length + content.length + 1;
     }
+    // include trailing more-indented empty lines in content
+    for (let i = lines.length - 1; i >= chompStart; --i) {
+        if (lines[i][0].length > trimIndent)
+            chompStart = i + 1;
+    }
     let value = '';
     let sep = '';
     let prevMoreIndented = false;

package/node_modules/yaml/dist/compose/resolve-props.js

@@ -61,6 +61,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
             case 'anchor':
                 if (anchor)
                     onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor');
+                if (token.source.endsWith(':'))
+                    onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
                 anchor = token;
                 if (start === null)
                     start = token.offset;

package/node_modules/yaml/dist/doc/Document.d.ts

@@ -5,7 +5,7 @@ import { 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';
-import { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
 import { Schema } from '../schema/Schema.js';
 import { Directives } from './directives.js';
 export declare type Replacer = any[] | ((key: any, value: any) => unknown);