@openrewrite/rewrite 8.66.0-SNAPSHOT → 8.66.1

package/dist/javascript/templating/capture.d.ts

@@ -0,0 +1,226 @@
+import { J } from '../../java';
+import { Capture, Any, TemplateParam, CaptureOptions, VariadicOptions } from './types';
+/**
+ * Combines multiple constraints with AND logic.
+ * All constraints must return true for the combined constraint to pass.
+ *
+ * @example
+ * const largeEvenNumber = capture('n', {
+ *     constraint: and(
+ *         (node) => typeof node.value === 'number',
+ *         (node) => node.value > 100,
+ *         (node) => node.value % 2 === 0
+ *     )
+ * });
+ */
+export declare function and<T>(...constraints: ((node: T) => boolean)[]): (node: T) => boolean;
+/**
+ * Combines multiple constraints with OR logic.
+ * At least one constraint must return true for the combined constraint to pass.
+ *
+ * @example
+ * const stringOrNumber = capture('value', {
+ *     constraint: or(
+ *         (node) => node.kind === J.Kind.Literal && typeof node.value === 'string',
+ *         (node) => node.kind === J.Kind.Literal && typeof node.value === 'number'
+ *     )
+ * });
+ */
+export declare function or<T>(...constraints: ((node: T) => boolean)[]): (node: T) => boolean;
+/**
+ * Negates a constraint.
+ * Returns true when the constraint returns false, and vice versa.
+ *
+ * @example
+ * const notString = capture('value', {
+ *     constraint: not((node) => typeof node.value === 'string')
+ * });
+ */
+export declare function not<T>(constraint: (node: T) => boolean): (node: T) => boolean;
+export declare const CAPTURE_NAME_SYMBOL: unique symbol;
+export declare const CAPTURE_VARIADIC_SYMBOL: unique symbol;
+export declare const CAPTURE_CONSTRAINT_SYMBOL: unique symbol;
+export declare const CAPTURE_CAPTURING_SYMBOL: unique symbol;
+export declare class CaptureImpl<T = any> implements Capture<T> {
+    readonly name: string;
+    [CAPTURE_NAME_SYMBOL]: string;
+    [CAPTURE_VARIADIC_SYMBOL]: VariadicOptions | undefined;
+    [CAPTURE_CONSTRAINT_SYMBOL]: ((node: T) => boolean) | undefined;
+    [CAPTURE_CAPTURING_SYMBOL]: boolean;
+    constructor(name: string, options?: CaptureOptions<T>, capturing?: boolean);
+    getName(): string;
+    isVariadic(): boolean;
+    getVariadicOptions(): VariadicOptions | undefined;
+    getConstraint(): ((node: T) => boolean) | undefined;
+    isCapturing(): boolean;
+}
+export declare class TemplateParamImpl<T = any> implements TemplateParam<T> {
+    readonly name: string;
+    constructor(name: string);
+    getName(): string;
+}
+/**
+ * Represents a property access on a captured value.
+ * When you access a property on a Capture (e.g., method.name), you get a CaptureValue
+ * that knows how to resolve that property from the matched values.
+ */
+export declare class CaptureValue {
+    readonly rootCapture: Capture;
+    readonly propertyPath: string[];
+    readonly arrayOperation?: {
+        type: "index" | "slice" | "length";
+        args?: number[];
+    } | undefined;
+    constructor(rootCapture: Capture, propertyPath: string[], arrayOperation?: {
+        type: "index" | "slice" | "length";
+        args?: number[];
+    } | undefined);
+    /**
+     * Resolves this capture value by looking up the root capture in the values map
+     * and navigating through the property path.
+     */
+    resolve(values: Pick<Map<string, J | J[]>, 'get'>): any;
+    /**
+     * Checks if this CaptureValue will resolve to an array that should be expanded.
+     */
+    isArrayExpansion(): boolean;
+}
+export declare function capture<T = any>(options: {
+    name?: string;
+    constraint: (node: T) => boolean;
+} & {
+    variadic?: never;
+}): Capture<T> & T;
+export declare function capture<T = any>(options: {
+    name?: string;
+    variadic: true | VariadicOptions;
+    constraint?: (nodes: T[]) => boolean;
+    min?: number;
+    max?: number;
+}): Capture<T[]> & T[];
+export declare function capture<T = any>(name?: string): Capture<T> & T;
+export declare namespace capture {
+    var nextUnnamedId: number;
+}
+/**
+ * Creates a non-capturing pattern match for use in patterns.
+ *
+ * Use `any()` when you need to match AST structure without binding the matched value to a name.
+ * This is useful for validation patterns where you care about structure but not the specific values.
+ *
+ * **Key Differences from `capture()`:**
+ * - `any()` returns `Any<T>` type (not `Capture<T>`)
+ * - Cannot be used in templates (TypeScript compiler prevents this)
+ * - Does not bind matched values (more memory efficient for patterns)
+ * - Supports same features: constraints, variadic matching
+ *
+ * @template T The expected type of the matched AST node (for TypeScript autocomplete and constraints)
+ * @param options Optional configuration (variadic, constraint)
+ * @returns An Any object that matches patterns without capturing
+ *
+ * @example
+ * // Match any single argument without capturing
+ * const pat = pattern`foo(${any()})`;
+ *
+ * @example
+ * // Match with constraint validation
+ * const numericArg = any<J.Literal>({
+ *     constraint: (node) => typeof node.value === 'number'
+ * });
+ * const pat = pattern`process(${numericArg})`;
+ *
+ * @example
+ * // Variadic any - match zero or more without capturing
+ * const rest = any({ variadic: true });
+ * const first = capture('first');
+ * const pat = pattern`foo(${first}, ${rest})`;
+ *
+ * @example
+ * // Mixed with captures - capture some, ignore others
+ * const important = capture('important');
+ * const pat = pattern`
+ *     if (${any()}) {
+ *         ${important}
+ *     }
+ * `;
+ *
+ * @example
+ * // Variadic with constraints
+ * const numericArgs = any<J.Literal>({
+ *     variadic: true,
+ *     constraint: (nodes) => nodes.every(n => typeof n.value === 'number')
+ * });
+ * const pat = pattern`sum(${numericArgs})`;
+ */
+export declare function any<T = any>(options: {
+    constraint: (node: T) => boolean;
+} & {
+    variadic?: never;
+}): Any<T> & T;
+export declare function any<T = any>(options: {
+    variadic: true | VariadicOptions;
+    constraint?: (nodes: T[]) => boolean;
+    min?: number;
+    max?: number;
+}): Any<T[]> & T[];
+export declare function any<T = any>(options?: CaptureOptions<T>): Any<T> & T;
+export declare namespace any {
+    var nextAnonId: number;
+}
+/**
+ * Creates a parameter specification for use in standalone templates (not used with patterns).
+ *
+ * Use `param()` when creating templates that are not used with pattern matching.
+ * Use `capture()` when the template works with a pattern.
+ *
+ * @template T The expected type of the parameter value (for TypeScript autocomplete only)
+ * @param name Optional name for the parameter. If not provided, an auto-generated name is used.
+ * @returns A TemplateParam object (simpler than Capture, no property access support)
+ *
+ * @remarks
+ * **When to use `param()` vs `capture()`:**
+ *
+ * - Use `param()` in **standalone templates** (no pattern matching involved)
+ * - Use `capture()` in **patterns** and templates used with patterns
+ *
+ * **Key Differences:**
+ * - `TemplateParam` is simpler - no property access proxy overhead
+ * - `Capture` supports property access (e.g., `capture('x').name.simpleName`)
+ * - Both work in templates, but `param()` makes intent clearer for standalone use
+ *
+ * @example
+ * // ✅ GOOD: Use param() for standalone templates
+ * const value = param<J.Literal>('value');
+ * const tmpl = template`return ${value} * 2;`;
+ * await tmpl.apply(cursor, node, new Map([['value', someLiteral]]));
+ *
+ * @example
+ * // ✅ GOOD: Use capture() with patterns
+ * const value = capture('value');
+ * const pat = pattern`foo(${value})`;
+ * const tmpl = template`bar(${value})`;  // capture() makes sense here
+ *
+ * @example
+ * // ⚠️ CONFUSING: Using capture() in standalone template
+ * const value = capture('value');
+ * template`return ${value} * 2;`;  // "Capturing" what? There's no pattern!
+ *
+ * @example
+ * // ❌ WRONG: param() doesn't support property access
+ * const node = param<J.MethodInvocation>('invocation');
+ * template`console.log(${node.name})`  // Error! Use capture() for property access
+ */
+export declare function param<T = any>(name?: string): TemplateParam<T>;
+/**
+ * Concise alias for `capture`. Works well for inline captures in patterns and templates.
+ *
+ * @param name Optional name for the capture. If not provided, an auto-generated name is used.
+ * @returns A Capture object
+ *
+ * @example
+ * // Inline captures with _ alias
+ * pattern`isDate(${_('dateArg')})`
+ * template`${_('dateArg')} instanceof Date`
+ */
+export declare const _: typeof capture;
+//# sourceMappingURL=capture.d.ts.map

package/dist/javascript/templating/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/capture.ts"],"names":[],"mappings":"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"}

package/dist/javascript/templating/capture.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ = exports.CaptureValue = exports.TemplateParamImpl = exports.CaptureImpl = exports.CAPTURE_CAPTURING_SYMBOL = exports.CAPTURE_CONSTRAINT_SYMBOL = exports.CAPTURE_VARIADIC_SYMBOL = exports.CAPTURE_NAME_SYMBOL = void 0;
+exports.and = and;
+exports.or = or;
+exports.not = not;
+exports.capture = capture;
+exports.any = any;
+exports.param = param;
+/**
+ * Combines multiple constraints with AND logic.
+ * All constraints must return true for the combined constraint to pass.
+ *
+ * @example
+ * const largeEvenNumber = capture('n', {
+ *     constraint: and(
+ *         (node) => typeof node.value === 'number',
+ *         (node) => node.value > 100,
+ *         (node) => node.value % 2 === 0
+ *     )
+ * });
+ */
+function and(...constraints) {
+    return (node) => constraints.every(c => c(node));
+}
+/**
+ * Combines multiple constraints with OR logic.
+ * At least one constraint must return true for the combined constraint to pass.
+ *
+ * @example
+ * const stringOrNumber = capture('value', {
+ *     constraint: or(
+ *         (node) => node.kind === J.Kind.Literal && typeof node.value === 'string',
+ *         (node) => node.kind === J.Kind.Literal && typeof node.value === 'number'
+ *     )
+ * });
+ */
+function or(...constraints) {
+    return (node) => constraints.some(c => c(node));
+}
+/**
+ * Negates a constraint.
+ * Returns true when the constraint returns false, and vice versa.
+ *
+ * @example
+ * const notString = capture('value', {
+ *     constraint: not((node) => typeof node.value === 'string')
+ * });
+ */
+function not(constraint) {
+    return (node) => !constraint(node);
+}
+// Symbol to access the internal capture name without triggering Proxy
+exports.CAPTURE_NAME_SYMBOL = Symbol('captureName');
+// Symbol to access variadic options without triggering Proxy
+exports.CAPTURE_VARIADIC_SYMBOL = Symbol('captureVariadic');
+// Symbol to access constraint function without triggering Proxy
+exports.CAPTURE_CONSTRAINT_SYMBOL = Symbol('captureConstraint');
+// Symbol to access capturing flag without triggering Proxy
+exports.CAPTURE_CAPTURING_SYMBOL = Symbol('captureCapturing');
+class CaptureImpl {
+    constructor(name, options, capturing = true) {
+        this.name = name;
+        this[exports.CAPTURE_NAME_SYMBOL] = name;
+        this[exports.CAPTURE_CAPTURING_SYMBOL] = capturing;
+        // Normalize variadic options
+        if (options === null || options === void 0 ? void 0 : options.variadic) {
+            if (typeof options.variadic === 'boolean') {
+                this[exports.CAPTURE_VARIADIC_SYMBOL] = {};
+            }
+            else {
+                this[exports.CAPTURE_VARIADIC_SYMBOL] = {
+                    min: options.variadic.min,
+                    max: options.variadic.max
+                };
+            }
+        }
+        // Store constraint if provided
+        if (options === null || options === void 0 ? void 0 : options.constraint) {
+            this[exports.CAPTURE_CONSTRAINT_SYMBOL] = options.constraint;
+        }
+    }
+    getName() {
+        return this[exports.CAPTURE_NAME_SYMBOL];
+    }
+    isVariadic() {
+        return this[exports.CAPTURE_VARIADIC_SYMBOL] !== undefined;
+    }
+    getVariadicOptions() {
+        return this[exports.CAPTURE_VARIADIC_SYMBOL];
+    }
+    getConstraint() {
+        return this[exports.CAPTURE_CONSTRAINT_SYMBOL];
+    }
+    isCapturing() {
+        return this[exports.CAPTURE_CAPTURING_SYMBOL];
+    }
+}
+exports.CaptureImpl = CaptureImpl;
+class TemplateParamImpl {
+    constructor(name) {
+        this.name = name;
+    }
+    getName() {
+        return this.name;
+    }
+}
+exports.TemplateParamImpl = TemplateParamImpl;
+/**
+ * Represents a property access on a captured value.
+ * When you access a property on a Capture (e.g., method.name), you get a CaptureValue
+ * that knows how to resolve that property from the matched values.
+ */
+class CaptureValue {
+    constructor(rootCapture, propertyPath, arrayOperation) {
+        this.rootCapture = rootCapture;
+        this.propertyPath = propertyPath;
+        this.arrayOperation = arrayOperation;
+    }
+    /**
+     * Resolves this capture value by looking up the root capture in the values map
+     * and navigating through the property path.
+     */
+    resolve(values) {
+        const rootName = this.rootCapture.getName();
+        let current = values.get(rootName);
+        // Handle array operations on variadic captures
+        if (this.arrayOperation && Array.isArray(current)) {
+            switch (this.arrayOperation.type) {
+                case 'index':
+                    current = current[this.arrayOperation.args[0]];
+                    break;
+                case 'slice':
+                    current = current.slice(...this.arrayOperation.args);
+                    break;
+                case 'length':
+                    current = current.length;
+                    break;
+            }
+        }
+        // Navigate through property path
+        for (const prop of this.propertyPath) {
+            if (current === null || current === undefined || typeof current === 'number') {
+                return undefined;
+            }
+            current = current[prop];
+        }
+        return current;
+    }
+    /**
+     * Checks if this CaptureValue will resolve to an array that should be expanded.
+     */
+    isArrayExpansion() {
+        var _a, _b, _c;
+        // Only slice operations and the root variadic capture return arrays
+        return ((_a = this.arrayOperation) === null || _a === void 0 ? void 0 : _a.type) === 'slice' ||
+            (this.arrayOperation === undefined && this.propertyPath.length === 0 &&
+                ((_c = (_b = this.rootCapture).isVariadic) === null || _c === void 0 ? void 0 : _c.call(_b)));
+    }
+}
+exports.CaptureValue = CaptureValue;
+/**
+ * Creates a Proxy around a CaptureValue that allows further property access.
+ * This enables chaining like method.name.simpleName
+ */
+function createCaptureValueProxy(rootCapture, propertyPath, arrayOperation) {
+    const captureValue = new CaptureValue(rootCapture, propertyPath, arrayOperation);
+    return new Proxy(captureValue, {
+        get(target, prop) {
+            // Allow access to the CaptureValue instance itself and its methods
+            if (prop === 'resolve' || prop === 'rootCapture' || prop === 'propertyPath' ||
+                prop === 'arrayOperation' || prop === 'isArrayExpansion') {
+                const value = target[prop];
+                return typeof value === 'function' ? value.bind(target) : value;
+            }
+            // For string property access, extend the property path
+            if (typeof prop === 'string') {
+                return createCaptureValueProxy(target.rootCapture, [...target.propertyPath, prop], target.arrayOperation);
+            }
+            return undefined;
+        }
+    });
+}
+/**
+ * Creates a capture specification for use in template patterns.
+ *
+ * @template T The expected type of the captured AST node (for TypeScript autocomplete only)
+ * @returns A Capture object that supports property access for use in templates
+ *
+ * @remarks
+ * **Pattern Matching is Structural:**
+ *
+ * What a capture matches is determined by the pattern structure, not the type parameter:
+ * - `pattern`${capture('x')}`` matches ANY single expression (identifier, literal, call, binary, etc.)
+ * - `pattern`foo(${capture('x')})`` matches only expressions inside `foo()` calls
+ * - `pattern`${capture('x')} + ${capture('y')}`` matches only binary `+` expressions
+ *
+ * The TypeScript type parameter `<T>` provides IDE autocomplete but doesn't enforce runtime types.
+ *
+ * @example
+ * // Named inline captures
+ * const pat = pattern`${capture('left')} + ${capture('right')}`;
+ * // Matches: <any expression> + <any expression>
+ *
+ * // Unnamed captures
+ * const {left, right} = {left: capture(), right: capture()};
+ * const pattern = pattern`${left} + ${right}`;
+ *
+ * @example
+ * // Type parameter is for IDE autocomplete only
+ * const method = capture<J.MethodInvocation>('method');
+ * const pat = pattern`foo(${method})`;
+ * // Matches: foo(<any expression>) - not restricted to method invocations!
+ * // Type <J.MethodInvocation> only helps with autocomplete in your code
+ *
+ * @example
+ * // Structural pattern determines what matches
+ * const arg = capture('arg');
+ * const pat = pattern`process(${arg})`;
+ * // Matches: process(42), process("text"), process(x + y), etc.
+ * // The 'arg' capture will bind to whatever expression is passed to process()
+ *
+ * @example
+ * // Repeated patterns using the same capture
+ * const expr = capture('expr');
+ * const redundantOr = pattern`${expr} || ${expr}`;
+ * // Matches expressions where both sides are identical: x || x, foo() || foo()
+ *
+ * @example
+ * // Property access in templates
+ * const method = capture<J.MethodInvocation>('method');
+ * template`console.log(${method.name.simpleName})`  // Accesses properties of captured node
+ */
+/**
+ * Creates a Proxy wrapper for CaptureImpl that intercepts property accesses.
+ * Shared logic between capture() and any() to avoid duplication.
+ */
+function createCaptureProxy(impl) {
+    return new Proxy(impl, {
+        get(target, prop) {
+            // Allow access to internal symbols
+            if (prop === exports.CAPTURE_NAME_SYMBOL) {
+                return target[exports.CAPTURE_NAME_SYMBOL];
+            }
+            if (prop === exports.CAPTURE_VARIADIC_SYMBOL) {
+                return target[exports.CAPTURE_VARIADIC_SYMBOL];
+            }
+            if (prop === exports.CAPTURE_CONSTRAINT_SYMBOL) {
+                return target[exports.CAPTURE_CONSTRAINT_SYMBOL];
+            }
+            if (prop === exports.CAPTURE_CAPTURING_SYMBOL) {
+                return target[exports.CAPTURE_CAPTURING_SYMBOL];
+            }
+            // Allow methods to be called directly on the target
+            if (prop === 'getName' || prop === 'isVariadic' || prop === 'getVariadicOptions' || prop === 'getConstraint' || prop === 'isCapturing') {
+                return target[prop].bind(target);
+            }
+            // For variadic captures, support array-like operations
+            if (target.isVariadic() && typeof prop === 'string') {
+                // Numeric index access: args[0], args[1], etc.
+                const indexNum = Number(prop);
+                if (!isNaN(indexNum) && indexNum >= 0 && Number.isInteger(indexNum)) {
+                    return createCaptureValueProxy(target, [], { type: 'index', args: [indexNum] });
+                }
+                // Array method: slice
+                if (prop === 'slice') {
+                    return (...args) => {
+                        return createCaptureValueProxy(target, [], { type: 'slice', args });
+                    };
+                }
+                // Array property: length
+                if (prop === 'length') {
+                    return createCaptureValueProxy(target, [], { type: 'length' });
+                }
+            }
+            // For string property access, create a CaptureValue with a property path
+            if (typeof prop === 'string') {
+                return createCaptureValueProxy(target, [prop]);
+            }
+            return undefined;
+        }
+    });
+}
+// Implementation
+function capture(nameOrOptions) {
+    let name;
+    let options;
+    if (typeof nameOrOptions === 'string') {
+        // Simple named capture: capture('name')
+        name = nameOrOptions;
+        options = undefined;
+    }
+    else {
+        // Options-based API: capture({ name: 'name', ...options }) or capture()
+        options = nameOrOptions;
+        name = options === null || options === void 0 ? void 0 : options.name;
+    }
+    const captureName = name || `unnamed_${capture.nextUnnamedId++}`;
+    const impl = new CaptureImpl(captureName, options);
+    return createCaptureProxy(impl);
+}
+// Static counter for generating unique IDs for unnamed captures
+capture.nextUnnamedId = 1;
+// Implementation
+function any(options) {
+    const anonName = `anon_${any.nextAnonId++}`;
+    const impl = new CaptureImpl(anonName, options, false); // capturing = false
+    return createCaptureProxy(impl);
+}
+// Static counter for generating unique IDs for anonymous (non-capturing) patterns
+any.nextAnonId = 1;
+/**
+ * Creates a parameter specification for use in standalone templates (not used with patterns).
+ *
+ * Use `param()` when creating templates that are not used with pattern matching.
+ * Use `capture()` when the template works with a pattern.
+ *
+ * @template T The expected type of the parameter value (for TypeScript autocomplete only)
+ * @param name Optional name for the parameter. If not provided, an auto-generated name is used.
+ * @returns A TemplateParam object (simpler than Capture, no property access support)
+ *
+ * @remarks
+ * **When to use `param()` vs `capture()`:**
+ *
+ * - Use `param()` in **standalone templates** (no pattern matching involved)
+ * - Use `capture()` in **patterns** and templates used with patterns
+ *
+ * **Key Differences:**
+ * - `TemplateParam` is simpler - no property access proxy overhead
+ * - `Capture` supports property access (e.g., `capture('x').name.simpleName`)
+ * - Both work in templates, but `param()` makes intent clearer for standalone use
+ *
+ * @example
+ * // ✅ GOOD: Use param() for standalone templates
+ * const value = param<J.Literal>('value');
+ * const tmpl = template`return ${value} * 2;`;
+ * await tmpl.apply(cursor, node, new Map([['value', someLiteral]]));
+ *
+ * @example
+ * // ✅ GOOD: Use capture() with patterns
+ * const value = capture('value');
+ * const pat = pattern`foo(${value})`;
+ * const tmpl = template`bar(${value})`;  // capture() makes sense here
+ *
+ * @example
+ * // ⚠️ CONFUSING: Using capture() in standalone template
+ * const value = capture('value');
+ * template`return ${value} * 2;`;  // "Capturing" what? There's no pattern!
+ *
+ * @example
+ * // ❌ WRONG: param() doesn't support property access
+ * const node = param<J.MethodInvocation>('invocation');
+ * template`console.log(${node.name})`  // Error! Use capture() for property access
+ */
+function param(name) {
+    const paramName = name || `unnamed_${capture.nextUnnamedId++}`;
+    return new TemplateParamImpl(paramName);
+}
+/**
+ * Concise alias for `capture`. Works well for inline captures in patterns and templates.
+ *
+ * @param name Optional name for the capture. If not provided, an auto-generated name is used.
+ * @returns A Capture object
+ *
+ * @example
+ * // Inline captures with _ alias
+ * pattern`isDate(${_('dateArg')})`
+ * template`${_('dateArg')} instanceof Date`
+ */
+exports._ = capture;
+//# sourceMappingURL=capture.js.map

package/dist/javascript/templating/capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.js","sourceRoot":"","sources":["../../../src/javascript/templating/capture.ts"],"names":[],"mappings":"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"}

package/dist/javascript/templating/comparator.d.ts

@@ -0,0 +1,61 @@
+import { Cursor, Tree } from '../..';
+import { J } from '../../java';
+import { JS } from '../index';
+import { JavaScriptSemanticComparatorVisitor } from '../comparator';
+import { CaptureStorageValue } from './utils';
+/**
+ * A comparator for pattern matching that is lenient about optional properties.
+ * Allows patterns without type annotations to match actual code with type annotations.
+ * Uses semantic comparison to match semantically equivalent code (e.g., isDate() and util.isDate()).
+ */
+export declare class PatternMatchingComparator extends JavaScriptSemanticComparatorVisitor {
+    private readonly matcher;
+    constructor(matcher: {
+        handleCapture: (pattern: J, target: J, wrapper?: J.RightPadded<J>) => boolean;
+        handleVariadicCapture: (pattern: J, targets: J[], wrappers?: J.RightPadded<J>[]) => boolean;
+        saveState: () => Map<string, CaptureStorageValue>;
+        restoreState: (state: Map<string, CaptureStorageValue>) => void;
+    }, lenientTypeMatching?: boolean);
+    /**
+     * Extracts the wrapper from the cursor if the parent is a RightPadded.
+     */
+    private getWrapperFromCursor;
+    visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined>;
+    protected hasSameKind(j: J, other: J): boolean;
+    visitIdentifier(identifier: J.Identifier, other: J): Promise<J | undefined>;
+    visitMethodInvocation(methodInvocation: J.MethodInvocation, other: J): Promise<J | undefined>;
+    visitBlock(block: J.Block, other: J): Promise<J | undefined>;
+    visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, other: J): Promise<J | undefined>;
+    /**
+     * Matches argument lists, with special handling for variadic captures.
+     * A variadic capture can match zero or more consecutive arguments.
+     */
+    private matchArguments;
+    /**
+     * Generic sequence matching with variadic capture support.
+     * Works for any sequence of JRightPadded elements (arguments, statements, etc.).
+     * A variadic capture can match zero or more consecutive elements.
+     *
+     * Uses pivot detection to optimize matching, with backtracking as fallback.
+     *
+     * @param patternElements The pattern elements (JRightPadded)
+     * @param targetElements The target elements to match against (JRightPadded)
+     * @param filterEmpty Whether to filter out J.Empty elements when capturing (true for arguments, false for statements)
+     * @returns true if the sequence matches, false otherwise
+     */
+    private matchSequence;
+    /**
+     * Optimized sequence matcher with pivot detection and backtracking.
+     * For variadic patterns, tries to detect pivots (where next pattern matches) to avoid
+     * unnecessary backtracking. Falls back to full backtracking when pivots are ambiguous.
+     *
+     * @param patternElements The pattern elements (JRightPadded)
+     * @param targetElements The target elements to match against (JRightPadded)
+     * @param patternIdx Current position in pattern
+     * @param targetIdx Current position in target
+     * @param filterEmpty Whether to filter out J.Empty elements when capturing
+     * @returns true if the remaining sequence matches, false otherwise
+     */
+    private matchSequenceOptimized;
+}
+//# sourceMappingURL=comparator.d.ts.map