@openrewrite/rewrite 8.66.0 → 8.66.1

package/dist/javascript/templating/pattern.js

@@ -0,0 +1,681 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchResult = exports.Pattern = exports.PatternBuilder = void 0;
+exports.pattern = pattern;
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const immer_1 = require("immer");
+const java_1 = require("../../java");
+const index_1 = require("../index");
+const uuid_1 = require("../../uuid");
+const capture_1 = require("./capture");
+const comparator_1 = require("./comparator");
+const utils_1 = require("./utils");
+/**
+ * Builder for creating patterns programmatically.
+ * Use when pattern structure is not known at compile time.
+ *
+ * @example
+ * // Loop-based pattern generation
+ * const builder = Pattern.builder().code('myFunction(');
+ * for (let i = 0; i < argCount; i++) {
+ *     if (i > 0) builder.code(', ');
+ *     builder.capture(capture(`arg${i}`));
+ * }
+ * builder.code(')');
+ * const pat = builder.build();
+ *
+ * @example
+ * // Conditional pattern construction
+ * const builder = Pattern.builder().code('foo(');
+ * builder.capture(capture('first'));
+ * if (needsSecondArg) {
+ *     builder.code(', ').capture(capture('second'));
+ * }
+ * builder.code(')');
+ * const pat = builder.build();
+ */
+class PatternBuilder {
+    constructor() {
+        this.parts = [];
+        this.captures = [];
+    }
+    /**
+     * Adds a static string part to the pattern.
+     *
+     * @param str The string to add
+     * @returns This builder for chaining
+     */
+    code(str) {
+        // If there are already captures, we need to add an empty string before this
+        if (this.captures.length > this.parts.length) {
+            this.parts.push('');
+        }
+        // Append to the last part or start a new one
+        if (this.parts.length === 0) {
+            this.parts.push(str);
+        }
+        else {
+            this.parts[this.parts.length - 1] += str;
+        }
+        return this;
+    }
+    /**
+     * Adds a capture to the pattern.
+     *
+     * @param value The capture object (Capture or Any) or string name
+     * @returns This builder for chaining
+     */
+    capture(value) {
+        // Ensure we have a part for after this capture
+        if (this.parts.length === 0) {
+            this.parts.push('');
+        }
+        // Convert string to Capture if needed
+        const captureObj = typeof value === 'string' ? new capture_1.CaptureImpl(value) : value;
+        this.captures.push(captureObj);
+        // Add an empty string for the next part
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Builds the pattern from accumulated parts and captures.
+     *
+     * @returns A Pattern instance
+     */
+    build() {
+        // Ensure parts array is one longer than captures array
+        while (this.parts.length <= this.captures.length) {
+            this.parts.push('');
+        }
+        // Create a synthetic TemplateStringsArray
+        const templateStrings = this.parts.slice();
+        templateStrings.raw = this.parts.slice();
+        Object.defineProperty(templateStrings, 'raw', {
+            value: this.parts.slice(),
+            writable: false
+        });
+        // Delegate to the pattern() function
+        return pattern(templateStrings, ...this.captures);
+    }
+}
+exports.PatternBuilder = PatternBuilder;
+/**
+ * Represents a pattern that can be matched against AST nodes.
+ */
+class Pattern {
+    /**
+     * Gets the configuration options for this pattern.
+     * @readonly
+     */
+    get options() {
+        return this._options;
+    }
+    /**
+     * Creates a new builder for constructing patterns programmatically.
+     *
+     * @returns A new PatternBuilder instance
+     *
+     * @example
+     * const pat = Pattern.builder()
+     *     .code('function ')
+     *     .capture(capture('name'))
+     *     .code('() { return ')
+     *     .capture(capture('value'))
+     *     .code('; }')
+     *     .build();
+     */
+    static builder() {
+        return new PatternBuilder();
+    }
+    /**
+     * Creates a new pattern from template parts and captures.
+     *
+     * @param templateParts The string parts of the template
+     * @param captures The captures between the string parts (can be Capture or Any)
+     */
+    constructor(templateParts, captures) {
+        this.templateParts = templateParts;
+        this.captures = captures;
+        this._options = {};
+    }
+    /**
+     * Configures this pattern with additional options.
+     *
+     * @param options Configuration options
+     * @returns This pattern for method chaining
+     *
+     * @example
+     * pattern`isDate(${capture('date')})`
+     *     .configure({
+     *         imports: ['import { isDate } from \"util\"'],
+     *         dependencies: { 'util': '^1.0.0' }
+     *     })
+     */
+    configure(options) {
+        this._options = Object.assign(Object.assign({}, this._options), options);
+        return this;
+    }
+    /**
+     * Creates a matcher for this pattern against a specific AST node.
+     *
+     * @param ast The AST node to match against
+     * @returns A Matcher object
+     */
+    match(ast) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const matcher = new Matcher(this, ast);
+            const success = yield matcher.matches();
+            if (!success) {
+                return undefined;
+            }
+            // Create MatchResult with unified storage
+            const storage = matcher.storage;
+            return new MatchResult(new Map(storage));
+        });
+    }
+}
+exports.Pattern = Pattern;
+/**
+ * Result of a successful pattern match containing captured values.
+ *
+ * Provides access to captured AST nodes from pattern matching operations.
+ * Use the `get()` method to retrieve captured values by name or by Capture object.
+ *
+ * @example
+ * const x = capture('x');
+ * const pat = pattern`foo(${x})`;
+ * const match = await pat.match(someNode);
+ * if (match) {
+ *     const captured = match.get('x');  // Get by name
+ *     // or
+ *     const captured = match.get(x);    // Get by Capture object
+ * }
+ *
+ * @example
+ * // Variadic captures return arrays
+ * const args = capture({ variadic: true });
+ * const pat = pattern`foo(${args})`;
+ * const match = await pat.match(methodInvocation);
+ * if (match) {
+ *     const capturedArgs = match.get(args);  // Returns J[] for variadic captures
+ * }
+ */
+class MatchResult {
+    constructor(storage = new Map()) {
+        this.storage = storage;
+    }
+    // Implementation
+    get(capture) {
+        // Use symbol to get internal name without triggering Proxy
+        const name = typeof capture === "string" ? capture : (capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName());
+        const value = this.storage.get(name);
+        if (value === undefined) {
+            return undefined;
+        }
+        return this.extractElements(value);
+    }
+    /**
+     * Extracts semantic elements from storage value.
+     * For wrappers, extracts the .element; for arrays, returns array of elements.
+     *
+     * @param value The storage value
+     * @returns The semantic element(s)
+     */
+    extractElements(value) {
+        if (Array.isArray(value)) {
+            // Check if it's an array of wrappers
+            if (value.length > 0 && value[0].element !== undefined) {
+                // Array of J.RightPadded - extract elements
+                return value.map(w => w.element);
+            }
+            // Already an array of elements
+            return value;
+        }
+        // Check if it's a scalar wrapper
+        if (value.element !== undefined) {
+            return value.element;
+        }
+        // Scalar element
+        return value;
+    }
+    /**
+     * Internal method to get wrappers (used by template expansion).
+     * Returns both scalar and variadic wrappers.
+     * @internal
+     */
+    [utils_1.WRAPPERS_MAP_SYMBOL]() {
+        const result = new Map();
+        for (const [name, value] of this.storage) {
+            if (Array.isArray(value) && value.length > 0 && value[0].element !== undefined) {
+                // This is an array of wrappers (variadic)
+                result.set(name, value);
+            }
+            else if (!Array.isArray(value) && value.element !== undefined) {
+                // This is a scalar wrapper
+                result.set(name, value);
+            }
+        }
+        return result;
+    }
+}
+exports.MatchResult = MatchResult;
+/**
+ * Matcher for checking if a pattern matches an AST node and extracting captured nodes.
+ */
+class Matcher {
+    /**
+     * Creates a new matcher for a pattern against an AST node.
+     *
+     * @param pattern The pattern to match
+     * @param ast The AST node to match against
+     */
+    constructor(pattern, ast) {
+        this.pattern = pattern;
+        this.ast = ast;
+        // Unified storage: holds J for scalar captures, J.RightPadded<J>[] or J[] for variadic captures
+        this.storage = new Map();
+    }
+    /**
+     * Checks if the pattern matches the AST node.
+     *
+     * @returns true if the pattern matches, false otherwise
+     */
+    matches() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.patternAst) {
+                // Prefer 'context' over deprecated 'imports'
+                const contextStatements = this.pattern.options.context || this.pattern.options.imports || [];
+                const templateProcessor = new TemplateProcessor(this.pattern.templateParts, this.pattern.captures, contextStatements, this.pattern.options.dependencies || {});
+                this.patternAst = yield templateProcessor.toAstPattern();
+            }
+            return this.matchNode(this.patternAst, this.ast);
+        });
+    }
+    /**
+     * Gets all captured nodes (projected view: extracts elements from wrappers).
+     *
+     * @returns A map of capture names to captured nodes
+     */
+    getAll() {
+        const result = new Map();
+        for (const [name, value] of this.storage) {
+            result.set(name, this.extractElements(value));
+        }
+        return result;
+    }
+    /**
+     * Extracts semantic elements from storage value.
+     * For wrappers, extracts the .element; for arrays, returns array of elements.
+     *
+     * @param value The storage value
+     * @returns The semantic element(s)
+     */
+    extractElements(value) {
+        if (Array.isArray(value)) {
+            // Check if it's an array of wrappers
+            if (value.length > 0 && value[0].element !== undefined) {
+                // Array of J.RightPadded - extract elements
+                return value.map(w => w.element);
+            }
+            // Already an array of elements
+            return value;
+        }
+        // Check if it's a scalar wrapper
+        if (value.element !== undefined) {
+            return value.element;
+        }
+        // Scalar element
+        return value;
+    }
+    /**
+     * Matches a pattern node against a target node.
+     *
+     * @param pattern The pattern node
+     * @param target The target node
+     * @returns true if the pattern matches the target, false otherwise
+     */
+    matchNode(pattern, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Check if pattern is a capture placeholder
+            if (utils_1.PlaceholderUtils.isCapture(pattern)) {
+                return this.handleCapture(pattern, target);
+            }
+            // Check if nodes have the same kind
+            if (pattern.kind !== target.kind) {
+                return false;
+            }
+            // Use the pattern matching comparator with configured lenient type matching
+            // Default to true for backward compatibility with existing patterns
+            const lenientTypeMatching = (_a = this.pattern.options.lenientTypeMatching) !== null && _a !== void 0 ? _a : true;
+            const comparator = new comparator_1.PatternMatchingComparator({
+                handleCapture: (p, t) => this.handleCapture(p, t),
+                handleVariadicCapture: (p, ts, ws) => this.handleVariadicCapture(p, ts, ws),
+                saveState: () => this.saveState(),
+                restoreState: (state) => this.restoreState(state)
+            }, lenientTypeMatching);
+            return yield comparator.compare(pattern, target);
+        });
+    }
+    /**
+     * Saves the current state of storage for backtracking.
+     *
+     * @returns A snapshot of the current state
+     */
+    saveState() {
+        return new Map(this.storage);
+    }
+    /**
+     * Restores a previously saved state for backtracking.
+     *
+     * @param state The state to restore
+     */
+    restoreState(state) {
+        this.storage.clear();
+        state.forEach((value, key) => this.storage.set(key, value));
+    }
+    /**
+     * Handles a capture placeholder.
+     *
+     * @param pattern The pattern node
+     * @param target The target node
+     * @param wrapper Optional wrapper containing the target (for preserving markers)
+     * @returns true if the capture is successful, false otherwise
+     */
+    handleCapture(pattern, target, wrapper) {
+        var _a, _b;
+        const captureName = utils_1.PlaceholderUtils.getCaptureName(pattern);
+        if (!captureName) {
+            return false;
+        }
+        // Find the original capture object to get constraint and capturing flag
+        const captureObj = this.pattern.captures.find(c => c.getName() === captureName);
+        const constraint = (_a = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getConstraint) === null || _a === void 0 ? void 0 : _a.call(captureObj);
+        // Apply constraint if present
+        if (constraint && !constraint(target)) {
+            return false;
+        }
+        // Only store the binding if this is a capturing placeholder
+        const capturing = (_b = captureObj === null || captureObj === void 0 ? void 0 : captureObj[capture_1.CAPTURE_CAPTURING_SYMBOL]) !== null && _b !== void 0 ? _b : true;
+        if (capturing) {
+            // Store wrapper if available (preserves markers), otherwise store element
+            this.storage.set(captureName, wrapper !== null && wrapper !== void 0 ? wrapper : target);
+        }
+        return true;
+    }
+    /**
+     * Handles a variadic capture placeholder.
+     *
+     * @param pattern The pattern node (the variadic capture)
+     * @param targets The target nodes that were matched
+     * @param wrappers Optional wrappers to preserve markers
+     * @returns true if the capture is successful, false otherwise
+     */
+    handleVariadicCapture(pattern, targets, wrappers) {
+        var _a, _b;
+        const captureName = utils_1.PlaceholderUtils.getCaptureName(pattern);
+        if (!captureName) {
+            return false;
+        }
+        // Find the original capture object to get constraint and capturing flag
+        const captureObj = this.pattern.captures.find(c => c.getName() === captureName);
+        const constraint = (_a = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getConstraint) === null || _a === void 0 ? void 0 : _a.call(captureObj);
+        // Apply constraint if present - for variadic captures, constraint receives the array of elements
+        if (constraint && !constraint(targets)) {
+            return false;
+        }
+        // Only store the binding if this is a capturing placeholder
+        const capturing = (_b = captureObj === null || captureObj === void 0 ? void 0 : captureObj[capture_1.CAPTURE_CAPTURING_SYMBOL]) !== null && _b !== void 0 ? _b : true;
+        if (capturing) {
+            // Store the richest representation: wrappers if available, otherwise elements
+            if (wrappers && wrappers.length > 0) {
+                this.storage.set(captureName, wrappers);
+            }
+            else {
+                this.storage.set(captureName, targets);
+            }
+        }
+        return true;
+    }
+}
+/**
+ * Processor for template strings.
+ * Converts a template string with captures into an AST pattern.
+ */
+class TemplateProcessor {
+    /**
+     * Creates a new template processor.
+     *
+     * @param templateParts The string parts of the template
+     * @param captures The captures between the string parts (can be Capture or Any)
+     * @param contextStatements Context declarations (imports, types, etc.) to prepend for type attribution
+     * @param dependencies NPM dependencies for type attribution
+     */
+    constructor(templateParts, captures, contextStatements = [], dependencies = {}) {
+        this.templateParts = templateParts;
+        this.captures = captures;
+        this.contextStatements = contextStatements;
+        this.dependencies = dependencies;
+    }
+    /**
+     * Converts the template to an AST pattern.
+     *
+     * @returns A Promise resolving to the AST pattern
+     */
+    toAstPattern() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Combine template parts and placeholders
+            const templateString = this.buildTemplateString();
+            // Use cache to get or parse the compilation unit
+            const cu = yield utils_1.templateCache.getOrParse(templateString, this.captures, this.contextStatements, this.dependencies);
+            // Extract the relevant part of the AST
+            return this.extractPatternFromAst(cu);
+        });
+    }
+    /**
+     * Builds a template string with placeholders for captures.
+     * If the template looks like a block pattern, wraps it in a function.
+     *
+     * @returns The template string
+     */
+    buildTemplateString() {
+        let result = '';
+        for (let i = 0; i < this.templateParts.length; i++) {
+            result += this.templateParts[i];
+            if (i < this.captures.length) {
+                const capture = this.captures[i];
+                // Use symbol to access capture name without triggering Proxy
+                const captureName = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
+                result += utils_1.PlaceholderUtils.createCapture(captureName, undefined);
+            }
+        }
+        // Check if this looks like a block pattern (starts with { and contains statement keywords)
+        const trimmed = result.trim();
+        if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+            // Check for statement keywords that indicate this is a block, not an object literal
+            const hasStatementKeywords = /\b(return|if|for|while|do|switch|try|throw|break|continue|const|let|var|function|class)\b/.test(result);
+            if (hasStatementKeywords) {
+                // Wrap in a function to ensure it parses as a block
+                return `function __PATTERN__() ${result}`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Extracts the pattern from the parsed AST.
+     *
+     * @param cu The compilation unit
+     * @returns The extracted pattern
+     */
+    extractPatternFromAst(cu) {
+        var _a, _b;
+        // Skip context statements to get to the actual pattern code
+        const patternStatementIndex = this.contextStatements.length;
+        // Check if we have any statements at the pattern index
+        if (!cu.statements || patternStatementIndex >= cu.statements.length) {
+            // If there's no statement at the index, but we have exactly one statement
+            // and it's a block, it might be the pattern itself (e.g., pattern`{ ... }`)
+            if (cu.statements && cu.statements.length === 1 && cu.statements[0].element.kind === java_1.J.Kind.Block) {
+                return this.attachCaptureMarkers(cu.statements[0].element);
+            }
+            throw new Error(`No statement found at index ${patternStatementIndex} in compilation unit with ${((_a = cu.statements) === null || _a === void 0 ? void 0 : _a.length) || 0} statements`);
+        }
+        // Extract the relevant part of the AST based on the template content
+        const firstStatement = cu.statements[patternStatementIndex].element;
+        let extracted;
+        // Check if this is our wrapper function for block patterns
+        if (firstStatement.kind === java_1.J.Kind.MethodDeclaration) {
+            const method = firstStatement;
+            if (((_b = method.name) === null || _b === void 0 ? void 0 : _b.simpleName) === '__PATTERN__' && method.body) {
+                // Extract the block from the wrapper function
+                extracted = method.body;
+            }
+            else {
+                extracted = firstStatement;
+            }
+        }
+        else if (firstStatement.kind === index_1.JS.Kind.ExpressionStatement) {
+            // If the first statement is an expression statement, extract the expression
+            extracted = firstStatement.expression;
+        }
+        else {
+            // Otherwise, return the statement itself
+            extracted = firstStatement;
+        }
+        // Attach CaptureMarkers to capture identifiers
+        return this.attachCaptureMarkers(extracted);
+    }
+    /**
+     * Attaches CaptureMarkers to capture identifiers in the AST.
+     * This allows efficient capture detection without string parsing.
+     *
+     * @param ast The AST to process
+     * @returns The AST with CaptureMarkers attached
+     */
+    attachCaptureMarkers(ast) {
+        const visited = new Set();
+        return (0, immer_1.produce)(ast, draft => {
+            this.visitAndAttachMarkers(draft, visited);
+        });
+    }
+    /**
+     * Recursively visits AST nodes and attaches CaptureMarkers to capture identifiers.
+     * For statement-level captures (identifiers in ExpressionStatement), the marker
+     * is attached to the ExpressionStatement itself rather than the nested identifier.
+     *
+     * @param node The node to visit
+     * @param visited Set of already visited nodes to avoid cycles
+     */
+    visitAndAttachMarkers(node, visited) {
+        var _a, _b, _c;
+        if (!node || typeof node !== 'object' || visited.has(node)) {
+            return;
+        }
+        // Mark as visited to avoid cycles
+        visited.add(node);
+        // Check if this is an ExpressionStatement containing a capture identifier
+        // For statement-level captures, we attach the marker to the ExpressionStatement itself
+        if (node.kind === index_1.JS.Kind.ExpressionStatement &&
+            ((_a = node.expression) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
+            ((_b = node.expression.simpleName) === null || _b === void 0 ? void 0 : _b.startsWith(utils_1.PlaceholderUtils.CAPTURE_PREFIX))) {
+            const captureInfo = utils_1.PlaceholderUtils.parseCapture(node.expression.simpleName);
+            if (captureInfo) {
+                // Initialize markers on the ExpressionStatement
+                if (!node.markers) {
+                    node.markers = { kind: 'org.openrewrite.marker.Markers', id: (0, uuid_1.randomId)(), markers: [] };
+                }
+                if (!node.markers.markers) {
+                    node.markers.markers = [];
+                }
+                // Find the original capture object to get variadic options
+                const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
+                const variadicOptions = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getVariadicOptions();
+                // Add CaptureMarker to the ExpressionStatement
+                node.markers.markers.push(new utils_1.CaptureMarker(captureInfo.name, variadicOptions));
+            }
+        }
+        // For non-statement captures (expressions), attach marker to the identifier
+        else if (node.kind === java_1.J.Kind.Identifier && ((_c = node.simpleName) === null || _c === void 0 ? void 0 : _c.startsWith(utils_1.PlaceholderUtils.CAPTURE_PREFIX))) {
+            const captureInfo = utils_1.PlaceholderUtils.parseCapture(node.simpleName);
+            if (captureInfo) {
+                // Initialize markers if needed
+                if (!node.markers) {
+                    node.markers = { kind: 'org.openrewrite.marker.Markers', id: (0, uuid_1.randomId)(), markers: [] };
+                }
+                if (!node.markers.markers) {
+                    node.markers.markers = [];
+                }
+                // Find the original capture object to get variadic options
+                const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
+                const variadicOptions = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getVariadicOptions();
+                // Add CaptureMarker with variadic options if available
+                node.markers.markers.push(new utils_1.CaptureMarker(captureInfo.name, variadicOptions));
+            }
+        }
+        // Recursively visit all properties
+        for (const key in node) {
+            if (node.hasOwnProperty(key)) {
+                const value = node[key];
+                if (Array.isArray(value)) {
+                    value.forEach(item => this.visitAndAttachMarkers(item, visited));
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    this.visitAndAttachMarkers(value, visited);
+                }
+            }
+        }
+    }
+}
+/**
+ * Tagged template function for creating patterns.
+ *
+ * @param strings The string parts of the template
+ * @param captures The captures between the string parts (Capture, Any, or string names)
+ * @returns A Pattern object
+ *
+ * @example
+ * // Using the same capture multiple times for repeated patterns
+ * const expr = capture('expr');
+ * const redundantOr = pattern`${expr} || ${expr}`;
+ *
+ * @example
+ * // Using any() for non-capturing matches
+ * const pat = pattern`foo(${any()})`;
+ */
+function pattern(strings, ...captures) {
+    const capturesByName = captures.reduce((map, c) => {
+        const capture = typeof c === "string" ? new capture_1.CaptureImpl(c) : c;
+        // Use symbol to get internal name without triggering Proxy
+        const name = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
+        return map.set(name, capture);
+    }, new Map());
+    return new Pattern(strings, captures.map(c => {
+        // Use symbol to get internal name without triggering Proxy
+        const name = typeof c === "string" ? c : (c[capture_1.CAPTURE_NAME_SYMBOL] || c.getName());
+        return capturesByName.get(name);
+    }));
+}
+//# sourceMappingURL=pattern.js.map