@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/cjs/query/matchers/str-matcher.js

@@ -1,109 +1,109 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StrNodeMatcher = exports.StrTplMatcher = exports.StrContentMatcher = void 0;
-const handler_1 = require("../handler");
-const regex_1 = require("../regex");
-const abstract_matcher_1 = require("./abstract-matcher");
-class StrContentMatcher extends abstract_matcher_1.AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.content = value !== null && value !== void 0 ? value : null;
-        this.handler = (0, handler_1.safeHandler)(handler);
-    }
-    match(checkpoint) {
-        let { cursor, context } = checkpoint;
-        const node = cursor.node;
-        if ((node === null || node === void 0 ? void 0 : node.type) === 'string-value') {
-            let isMatched = true;
-            if (typeof this.content === 'string') {
-                isMatched = this.content === node.value;
-            }
-            else if ((0, regex_1.isRegex)(this.content)) {
-                isMatched = this.content.test(node.value);
-            }
-            if (isMatched) {
-                context = this.handler(context, node);
-                cursor = this.moveRight(cursor);
-                return { cursor, context };
-            }
-        }
-        return null;
-    }
-}
-exports.StrContentMatcher = StrContentMatcher;
-class StrTplMatcher extends abstract_matcher_1.AbstractMatcher {
-    constructor(config) {
-        super();
-        this.matcher = config.matcher;
-        this.preHandler = (0, handler_1.safeHandler)(config.preHandler);
-        this.postHandler = (0, handler_1.safeHandler)(config.postHandler);
-    }
-    match(checkpoint) {
-        var _a;
-        const { cursor: tplCursor, context: tplContext } = checkpoint;
-        const rootNode = tplCursor.node;
-        if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'template-tree') {
-            let cursor = checkpoint.cursor.down;
-            if (cursor && cursor.node) {
-                let context = this.preHandler(tplContext, rootNode);
-                cursor = this.matcher.seekNext(cursor);
-                const match = this.matcher.match({ context, cursor });
-                if (match) {
-                    ({ cursor, context } = match);
-                    cursor = this.seekNext(cursor);
-                    if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_end') {
-                        context = this.postHandler(context, rootNode);
-                        cursor = this.moveRight(tplCursor);
-                        return { context, cursor };
-                    }
-                }
-            }
-        }
-        return null;
-    }
-}
-exports.StrTplMatcher = StrTplMatcher;
-class StrNodeMatcher extends abstract_matcher_1.AbstractMatcher {
-    constructor(opts) {
-        var _a;
-        super();
-        this.matchers = (_a = opts.matchers) !== null && _a !== void 0 ? _a : null;
-        this.preHandler = (0, handler_1.safeHandler)(opts.preHandler);
-        this.postHandler = (0, handler_1.safeHandler)(opts.postHandler);
-    }
-    match(checkpoint) {
-        var _a;
-        const rootCursor = this.seekNext(checkpoint.cursor);
-        const rootNode = rootCursor.node;
-        if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'string-tree') {
-            let context = this.preHandler(checkpoint.context, rootNode);
-            let cursor = rootCursor;
-            if (this.matchers) {
-                const tokensCount = cursor.children.length - 2;
-                if (tokensCount !== this.matchers.length) {
-                    return null;
-                }
-                if (tokensCount > 0) {
-                    cursor = this.moveRight(cursor.down);
-                    for (const matcher of this.matchers) {
-                        const match = matcher.match({ context, cursor });
-                        if (!match) {
-                            return null;
-                        }
-                        ({ cursor, context } = match);
-                    }
-                }
-            }
-            context = this.postHandler(context, rootNode);
-            cursor = this.moveRight(rootCursor);
-            return { context, cursor };
-        }
-        else if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'string-value' && ((_a = this.matchers) === null || _a === void 0 ? void 0 : _a.length)) {
-            const matcher = this.matchers[0];
-            return matcher.match({ context: checkpoint.context, cursor: rootCursor });
-        }
-        return null;
-    }
-}
-exports.StrNodeMatcher = StrNodeMatcher;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrNodeMatcher = exports.StrTplMatcher = exports.StrContentMatcher = void 0;
+const handler_1 = require("../handler");
+const regex_1 = require("../regex");
+const abstract_matcher_1 = require("./abstract-matcher");
+class StrContentMatcher extends abstract_matcher_1.AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.content = value !== null && value !== void 0 ? value : null;
+        this.handler = (0, handler_1.safeHandler)(handler);
+    }
+    match(checkpoint) {
+        let { cursor, context } = checkpoint;
+        const node = cursor.node;
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'string-value') {
+            let isMatched = true;
+            if (typeof this.content === 'string') {
+                isMatched = this.content === node.value;
+            }
+            else if ((0, regex_1.isRegex)(this.content)) {
+                isMatched = this.content.test(node.value);
+            }
+            if (isMatched) {
+                context = this.handler(context, node);
+                cursor = this.moveRight(cursor);
+                return { cursor, context };
+            }
+        }
+        return null;
+    }
+}
+exports.StrContentMatcher = StrContentMatcher;
+class StrTplMatcher extends abstract_matcher_1.AbstractMatcher {
+    constructor(config) {
+        super();
+        this.matcher = config.matcher;
+        this.preHandler = (0, handler_1.safeHandler)(config.preHandler);
+        this.postHandler = (0, handler_1.safeHandler)(config.postHandler);
+    }
+    match(checkpoint) {
+        var _a;
+        const { cursor: tplCursor, context: tplContext } = checkpoint;
+        const rootNode = tplCursor.node;
+        if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'template-tree') {
+            let cursor = checkpoint.cursor.down;
+            if (cursor && cursor.node) {
+                let context = this.preHandler(tplContext, rootNode);
+                cursor = this.matcher.seekNext(cursor);
+                const match = this.matcher.match({ context, cursor });
+                if (match) {
+                    ({ cursor, context } = match);
+                    cursor = this.seekNext(cursor);
+                    if (((_a = cursor.node) === null || _a === void 0 ? void 0 : _a.type) === '_end') {
+                        context = this.postHandler(context, rootNode);
+                        cursor = this.moveRight(tplCursor);
+                        return { context, cursor };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.StrTplMatcher = StrTplMatcher;
+class StrNodeMatcher extends abstract_matcher_1.AbstractMatcher {
+    constructor(opts) {
+        var _a;
+        super();
+        this.matchers = (_a = opts.matchers) !== null && _a !== void 0 ? _a : null;
+        this.preHandler = (0, handler_1.safeHandler)(opts.preHandler);
+        this.postHandler = (0, handler_1.safeHandler)(opts.postHandler);
+    }
+    match(checkpoint) {
+        var _a;
+        const rootCursor = this.seekNext(checkpoint.cursor);
+        const rootNode = rootCursor.node;
+        if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'string-tree') {
+            let context = this.preHandler(checkpoint.context, rootNode);
+            let cursor = rootCursor;
+            if (this.matchers) {
+                const tokensCount = cursor.children.length - 2;
+                if (tokensCount !== this.matchers.length) {
+                    return null;
+                }
+                if (tokensCount > 0) {
+                    cursor = this.moveRight(cursor.down);
+                    for (const matcher of this.matchers) {
+                        const match = matcher.match({ context, cursor });
+                        if (!match) {
+                            return null;
+                        }
+                        ({ cursor, context } = match);
+                    }
+                }
+            }
+            context = this.postHandler(context, rootNode);
+            cursor = this.moveRight(rootCursor);
+            return { context, cursor };
+        }
+        else if ((rootNode === null || rootNode === void 0 ? void 0 : rootNode.type) === 'string-value' && ((_a = this.matchers) === null || _a === void 0 ? void 0 : _a.length)) {
+            const matcher = this.matchers[0];
+            return matcher.match({ context: checkpoint.context, cursor: rootCursor });
+        }
+        return null;
+    }
+}
+exports.StrNodeMatcher = StrNodeMatcher;
 //# sourceMappingURL=str-matcher.js.map

package/dist/cjs/query/matchers/sym-matcher.d.ts

@@ -1,9 +1,9 @@
-import type { Checkpoint, SymMatcherHandler, SymMatcherOptions, SymMatcherValue } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class SymMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly sym: SymMatcherValue;
-    readonly handler: SymMatcherHandler<Ctx>;
-    constructor({ value, handler }: SymMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
+import type { Checkpoint, SymMatcherHandler, SymMatcherOptions, SymMatcherValue } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class SymMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly sym: SymMatcherValue;
+    readonly handler: SymMatcherHandler<Ctx>;
+    constructor({ value, handler }: SymMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=sym-matcher.d.ts.map

package/dist/cjs/query/matchers/sym-matcher.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymMatcher = void 0;
-const handler_1 = require("../handler");
-const regex_1 = require("../regex");
-const abstract_matcher_1 = require("./abstract-matcher");
-class SymMatcher extends abstract_matcher_1.AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.sym = value;
-        this.handler = (0, handler_1.safeHandler)(handler);
-    }
-    match(checkpoint) {
-        let context = checkpoint.context;
-        let cursor = this.seekNext(checkpoint.cursor);
-        const node = cursor.node;
-        if ((node === null || node === void 0 ? void 0 : node.type) === 'symbol') {
-            let isMatched = true;
-            if (typeof this.sym === 'string') {
-                isMatched = this.sym === node.value;
-            }
-            else if ((0, regex_1.isRegex)(this.sym)) {
-                isMatched = this.sym.test(node.value);
-            }
-            if (isMatched) {
-                context = this.handler(context, node);
-                cursor = this.moveRight(cursor);
-                return { cursor, context };
-            }
-        }
-        return null;
-    }
-}
-exports.SymMatcher = SymMatcher;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymMatcher = void 0;
+const handler_1 = require("../handler");
+const regex_1 = require("../regex");
+const abstract_matcher_1 = require("./abstract-matcher");
+class SymMatcher extends abstract_matcher_1.AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.sym = value;
+        this.handler = (0, handler_1.safeHandler)(handler);
+    }
+    match(checkpoint) {
+        let context = checkpoint.context;
+        let cursor = this.seekNext(checkpoint.cursor);
+        const node = cursor.node;
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'symbol') {
+            let isMatched = true;
+            if (typeof this.sym === 'string') {
+                isMatched = this.sym === node.value;
+            }
+            else if ((0, regex_1.isRegex)(this.sym)) {
+                isMatched = this.sym.test(node.value);
+            }
+            if (isMatched) {
+                context = this.handler(context, node);
+                cursor = this.moveRight(cursor);
+                return { cursor, context };
+            }
+        }
+        return null;
+    }
+}
+exports.SymMatcher = SymMatcher;
 //# sourceMappingURL=sym-matcher.js.map

package/dist/cjs/query/matchers/tree-matcher.d.ts

@@ -1,24 +1,24 @@
-import type { Cursor } from '../../parser/types';
-import type { Checkpoint, Matcher, TreeMatcherHandler, TreeMatcherType, TreeOptionsBase } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-interface TreeMatcherOptions<Ctx> extends TreeOptionsBase<Ctx> {
-    matcher: Matcher<Ctx> | null;
-}
-export declare class TreeMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly type: TreeMatcherType | null;
-    readonly startsWithValue: string | null;
-    readonly endsWithValue: string | null;
-    readonly matcher: Matcher<Ctx> | null;
-    readonly maxDepth: number;
-    readonly maxMatches: number;
-    readonly preHandler: TreeMatcherHandler<Ctx>;
-    readonly postHandler: TreeMatcherHandler<Ctx>;
-    private walkDepth;
-    private matchCount;
-    constructor(config: TreeMatcherOptions<Ctx>);
-    walkToNextSignificantNode(cursor: Cursor): Cursor | undefined;
-    walkToNextMatch(context: Ctx, cursor: Cursor | undefined): Checkpoint<Ctx> | undefined;
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-export {};
+import type { Cursor } from '../../parser/types';
+import type { Checkpoint, Matcher, TreeMatcherHandler, TreeMatcherType, TreeOptionsBase } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+interface TreeMatcherOptions<Ctx> extends TreeOptionsBase<Ctx> {
+    matcher: Matcher<Ctx> | null;
+}
+export declare class TreeMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly type: TreeMatcherType | null;
+    readonly startsWithValue: string | null;
+    readonly endsWithValue: string | null;
+    readonly matcher: Matcher<Ctx> | null;
+    readonly maxDepth: number;
+    readonly maxMatches: number;
+    readonly preHandler: TreeMatcherHandler<Ctx>;
+    readonly postHandler: TreeMatcherHandler<Ctx>;
+    private walkDepth;
+    private matchCount;
+    constructor(config: TreeMatcherOptions<Ctx>);
+    walkToNextSignificantNode(cursor: Cursor): Cursor | undefined;
+    walkToNextMatch(context: Ctx, cursor: Cursor | undefined): Checkpoint<Ctx> | undefined;
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+export {};
 //# sourceMappingURL=tree-matcher.d.ts.map

package/dist/cjs/query/matchers/tree-matcher.js

@@ -1,122 +1,122 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMatcher = void 0;
-const parser_1 = require("../../parser");
-const handler_1 = require("../handler");
-const abstract_matcher_1 = require("./abstract-matcher");
-class TreeMatcher extends abstract_matcher_1.AbstractMatcher {
-    constructor(config) {
-        var _a, _b, _c;
-        super();
-        this.walkDepth = 0;
-        this.matchCount = 0;
-        this.type = (_a = config.type) !== null && _a !== void 0 ? _a : null;
-        this.startsWithValue = (_b = config.startsWith) !== null && _b !== void 0 ? _b : null;
-        this.endsWithValue = (_c = config.endsWith) !== null && _c !== void 0 ? _c : null;
-        this.matcher = config.matcher;
-        this.maxDepth =
-            typeof config.maxDepth === 'number' && config.maxDepth > 0
-                ? config.maxDepth
-                : 1024;
-        this.maxMatches =
-            typeof config.maxMatches === 'number' && config.maxMatches > 0
-                ? config.maxMatches
-                : 1024 * 1024;
-        this.preHandler = (0, handler_1.safeHandler)(config.preHandler);
-        this.postHandler = (0, handler_1.safeHandler)(config.postHandler);
-    }
-    walkToNextSignificantNode(cursor) {
-        const downCursor = cursor.down;
-        if (downCursor && this.walkDepth < this.maxDepth) {
-            this.walkDepth += 1;
-            return downCursor;
-        }
-        let rightCursor = cursor.right;
-        if (rightCursor) {
-            rightCursor = this.matcher
-                ? this.matcher.seekNext(rightCursor)
-                : this.seekNext(rightCursor);
-            if (rightCursor) {
-                return rightCursor;
-            }
-        }
-        const canMoveUp = this.walkDepth > 1;
-        let upperCursor = canMoveUp ? cursor.up : undefined;
-        while (upperCursor && canMoveUp) {
-            rightCursor = upperCursor.right;
-            if (rightCursor) {
-                rightCursor = this.matcher
-                    ? this.matcher.seekNext(rightCursor)
-                    : this.seekNext(rightCursor);
-                if (rightCursor) {
-                    upperCursor = rightCursor;
-                    break;
-                }
-            }
-            upperCursor = upperCursor.up;
-        }
-        if (upperCursor) {
-            this.walkDepth -= 1;
-            return upperCursor;
-        }
-        return undefined;
-    }
-    walkToNextMatch(context, cursor) {
-        if (!cursor || !this.matcher) {
-            return undefined;
-        }
-        let nextCursor = this.walkToNextSignificantNode(cursor);
-        while (nextCursor) {
-            const match = this.matcher.match({ cursor: nextCursor, context });
-            if (match) {
-                this.matchCount += 1;
-                return match;
-            }
-            nextCursor = this.walkToNextSignificantNode(nextCursor);
-        }
-        return undefined;
-    }
-    match(checkpoint) {
-        this.walkDepth = 0;
-        this.matchCount = 0;
-        const rootCursor = this.seekNext(checkpoint.cursor);
-        const rootNode = rootCursor.node;
-        if ((0, parser_1.isTree)(rootNode)) {
-            if (this.type && this.type !== rootNode.type) {
-                return null;
-            }
-            if (this.type === 'wrapped-tree') {
-                const currentTree = rootNode;
-                if (this.startsWithValue &&
-                    currentTree.startsWith.value !== this.startsWithValue) {
-                    return null;
-                }
-                if (this.endsWithValue &&
-                    currentTree.endsWith.value !== this.endsWithValue) {
-                    return null;
-                }
-            }
-            let context = checkpoint.context;
-            context = this.preHandler(context, rootNode);
-            if (this.matcher) {
-                let nextMatch = this.walkToNextMatch(context, rootCursor);
-                while (nextMatch) {
-                    context = nextMatch.context;
-                    if (this.matchCount === this.maxMatches) {
-                        break;
-                    }
-                    nextMatch = this.walkToNextMatch(context, nextMatch.cursor);
-                }
-                if (this.matchCount === 0) {
-                    return null;
-                }
-            }
-            context = this.postHandler(context, rootNode);
-            const cursor = rootNode.type === 'root-tree' ? rootCursor : this.moveRight(rootCursor);
-            return { context, cursor };
-        }
-        return null;
-    }
-}
-exports.TreeMatcher = TreeMatcher;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMatcher = void 0;
+const parser_1 = require("../../parser");
+const handler_1 = require("../handler");
+const abstract_matcher_1 = require("./abstract-matcher");
+class TreeMatcher extends abstract_matcher_1.AbstractMatcher {
+    constructor(config) {
+        var _a, _b, _c;
+        super();
+        this.walkDepth = 0;
+        this.matchCount = 0;
+        this.type = (_a = config.type) !== null && _a !== void 0 ? _a : null;
+        this.startsWithValue = (_b = config.startsWith) !== null && _b !== void 0 ? _b : null;
+        this.endsWithValue = (_c = config.endsWith) !== null && _c !== void 0 ? _c : null;
+        this.matcher = config.matcher;
+        this.maxDepth =
+            typeof config.maxDepth === 'number' && config.maxDepth > 0
+                ? config.maxDepth
+                : 1024;
+        this.maxMatches =
+            typeof config.maxMatches === 'number' && config.maxMatches > 0
+                ? config.maxMatches
+                : 1024 * 1024;
+        this.preHandler = (0, handler_1.safeHandler)(config.preHandler);
+        this.postHandler = (0, handler_1.safeHandler)(config.postHandler);
+    }
+    walkToNextSignificantNode(cursor) {
+        const downCursor = cursor.down;
+        if (downCursor && this.walkDepth < this.maxDepth) {
+            this.walkDepth += 1;
+            return downCursor;
+        }
+        let rightCursor = cursor.right;
+        if (rightCursor) {
+            rightCursor = this.matcher
+                ? this.matcher.seekNext(rightCursor)
+                : this.seekNext(rightCursor);
+            if (rightCursor) {
+                return rightCursor;
+            }
+        }
+        const canMoveUp = this.walkDepth > 1;
+        let upperCursor = canMoveUp ? cursor.up : undefined;
+        while (upperCursor && canMoveUp) {
+            rightCursor = upperCursor.right;
+            if (rightCursor) {
+                rightCursor = this.matcher
+                    ? this.matcher.seekNext(rightCursor)
+                    : this.seekNext(rightCursor);
+                if (rightCursor) {
+                    upperCursor = rightCursor;
+                    break;
+                }
+            }
+            upperCursor = upperCursor.up;
+        }
+        if (upperCursor) {
+            this.walkDepth -= 1;
+            return upperCursor;
+        }
+        return undefined;
+    }
+    walkToNextMatch(context, cursor) {
+        if (!cursor || !this.matcher) {
+            return undefined;
+        }
+        let nextCursor = this.walkToNextSignificantNode(cursor);
+        while (nextCursor) {
+            const match = this.matcher.match({ cursor: nextCursor, context });
+            if (match) {
+                this.matchCount += 1;
+                return match;
+            }
+            nextCursor = this.walkToNextSignificantNode(nextCursor);
+        }
+        return undefined;
+    }
+    match(checkpoint) {
+        this.walkDepth = 0;
+        this.matchCount = 0;
+        const rootCursor = this.seekNext(checkpoint.cursor);
+        const rootNode = rootCursor.node;
+        if ((0, parser_1.isTree)(rootNode)) {
+            if (this.type && this.type !== rootNode.type) {
+                return null;
+            }
+            if (this.type === 'wrapped-tree') {
+                const currentTree = rootNode;
+                if (this.startsWithValue &&
+                    currentTree.startsWith.value !== this.startsWithValue) {
+                    return null;
+                }
+                if (this.endsWithValue &&
+                    currentTree.endsWith.value !== this.endsWithValue) {
+                    return null;
+                }
+            }
+            let context = checkpoint.context;
+            context = this.preHandler(context, rootNode);
+            if (this.matcher) {
+                let nextMatch = this.walkToNextMatch(context, rootCursor);
+                while (nextMatch) {
+                    context = nextMatch.context;
+                    if (this.matchCount === this.maxMatches) {
+                        break;
+                    }
+                    nextMatch = this.walkToNextMatch(context, nextMatch.cursor);
+                }
+                if (this.matchCount === 0) {
+                    return null;
+                }
+            }
+            context = this.postHandler(context, rootNode);
+            const cursor = rootNode.type === 'root-tree' ? rootCursor : this.moveRight(rootCursor);
+            return { context, cursor };
+        }
+        return null;
+    }
+}
+exports.TreeMatcher = TreeMatcher;
 //# sourceMappingURL=tree-matcher.js.map

package/dist/cjs/query/options.d.ts

@@ -1,11 +1,11 @@
-import type { Node, TreeType } from '../parser/types';
-import type { StrContentMatcherHandler } from './matchers/str-matcher';
-import type { CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue, ManyBuilderOpts, NumMatcherHandler, NumMatcherOptions, NumMatcherValue, OpMatcherHandler, OpMatcherOptions, OpMatcherValue, QueryBuilder, StrBuilderOptions, StrBuilderOptionsBase, SymMatcherHandler, SymMatcherOptions, SymMatcherValue, TreeBuilderOptions } from './types';
-export declare function coerceSymOptions<Ctx>(arg1?: SymMatcherValue | SymMatcherOptions<Ctx> | SymMatcherHandler<Ctx>, arg2?: SymMatcherHandler<Ctx>): SymMatcherOptions<Ctx>;
-export declare function coerceOpOptions<Ctx>(arg1?: OpMatcherValue | OpMatcherOptions<Ctx> | OpMatcherHandler<Ctx>, arg2?: OpMatcherHandler<Ctx>): OpMatcherOptions<Ctx>;
-export declare function coerceCommentOptions<Ctx>(arg1?: CommentMatcherValue | CommentMatcherOptions<Ctx> | CommentMatcherHandler<Ctx>, arg2?: CommentMatcherHandler<Ctx>): CommentMatcherOptions<Ctx>;
-export declare function coerceNumOptions<Ctx>(arg1?: NumMatcherValue | NumMatcherOptions<Ctx> | NumMatcherHandler<Ctx>, arg2?: NumMatcherHandler<Ctx>): NumMatcherOptions<Ctx>;
-export declare function coerceManyOptions<Ctx>(builder: QueryBuilder<Ctx, Node>, arg2?: number, arg3?: number): ManyBuilderOpts<Ctx>;
-export declare function coerceTreeOptions<Ctx>(arg1: TreeBuilderOptions<Ctx> | TreeType | undefined): TreeBuilderOptions<Ctx>;
-export declare function coerceStrOptions<Ctx>(arg1: string | RegExp | StrContentMatcherHandler<Ctx> | StrBuilderOptionsBase<Ctx> | undefined, arg2: StrContentMatcherHandler<Ctx> | undefined): StrBuilderOptions<Ctx>;
+import type { Node, TreeType } from '../parser/types';
+import type { StrContentMatcherHandler } from './matchers/str-matcher';
+import type { CommentMatcherHandler, CommentMatcherOptions, CommentMatcherValue, ManyBuilderOpts, NumMatcherHandler, NumMatcherOptions, NumMatcherValue, OpMatcherHandler, OpMatcherOptions, OpMatcherValue, QueryBuilder, StrBuilderOptions, StrBuilderOptionsBase, SymMatcherHandler, SymMatcherOptions, SymMatcherValue, TreeBuilderOptions } from './types';
+export declare function coerceSymOptions<Ctx>(arg1?: SymMatcherValue | SymMatcherOptions<Ctx> | SymMatcherHandler<Ctx>, arg2?: SymMatcherHandler<Ctx>): SymMatcherOptions<Ctx>;
+export declare function coerceOpOptions<Ctx>(arg1?: OpMatcherValue | OpMatcherOptions<Ctx> | OpMatcherHandler<Ctx>, arg2?: OpMatcherHandler<Ctx>): OpMatcherOptions<Ctx>;
+export declare function coerceCommentOptions<Ctx>(arg1?: CommentMatcherValue | CommentMatcherOptions<Ctx> | CommentMatcherHandler<Ctx>, arg2?: CommentMatcherHandler<Ctx>): CommentMatcherOptions<Ctx>;
+export declare function coerceNumOptions<Ctx>(arg1?: NumMatcherValue | NumMatcherOptions<Ctx> | NumMatcherHandler<Ctx>, arg2?: NumMatcherHandler<Ctx>): NumMatcherOptions<Ctx>;
+export declare function coerceManyOptions<Ctx>(builder: QueryBuilder<Ctx, Node>, arg2?: number, arg3?: number): ManyBuilderOpts<Ctx>;
+export declare function coerceTreeOptions<Ctx>(arg1: TreeBuilderOptions<Ctx> | TreeType | undefined): TreeBuilderOptions<Ctx>;
+export declare function coerceStrOptions<Ctx>(arg1: string | RegExp | StrContentMatcherHandler<Ctx> | StrBuilderOptionsBase<Ctx> | undefined, arg2: StrContentMatcherHandler<Ctx> | undefined): StrBuilderOptions<Ctx>;
 //# sourceMappingURL=options.d.ts.map