@renovatebot/good-enough-parser 1.1.24 → 1.2.0

package/dist/esm/query/matchers/op-matcher.js

@@ -1,31 +1,31 @@
-import { safeHandler } from '../handler';
-import { isRegex } from '../regex';
-import { AbstractMatcher } from './abstract-matcher';
-export class OpMatcher extends AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.op = value;
-        this.handler = 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) === 'operator') {
-            let isMatched = true;
-            if (typeof this.op === 'string') {
-                isMatched = this.op === node.value;
-            }
-            else if (isRegex(this.op)) {
-                isMatched = this.op.test(node.value);
-            }
-            if (isMatched) {
-                context = this.handler(context, node);
-                cursor = this.moveRight(cursor);
-                return { cursor, context };
-            }
-        }
-        return null;
-    }
-}
+import { safeHandler } from '../handler';
+import { isRegex } from '../regex';
+import { AbstractMatcher } from './abstract-matcher';
+export class OpMatcher extends AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.op = value;
+        this.handler = 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) === 'operator') {
+            let isMatched = true;
+            if (typeof this.op === 'string') {
+                isMatched = this.op === node.value;
+            }
+            else if (isRegex(this.op)) {
+                isMatched = this.op.test(node.value);
+            }
+            if (isMatched) {
+                context = this.handler(context, node);
+                cursor = this.moveRight(cursor);
+                return { cursor, context };
+            }
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=op-matcher.js.map

package/dist/esm/query/matchers/seq-matcher.d.ts

@@ -1,15 +1,15 @@
-import type { Checkpoint, Matcher, SeqMatcherOptions } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export declare class SeqMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly seq: Matcher<Ctx>[];
-    readonly length: number;
-    private checkpoint;
-    private idx;
-    constructor({ matchers }: SeqMatcherOptions<Ctx>);
-    private isMatchingComplete;
-    private matchForward;
-    private backtrack;
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-    nextMatch(): Checkpoint<Ctx> | null;
-}
+import type { Checkpoint, Matcher, SeqMatcherOptions } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export declare class SeqMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly seq: Matcher<Ctx>[];
+    readonly length: number;
+    private checkpoint;
+    private idx;
+    constructor({ matchers }: SeqMatcherOptions<Ctx>);
+    private isMatchingComplete;
+    private matchForward;
+    private backtrack;
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+    nextMatch(): Checkpoint<Ctx> | null;
+}
 //# sourceMappingURL=seq-matcher.d.ts.map

package/dist/esm/query/matchers/seq-matcher.js

@@ -1,73 +1,73 @@
-import { AbstractMatcher } from './abstract-matcher';
-export class SeqMatcher extends AbstractMatcher {
-    constructor({ matchers }) {
-        super();
-        this.checkpoint = null;
-        this.idx = 0;
-        this.seq = matchers;
-        this.length = this.seq.length;
-    }
-    isMatchingComplete() {
-        return this.idx === this.length;
-    }
-    matchForward() {
-        if (this.checkpoint) {
-            while (this.idx < this.length) {
-                const matcher = this.seq[this.idx];
-                const checkpoint = matcher.match(this.checkpoint);
-                if (!checkpoint) {
-                    break;
-                }
-                this.checkpoint = checkpoint;
-                this.idx += 1;
-            }
-            if (this.isMatchingComplete()) {
-                return this.checkpoint;
-            }
-        }
-        return null;
-    }
-    backtrack() {
-        while (this.idx > 0) {
-            this.idx -= 1;
-            const matcher = this.seq[this.idx];
-            const match = matcher.nextMatch();
-            if (match) {
-                this.checkpoint = match;
-                this.idx += 1;
-                return match;
-            }
-        }
-        return null;
-    }
-    match(checkpoint) {
-        this.idx = 0;
-        this.checkpoint = checkpoint;
-        while (!this.isMatchingComplete()) {
-            const forwardMatch = this.matchForward();
-            if (!forwardMatch) {
-                const backwardMatch = this.backtrack();
-                if (!backwardMatch) {
-                    return null;
-                }
-            }
-        }
-        return this.checkpoint;
-    }
-    nextMatch() {
-        if (!this.backtrack()) {
-            return null;
-        }
-        while (!this.isMatchingComplete()) {
-            const forwardMatch = this.matchForward();
-            if (!forwardMatch) {
-                const backwardMatch = this.backtrack();
-                if (!backwardMatch) {
-                    return null;
-                }
-            }
-        }
-        return this.checkpoint;
-    }
-}
+import { AbstractMatcher } from './abstract-matcher';
+export class SeqMatcher extends AbstractMatcher {
+    constructor({ matchers }) {
+        super();
+        this.checkpoint = null;
+        this.idx = 0;
+        this.seq = matchers;
+        this.length = this.seq.length;
+    }
+    isMatchingComplete() {
+        return this.idx === this.length;
+    }
+    matchForward() {
+        if (this.checkpoint) {
+            while (this.idx < this.length) {
+                const matcher = this.seq[this.idx];
+                const checkpoint = matcher.match(this.checkpoint);
+                if (!checkpoint) {
+                    break;
+                }
+                this.checkpoint = checkpoint;
+                this.idx += 1;
+            }
+            if (this.isMatchingComplete()) {
+                return this.checkpoint;
+            }
+        }
+        return null;
+    }
+    backtrack() {
+        while (this.idx > 0) {
+            this.idx -= 1;
+            const matcher = this.seq[this.idx];
+            const match = matcher.nextMatch();
+            if (match) {
+                this.checkpoint = match;
+                this.idx += 1;
+                return match;
+            }
+        }
+        return null;
+    }
+    match(checkpoint) {
+        this.idx = 0;
+        this.checkpoint = checkpoint;
+        while (!this.isMatchingComplete()) {
+            const forwardMatch = this.matchForward();
+            if (!forwardMatch) {
+                const backwardMatch = this.backtrack();
+                if (!backwardMatch) {
+                    return null;
+                }
+            }
+        }
+        return this.checkpoint;
+    }
+    nextMatch() {
+        if (!this.backtrack()) {
+            return null;
+        }
+        while (!this.isMatchingComplete()) {
+            const forwardMatch = this.matchForward();
+            if (!forwardMatch) {
+                const backwardMatch = this.backtrack();
+                if (!backwardMatch) {
+                    return null;
+                }
+            }
+        }
+        return this.checkpoint;
+    }
+}
 //# sourceMappingURL=seq-matcher.js.map

package/dist/esm/query/matchers/str-matcher.d.ts

@@ -1,39 +1,39 @@
-import type { StringValueToken } from '../../lexer/types';
-import type { TemplateTree } from '../../parser/types';
-import type { Checkpoint, Matcher, NodeHandler, StrTplOptionsBase, StrTreeHandler, StrTreeOptionsBase } from '../types';
-import { AbstractMatcher } from './abstract-matcher';
-export type StrContentMatcherValue = string | RegExp | null;
-export type StrContentMatcherHandler<Ctx> = (ctx: Ctx, token: StringValueToken) => Ctx;
-export interface StrContentMatcherOptions<Ctx> {
-    value: StrContentMatcherValue;
-    handler: StrContentMatcherHandler<Ctx> | null;
-}
-export declare class StrContentMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly content: StrContentMatcherValue;
-    readonly handler: StrContentMatcherHandler<Ctx>;
-    constructor({ value, handler }: StrContentMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-interface StrTplMatcherOptions<Ctx> extends StrTplOptionsBase<Ctx> {
-    matcher: Matcher<Ctx>;
-}
-export declare class StrTplMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    readonly matcher: Matcher<Ctx>;
-    readonly preHandler: NodeHandler<Ctx, TemplateTree>;
-    readonly postHandler: NodeHandler<Ctx, TemplateTree>;
-    constructor(config: StrTplMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-export type StrNodeChildMatcher<Ctx> = StrContentMatcher<Ctx> | StrTplMatcher<Ctx>;
-export interface StrMatcherOptions<Ctx> extends StrTreeOptionsBase<Ctx> {
-    matchers: StrNodeChildMatcher<Ctx>[] | null;
-}
-export declare class StrNodeMatcher<Ctx> extends AbstractMatcher<Ctx> {
-    matchers: StrNodeChildMatcher<Ctx>[] | null;
-    readonly preHandler: StrTreeHandler<Ctx>;
-    readonly postHandler: StrTreeHandler<Ctx>;
-    constructor(opts: StrMatcherOptions<Ctx>);
-    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
-}
-export {};
+import type { StringValueToken } from '../../lexer/types';
+import type { TemplateTree } from '../../parser/types';
+import type { Checkpoint, Matcher, NodeHandler, StrTplOptionsBase, StrTreeHandler, StrTreeOptionsBase } from '../types';
+import { AbstractMatcher } from './abstract-matcher';
+export type StrContentMatcherValue = string | RegExp | null;
+export type StrContentMatcherHandler<Ctx> = (ctx: Ctx, token: StringValueToken) => Ctx;
+export interface StrContentMatcherOptions<Ctx> {
+    value: StrContentMatcherValue;
+    handler: StrContentMatcherHandler<Ctx> | null;
+}
+export declare class StrContentMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly content: StrContentMatcherValue;
+    readonly handler: StrContentMatcherHandler<Ctx>;
+    constructor({ value, handler }: StrContentMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+interface StrTplMatcherOptions<Ctx> extends StrTplOptionsBase<Ctx> {
+    matcher: Matcher<Ctx>;
+}
+export declare class StrTplMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    readonly matcher: Matcher<Ctx>;
+    readonly preHandler: NodeHandler<Ctx, TemplateTree>;
+    readonly postHandler: NodeHandler<Ctx, TemplateTree>;
+    constructor(config: StrTplMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+export type StrNodeChildMatcher<Ctx> = StrContentMatcher<Ctx> | StrTplMatcher<Ctx>;
+export interface StrMatcherOptions<Ctx> extends StrTreeOptionsBase<Ctx> {
+    matchers: StrNodeChildMatcher<Ctx>[] | null;
+}
+export declare class StrNodeMatcher<Ctx> extends AbstractMatcher<Ctx> {
+    matchers: StrNodeChildMatcher<Ctx>[] | null;
+    readonly preHandler: StrTreeHandler<Ctx>;
+    readonly postHandler: StrTreeHandler<Ctx>;
+    constructor(opts: StrMatcherOptions<Ctx>);
+    match(checkpoint: Checkpoint<Ctx>): Checkpoint<Ctx> | null;
+}
+export {};
 //# sourceMappingURL=str-matcher.d.ts.map

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

@@ -1,103 +1,103 @@
-import { safeHandler } from '../handler';
-import { isRegex } from '../regex';
-import { AbstractMatcher } from './abstract-matcher';
-export class StrContentMatcher extends AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.content = value !== null && value !== void 0 ? value : null;
-        this.handler = 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 (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;
-    }
-}
-export class StrTplMatcher extends AbstractMatcher {
-    constructor(config) {
-        super();
-        this.matcher = config.matcher;
-        this.preHandler = safeHandler(config.preHandler);
-        this.postHandler = 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;
-    }
-}
-export class StrNodeMatcher extends AbstractMatcher {
-    constructor(opts) {
-        var _a;
-        super();
-        this.matchers = (_a = opts.matchers) !== null && _a !== void 0 ? _a : null;
-        this.preHandler = safeHandler(opts.preHandler);
-        this.postHandler = 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;
-    }
-}
+import { safeHandler } from '../handler';
+import { isRegex } from '../regex';
+import { AbstractMatcher } from './abstract-matcher';
+export class StrContentMatcher extends AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.content = value !== null && value !== void 0 ? value : null;
+        this.handler = 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 (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;
+    }
+}
+export class StrTplMatcher extends AbstractMatcher {
+    constructor(config) {
+        super();
+        this.matcher = config.matcher;
+        this.preHandler = safeHandler(config.preHandler);
+        this.postHandler = 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;
+    }
+}
+export class StrNodeMatcher extends AbstractMatcher {
+    constructor(opts) {
+        var _a;
+        super();
+        this.matchers = (_a = opts.matchers) !== null && _a !== void 0 ? _a : null;
+        this.preHandler = safeHandler(opts.preHandler);
+        this.postHandler = 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;
+    }
+}
 //# sourceMappingURL=str-matcher.js.map

package/dist/esm/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/esm/query/matchers/sym-matcher.js

@@ -1,31 +1,31 @@
-import { safeHandler } from '../handler';
-import { isRegex } from '../regex';
-import { AbstractMatcher } from './abstract-matcher';
-export class SymMatcher extends AbstractMatcher {
-    constructor({ value, handler }) {
-        super();
-        this.sym = value;
-        this.handler = 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 (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;
-    }
-}
+import { safeHandler } from '../handler';
+import { isRegex } from '../regex';
+import { AbstractMatcher } from './abstract-matcher';
+export class SymMatcher extends AbstractMatcher {
+    constructor({ value, handler }) {
+        super();
+        this.sym = value;
+        this.handler = 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 (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;
+    }
+}
 //# sourceMappingURL=sym-matcher.js.map

package/dist/esm/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