@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/comparator.js

@@ -1,13 +1,4 @@
 "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.JavaScriptSemanticComparatorVisitor = exports.JavaScriptComparatorVisitor = void 0;
 /*
@@ -51,16 +42,14 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param parentCursor2 Optional parent cursor for the target tree (for navigating to root)
      * @returns true if the trees match, false otherwise
      */
-    compare(tree1, tree2, parentCursor1, parentCursor2) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.match = true;
-            // Initialize targetCursor with parent if provided, otherwise undefined (will be set by visit())
-            this.targetCursor = parentCursor2;
-            // Initialize this.cursor (pattern cursor) with parent if provided
-            this.cursor = parentCursor1 || new tree_2.Cursor(undefined, undefined);
-            yield this.visit(tree1, tree2);
-            return this.match;
-        });
+    async compare(tree1, tree2, parentCursor1, parentCursor2) {
+        this.match = true;
+        // Initialize targetCursor with parent if provided, otherwise undefined (will be set by visit())
+        this.targetCursor = parentCursor2;
+        // Initialize this.cursor (pattern cursor) with parent if provided
+        this.cursor = parentCursor1 || new tree_2.Cursor(undefined, undefined);
+        await this.visit(tree1, tree2);
+        return this.match;
     }
     /**
      * Checks if two nodes have the same kind.
@@ -131,20 +120,18 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param visitor Function to visit each element pair (no need to return anything)
      * @returns undefined, modifying this.match if a mismatch occurs
      */
-    visitArrayProperty(parent, propertyName, array1, array2, visitor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check length mismatch
-            if (array1.length !== array2.length) {
-                this.arrayLengthMismatch(propertyName);
+    async visitArrayProperty(parent, propertyName, array1, array2, visitor) {
+        // Check length mismatch
+        if (array1.length !== array2.length) {
+            this.arrayLengthMismatch(propertyName);
+            return;
+        }
+        // Visit each element in lock step
+        for (let i = 0; i < array1.length; i++) {
+            await visitor(array1[i], array2[i], i);
+            if (!this.match)
                 return;
-            }
-            // Visit each element in lock step
-            for (let i = 0; i < array1.length; i++) {
-                yield visitor(array1[i], array2[i], i);
-                if (!this.match)
-                    return;
-            }
-        });
+        }
     }
     /**
      * Helper method to visit a container property with proper context.
@@ -156,13 +143,11 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param otherContainer The container from the second tree
      * @returns The container from the first tree
      */
-    visitContainerProperty(propertyName, container, otherContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default implementation just calls visitContainer
-            // Subclasses can override to add property context
-            yield this.visitContainer(container, otherContainer);
-            return container;
-        });
+    async visitContainerProperty(propertyName, container, otherContainer) {
+        // Default implementation just calls visitContainer
+        // Subclasses can override to add property context
+        await this.visitContainer(container, otherContainer);
+        return container;
     }
     /**
      * Helper to visit a RightPadded property with property context.
@@ -173,12 +158,10 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param otherRightPadded The RightPadded from the second tree
      * @returns The RightPadded from the first tree
      */
-    visitRightPaddedProperty(propertyName, rightPadded, otherRightPadded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default implementation just calls visitRightPadded
-            // Subclasses can override to add property context
-            return yield this.visitRightPadded(rightPadded, otherRightPadded);
-        });
+    async visitRightPaddedProperty(propertyName, rightPadded, otherRightPadded) {
+        // Default implementation just calls visitRightPadded
+        // Subclasses can override to add property context
+        return await this.visitRightPadded(rightPadded, otherRightPadded);
     }
     /**
      * Helper to visit a LeftPadded property with property context.
@@ -189,12 +172,10 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param otherLeftPadded The LeftPadded from the second tree
      * @returns The LeftPadded from the first tree
      */
-    visitLeftPaddedProperty(propertyName, leftPadded, otherLeftPadded) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default implementation just calls visitLeftPadded
-            // Subclasses can override to add property context
-            return yield this.visitLeftPadded(leftPadded, otherLeftPadded);
-        });
+    async visitLeftPaddedProperty(propertyName, leftPadded, otherLeftPadded) {
+        // Default implementation just calls visitLeftPadded
+        // Subclasses can override to add property context
+        return await this.visitLeftPadded(leftPadded, otherLeftPadded);
     }
     /**
      * Generic method to visit a property value using the appropriate visitor method.
@@ -205,50 +186,48 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param propertyName Optional property name for error reporting
      * @returns The visited property value from the first tree
      */
-    visitProperty(j, other, propertyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Handle null/undefined (but not other falsy values like 0, false, '')
-            if (j == null || other == null) {
-                if (j !== other) {
-                    return this.structuralMismatch(propertyName);
-                }
-                return j;
-            }
-            const kind = j.kind;
-            // Check wrappers by kind
-            if (kind === java_1.J.Kind.RightPadded) {
-                return propertyName ? yield this.visitRightPaddedProperty(propertyName, j, other) :
-                    yield this.visitRightPadded(j, other);
-            }
-            if (kind === java_1.J.Kind.LeftPadded) {
-                return propertyName ? yield this.visitLeftPaddedProperty(propertyName, j, other) :
-                    yield this.visitLeftPadded(j, other);
-            }
-            if (kind === java_1.J.Kind.Container) {
-                // Use visitContainerProperty when propertyName is provided for proper context tracking
-                if (propertyName) {
-                    return yield this.visitContainerProperty(propertyName, j, other);
-                }
-                return yield this.visitContainer(j, other);
-            }
-            // Check if it's a Space (skip comparison)
-            if (kind === java_1.J.Kind.Space) {
-                return j;
-            }
-            // Check if it's a Type node
-            if (java_1.Type.isType(j)) {
-                return yield this.visitType(j, other);
-            }
-            // Check if it's a Tree node (has a kind property with a string value)
-            if (kind !== undefined && typeof kind === 'string') {
-                return yield this.visit(j, other);
-            }
-            // For primitive values, compare directly
+    async visitProperty(j, other, propertyName) {
+        // Handle null/undefined (but not other falsy values like 0, false, '')
+        if (j == null || other == null) {
             if (j !== other) {
-                return this.valueMismatch(propertyName, j, other);
+                return this.structuralMismatch(propertyName);
             }
             return j;
-        });
+        }
+        const kind = j.kind;
+        // Check wrappers by kind
+        if (kind === java_1.J.Kind.RightPadded) {
+            return propertyName ? await this.visitRightPaddedProperty(propertyName, j, other) :
+                await this.visitRightPadded(j, other);
+        }
+        if (kind === java_1.J.Kind.LeftPadded) {
+            return propertyName ? await this.visitLeftPaddedProperty(propertyName, j, other) :
+                await this.visitLeftPadded(j, other);
+        }
+        if (kind === java_1.J.Kind.Container) {
+            // Use visitContainerProperty when propertyName is provided for proper context tracking
+            if (propertyName) {
+                return await this.visitContainerProperty(propertyName, j, other);
+            }
+            return await this.visitContainer(j, other);
+        }
+        // Check if it's a Space (skip comparison)
+        if (kind === java_1.J.Kind.Space) {
+            return j;
+        }
+        // Check if it's a Type node
+        if (java_1.Type.isType(j)) {
+            return await this.visitType(j, other);
+        }
+        // Check if it's a Tree node (has a kind property with a string value)
+        if (kind !== undefined && typeof kind === 'string') {
+            return await this.visit(j, other);
+        }
+        // For primitive values, compare directly
+        if (j !== other) {
+            return this.valueMismatch(propertyName, j, other);
+        }
+        return j;
     }
     /**
      * Generic method to visit all properties of an element, calling visitProperty for each.
@@ -259,67 +238,60 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The corresponding element from the second tree
      * @returns The visited element from the first tree
      */
-    visitElement(j, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return j;
-            // Check if kinds match
-            if (j.kind !== other.kind) {
-                return this.kindMismatch();
-            }
-            // Iterate over all properties
-            for (const key of Object.keys(j)) {
-                // Skip internal/private properties, id property, and markers property
-                if (key.startsWith('_') || key === 'kind' || key === 'id' || key === 'markers') {
-                    continue;
-                }
-                const jValue = j[key];
-                const otherValue = other[key];
-                // Handle arrays - compare element by element
-                if (Array.isArray(jValue)) {
-                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.arrayLengthMismatch(key);
-                    }
-                    for (let i = 0; i < jValue.length; i++) {
-                        yield this.visitProperty(jValue[i], otherValue[i], `${key}[${i}]`);
-                        if (!this.match)
-                            return j;
-                    }
+    async visitElement(j, other) {
+        if (!this.match)
+            return j;
+        // Check if kinds match
+        if (j.kind !== other.kind) {
+            return this.kindMismatch();
+        }
+        // Iterate over all properties
+        for (const key of Object.keys(j)) {
+            // Skip internal/private properties, id property, and markers property
+            if (key.startsWith('_') || key === 'kind' || key === 'id' || key === 'markers') {
+                continue;
+            }
+            const jValue = j[key];
+            const otherValue = other[key];
+            // Handle arrays - compare element by element
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.arrayLengthMismatch(key);
                 }
-                else {
-                    // Visit the property (which will handle wrappers, trees, primitives, etc.)
-                    yield this.visitProperty(jValue, otherValue, key);
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i], `${key}[${i}]`);
                     if (!this.match)
                         return j;
                 }
             }
-            return j;
-        });
-    }
-    visit(j, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // If we've already found a mismatch, abort further processing
-            if (!this.match)
-                return j;
-            // Check if the nodes have the same kind
-            if (!this.hasSameKind(j, p)) {
-                return this.kindMismatch();
-            }
-            // Update targetCursor to track the target node in parallel with the pattern cursor
-            // (Can be overridden by subclasses if they need cursor access before calling super)
-            const savedTargetCursor = this.targetCursor;
-            this.targetCursor = new tree_2.Cursor(p, this.targetCursor);
-            try {
-                // Continue with normal visitation, passing the other node as context
-                return yield _super.visit.call(this, j, p);
-            }
-            finally {
-                this.targetCursor = savedTargetCursor;
+            else {
+                // Visit the property (which will handle wrappers, trees, primitives, etc.)
+                await this.visitProperty(jValue, otherValue, key);
+                if (!this.match)
+                    return j;
             }
-        });
+        }
+        return j;
+    }
+    async visit(j, p, parent) {
+        // If we've already found a mismatch, abort further processing
+        if (!this.match)
+            return j;
+        // Check if the nodes have the same kind
+        if (!this.hasSameKind(j, p)) {
+            return this.kindMismatch();
+        }
+        // Update targetCursor to track the target node in parallel with the pattern cursor
+        // (Can be overridden by subclasses if they need cursor access before calling super)
+        const savedTargetCursor = this.targetCursor;
+        this.targetCursor = new tree_2.Cursor(p, this.targetCursor);
+        try {
+            // Continue with normal visitation, passing the other node as context
+            return await super.visit(j, p);
+        }
+        finally {
+            this.targetCursor = savedTargetCursor;
+        }
     }
     /**
      * Override visitRightPadded to compare only the elements, not markers or spacing.
@@ -327,30 +299,28 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * Pushes the wrapper onto the cursor stack so captures can access it.
      * Also updates targetCursor in parallel.
      */
-    visitRightPadded(right, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return right;
-            // Extract the other element if it's also a RightPadded
-            const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
-            const otherWrapper = isRightPadded ? p : undefined;
-            const otherElement = isRightPadded ? otherWrapper.element : p;
-            // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
-            const savedCursor = this.cursor;
-            const savedTargetCursor = this.targetCursor;
-            this.cursor = new tree_2.Cursor(right, this.cursor);
-            this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
-            try {
-                // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
-                // The property context should be provided through visitRightPaddedProperty() if needed
-                yield this.visitProperty(right.element, otherElement);
-            }
-            finally {
-                this.cursor = savedCursor;
-                this.targetCursor = savedTargetCursor;
-            }
+    async visitRightPadded(right, p) {
+        if (!this.match)
             return right;
-        });
+        // Extract the other element if it's also a RightPadded
+        const isRightPadded = p.kind === java_1.J.Kind.RightPadded;
+        const otherWrapper = isRightPadded ? p : undefined;
+        const otherElement = isRightPadded ? otherWrapper.element : p;
+        // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new tree_2.Cursor(right, this.cursor);
+        this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
+        try {
+            // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
+            // The property context should be provided through visitRightPaddedProperty() if needed
+            await this.visitProperty(right.element, otherElement);
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+        return right;
     }
     /**
      * Override visitLeftPadded to compare only the elements, not markers or spacing.
@@ -358,30 +328,28 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * Pushes the wrapper onto the cursor stack so captures can access it.
      * Also updates targetCursor in parallel.
      */
-    visitLeftPadded(left, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return left;
-            // Extract the other element if it's also a LeftPadded
-            const isLeftPadded = p.kind === java_1.J.Kind.LeftPadded;
-            const otherWrapper = isLeftPadded ? p : undefined;
-            const otherElement = isLeftPadded ? otherWrapper.element : p;
-            // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
-            const savedCursor = this.cursor;
-            const savedTargetCursor = this.targetCursor;
-            this.cursor = new tree_2.Cursor(left, this.cursor);
-            this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
-            try {
-                // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
-                // The property context should be provided through visitLeftPaddedProperty() if needed
-                yield this.visitProperty(left.element, otherElement);
-            }
-            finally {
-                this.cursor = savedCursor;
-                this.targetCursor = savedTargetCursor;
-            }
+    async visitLeftPadded(left, p) {
+        if (!this.match)
             return left;
-        });
+        // Extract the other element if it's also a LeftPadded
+        const isLeftPadded = p.kind === java_1.J.Kind.LeftPadded;
+        const otherWrapper = isLeftPadded ? p : undefined;
+        const otherElement = isLeftPadded ? otherWrapper.element : p;
+        // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new tree_2.Cursor(left, this.cursor);
+        this.targetCursor = otherWrapper ? new tree_2.Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
+        try {
+            // Call visitProperty without propertyName to avoid pushing spurious 'element' path entries
+            // The property context should be provided through visitLeftPaddedProperty() if needed
+            await this.visitProperty(left.element, otherElement);
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+        return left;
     }
     /**
      * Override visitContainer to compare only the elements, not markers or spacing.
@@ -389,36 +357,34 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * Pushes the wrapper onto the cursor stack so captures can access it.
      * Also updates targetCursor in parallel.
      */
-    visitContainer(container, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return container;
-            // Extract the other elements if it's also a Container
-            const isContainer = p.kind === java_1.J.Kind.Container;
-            const otherContainer = isContainer ? p : undefined;
-            const otherElements = isContainer ? otherContainer.elements : p;
-            // Compare elements array length
-            if (container.elements.length !== otherElements.length) {
-                return this.arrayLengthMismatch('elements');
-            }
-            // Push wrappers onto both cursors, then compare each element
-            const savedCursor = this.cursor;
-            const savedTargetCursor = this.targetCursor;
-            this.cursor = new tree_2.Cursor(container, this.cursor);
-            this.targetCursor = otherContainer ? new tree_2.Cursor(otherContainer, this.targetCursor) : this.targetCursor;
-            try {
-                for (let i = 0; i < container.elements.length; i++) {
-                    yield this.visitProperty(container.elements[i], otherElements[i]);
-                    if (!this.match)
-                        return container;
-                }
-            }
-            finally {
-                this.cursor = savedCursor;
-                this.targetCursor = savedTargetCursor;
-            }
+    async visitContainer(container, p) {
+        if (!this.match)
             return container;
-        });
+        // Extract the other elements if it's also a Container
+        const isContainer = p.kind === java_1.J.Kind.Container;
+        const otherContainer = isContainer ? p : undefined;
+        const otherElements = isContainer ? otherContainer.elements : p;
+        // Compare elements array length
+        if (container.elements.length !== otherElements.length) {
+            return this.arrayLengthMismatch('elements');
+        }
+        // Push wrappers onto both cursors, then compare each element
+        const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
+        this.cursor = new tree_2.Cursor(container, this.cursor);
+        this.targetCursor = otherContainer ? new tree_2.Cursor(otherContainer, this.targetCursor) : this.targetCursor;
+        try {
+            for (let i = 0; i < container.elements.length; i++) {
+                await this.visitProperty(container.elements[i], otherElements[i]);
+                if (!this.match)
+                    return container;
+            }
+        }
+        finally {
+            this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
+        }
+        return container;
     }
     /**
      * Overrides the visitBinary method to compare binary expressions.
@@ -427,10 +393,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other binary expression to compare with
      * @returns The visited binary expression, or undefined if the visit was aborted
      */
-    visitBinary(binary, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(binary, other);
-        });
+    async visitBinary(binary, other) {
+        return this.visitElement(binary, other);
     }
     /**
      * Overrides the visitIdentifier method to compare identifiers.
@@ -439,10 +403,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other identifier to compare with
      * @returns The visited identifier, or undefined if the visit was aborted
      */
-    visitIdentifier(identifier, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(identifier, other);
-        });
+    async visitIdentifier(identifier, other) {
+        return this.visitElement(identifier, other);
     }
     /**
      * Overrides the visitLiteral method to compare literals.
@@ -451,10 +413,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other literal to compare with
      * @returns The visited literal, or undefined if the visit was aborted
      */
-    visitLiteral(literal, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(literal, other);
-        });
+    async visitLiteral(literal, other) {
+        return this.visitElement(literal, other);
     }
     /**
      * Overrides the visitBlock method to compare blocks.
@@ -463,10 +423,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other block to compare with
      * @returns The visited block, or undefined if the visit was aborted
      */
-    visitBlock(block, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(block, other);
-        });
+    async visitBlock(block, other) {
+        return this.visitElement(block, other);
     }
     /**
      * Overrides the visitJsCompilationUnit method to compare compilation units.
@@ -475,10 +433,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other compilation unit to compare with
      * @returns The visited compilation unit, or undefined if the visit was aborted
      */
-    visitJsCompilationUnit(compilationUnit, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(compilationUnit, other);
-        });
+    async visitJsCompilationUnit(compilationUnit, other) {
+        return this.visitElement(compilationUnit, other);
     }
     /**
      * Overrides the visitAlias method to compare aliases.
@@ -487,10 +443,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other alias to compare with
      * @returns The visited alias, or undefined if the visit was aborted
      */
-    visitAlias(alias, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(alias, other);
-        });
+    async visitAlias(alias, other) {
+        return this.visitElement(alias, other);
     }
     /**
      * Overrides the visitArrowFunction method to compare arrow functions.
@@ -499,10 +453,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other arrow function to compare with
      * @returns The visited arrow function, or undefined if the visit was aborted
      */
-    visitArrowFunction(arrowFunction, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(arrowFunction, other);
-        });
+    async visitArrowFunction(arrowFunction, other) {
+        return this.visitElement(arrowFunction, other);
     }
     /**
      * Overrides the visitAwait method to compare await expressions.
@@ -511,10 +463,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other await expression to compare with
      * @returns The visited await expression, or undefined if the visit was aborted
      */
-    visitAwait(await_, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(await_, other);
-        });
+    async visitAwait(await_, other) {
+        return this.visitElement(await_, other);
     }
     /**
      * Overrides the visitJsxTag method to compare JSX tags.
@@ -523,10 +473,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other JSX tag to compare with
      * @returns The visited JSX tag, or undefined if the visit was aborted
      */
-    visitJsxTag(element, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(element, other);
-        });
+    async visitJsxTag(element, other) {
+        return this.visitElement(element, other);
     }
     /**
      * Overrides the visitJsxAttribute method to compare JSX attributes.
@@ -535,10 +483,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other JSX attribute to compare with
      * @returns The visited JSX attribute, or undefined if the visit was aborted
      */
-    visitJsxAttribute(attribute, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(attribute, other);
-        });
+    async visitJsxAttribute(attribute, other) {
+        return this.visitElement(attribute, other);
     }
     /**
      * Overrides the visitJsxSpreadAttribute method to compare JSX spread attributes.
@@ -547,10 +493,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other JSX spread attribute to compare with
      * @returns The visited JSX spread attribute, or undefined if the visit was aborted
      */
-    visitJsxSpreadAttribute(spread, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(spread, other);
-        });
+    async visitJsxSpreadAttribute(spread, other) {
+        return this.visitElement(spread, other);
     }
     /**
      * Overrides the visitJsxExpression method to compare JSX expressions.
@@ -559,10 +503,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other JSX expression to compare with
      * @returns The visited JSX expression, or undefined if the visit was aborted
      */
-    visitJsxEmbeddedExpression(expr, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(expr, other);
-        });
+    async visitJsxEmbeddedExpression(expr, other) {
+        return this.visitElement(expr, other);
     }
     /**
      * Overrides the visitJsxNamespacedName method to compare JSX namespaced names.
@@ -571,10 +513,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other JSX namespaced name to compare with
      * @returns The visited JSX namespaced name, or undefined if the visit was aborted
      */
-    visitJsxNamespacedName(ns, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(ns, other);
-        });
+    async visitJsxNamespacedName(ns, other) {
+        return this.visitElement(ns, other);
     }
     /**
      * Overrides the visitConditionalType method to compare conditional types.
@@ -583,10 +523,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other conditional type to compare with
      * @returns The visited conditional type, or undefined if the visit was aborted
      */
-    visitConditionalType(conditionalType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(conditionalType, other);
-        });
+    async visitConditionalType(conditionalType, other) {
+        return this.visitElement(conditionalType, other);
     }
     /**
      * Overrides the visitDelete method to compare delete expressions.
@@ -595,10 +533,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other delete expression to compare with
      * @returns The visited delete expression, or undefined if the visit was aborted
      */
-    visitDelete(delete_, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(delete_, other);
-        });
+    async visitDelete(delete_, other) {
+        return this.visitElement(delete_, other);
     }
     /**
      * Overrides the visitExpressionStatement method to compare expression statements.
@@ -607,10 +543,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other expression statement to compare with
      * @returns The visited expression statement, or undefined if the visit was aborted
      */
-    visitExpressionStatement(expressionStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(expressionStatement, other);
-        });
+    async visitExpressionStatement(expressionStatement, other) {
+        return this.visitElement(expressionStatement, other);
     }
     /**
      * Overrides the visitExpressionWithTypeArguments method to compare expressions with type arguments.
@@ -619,10 +553,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other expression with type arguments to compare with
      * @returns The visited expression with type arguments, or undefined if the visit was aborted
      */
-    visitExpressionWithTypeArguments(expressionWithTypeArguments, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(expressionWithTypeArguments, other);
-        });
+    async visitExpressionWithTypeArguments(expressionWithTypeArguments, other) {
+        return this.visitElement(expressionWithTypeArguments, other);
     }
     /**
      * Overrides the visitFunctionCall method to compare method invocations.
@@ -631,10 +563,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other function call to compare with
      * @returns The visited function call, or undefined if the visit was aborted
      */
-    visitFunctionCall(functionCall, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(functionCall, other);
-        });
+    async visitFunctionCall(functionCall, other) {
+        return this.visitElement(functionCall, other);
     }
     /**
      * Overrides the visitFunctionType method to compare function types.
@@ -643,10 +573,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other function type to compare with
      * @returns The visited function type, or undefined if the visit was aborted
      */
-    visitFunctionType(functionType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(functionType, other);
-        });
+    async visitFunctionType(functionType, other) {
+        return this.visitElement(functionType, other);
     }
     /**
      * Overrides the visitInferType method to compare infer types.
@@ -655,10 +583,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other infer type to compare with
      * @returns The visited infer type, or undefined if the visit was aborted
      */
-    visitInferType(inferType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(inferType, other);
-        });
+    async visitInferType(inferType, other) {
+        return this.visitElement(inferType, other);
     }
     /**
      * Overrides the visitImportType method to compare import types.
@@ -667,10 +593,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import type to compare with
      * @returns The visited import type, or undefined if the visit was aborted
      */
-    visitImportType(importType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importType, other);
-        });
+    async visitImportType(importType, other) {
+        return this.visitElement(importType, other);
     }
     /**
      * Overrides the visitImportDeclaration method to compare import declarations.
@@ -679,10 +603,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import declaration to compare with
      * @returns The visited import declaration, or undefined if the visit was aborted
      */
-    visitImportDeclaration(jsImport, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(jsImport, other);
-        });
+    async visitImportDeclaration(jsImport, other) {
+        return this.visitElement(jsImport, other);
     }
     /**
      * Overrides the visitImportClause method to compare import clauses.
@@ -691,10 +613,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import clause to compare with
      * @returns The visited import clause, or undefined if the visit was aborted
      */
-    visitImportClause(importClause, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importClause, other);
-        });
+    async visitImportClause(importClause, other) {
+        return this.visitElement(importClause, other);
     }
     /**
      * Overrides the visitNamedImports method to compare named imports.
@@ -703,10 +623,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other named imports to compare with
      * @returns The visited named imports, or undefined if the visit was aborted
      */
-    visitNamedImports(namedImports, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(namedImports, other);
-        });
+    async visitNamedImports(namedImports, other) {
+        return this.visitElement(namedImports, other);
     }
     /**
      * Overrides the visitImportSpecifier method to compare import specifiers.
@@ -715,10 +633,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import specifier to compare with
      * @returns The visited import specifier, or undefined if the visit was aborted
      */
-    visitImportSpecifier(importSpecifier, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importSpecifier, other);
-        });
+    async visitImportSpecifier(importSpecifier, other) {
+        return this.visitElement(importSpecifier, other);
     }
     /**
      * Overrides the visitImportAttributes method to compare import attributes.
@@ -727,10 +643,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import attributes to compare with
      * @returns The visited import attributes, or undefined if the visit was aborted
      */
-    visitImportAttributes(importAttributes, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importAttributes, other);
-        });
+    async visitImportAttributes(importAttributes, other) {
+        return this.visitElement(importAttributes, other);
     }
     /**
      * Overrides the visitImportTypeAttributes method to compare import type attributes.
@@ -739,10 +653,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import type attributes to compare with
      * @returns The visited import type attributes, or undefined if the visit was aborted
      */
-    visitImportTypeAttributes(importTypeAttributes, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importTypeAttributes, other);
-        });
+    async visitImportTypeAttributes(importTypeAttributes, other) {
+        return this.visitElement(importTypeAttributes, other);
     }
     /**
      * Overrides the visitImportAttribute method to compare import attributes.
@@ -751,10 +663,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import attribute to compare with
      * @returns The visited import attribute, or undefined if the visit was aborted
      */
-    visitImportAttribute(importAttribute, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importAttribute, other);
-        });
+    async visitImportAttribute(importAttribute, other) {
+        return this.visitElement(importAttribute, other);
     }
     /**
      * Overrides the visitBinaryExtensions method to compare binary expressions.
@@ -763,10 +673,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other binary expression to compare with
      * @returns The visited binary expression, or undefined if the visit was aborted
      */
-    visitBinaryExtensions(jsBinary, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(jsBinary, other);
-        });
+    async visitBinaryExtensions(jsBinary, other) {
+        return this.visitElement(jsBinary, other);
     }
     /**
      * Overrides the visitLiteralType method to compare literal types.
@@ -775,10 +683,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other literal type to compare with
      * @returns The visited literal type, or undefined if the visit was aborted
      */
-    visitLiteralType(literalType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(literalType, other);
-        });
+    async visitLiteralType(literalType, other) {
+        return this.visitElement(literalType, other);
     }
     /**
      * Overrides the visitMappedType method to compare mapped types.
@@ -787,10 +693,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other mapped type to compare with
      * @returns The visited mapped type, or undefined if the visit was aborted
      */
-    visitMappedType(mappedType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(mappedType, other);
-        });
+    async visitMappedType(mappedType, other) {
+        return this.visitElement(mappedType, other);
     }
     /**
      * Overrides the visitKeysRemapping method to compare keys remapping.
@@ -799,10 +703,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other keys remapping to compare with
      * @returns The visited keys remapping, or undefined if the visit was aborted
      */
-    visitMappedTypeKeysRemapping(keysRemapping, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(keysRemapping, other);
-        });
+    async visitMappedTypeKeysRemapping(keysRemapping, other) {
+        return this.visitElement(keysRemapping, other);
     }
     /**
      * Overrides the visitMappedTypeParameter method to compare mapped type parameters.
@@ -811,10 +713,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other mapped type parameter to compare with
      * @returns The visited mapped type parameter, or undefined if the visit was aborted
      */
-    visitMappedTypeParameter(mappedTypeParameter, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(mappedTypeParameter, other);
-        });
+    async visitMappedTypeParameter(mappedTypeParameter, other) {
+        return this.visitElement(mappedTypeParameter, other);
     }
     /**
      * Overrides the visitObjectBindingPattern method to compare object binding declarations.
@@ -823,10 +723,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other object binding declarations to compare with
      * @returns The visited object binding declarations, or undefined if the visit was aborted
      */
-    visitObjectBindingPattern(objectBindingPattern, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(objectBindingPattern, other);
-        });
+    async visitObjectBindingPattern(objectBindingPattern, other) {
+        return this.visitElement(objectBindingPattern, other);
     }
     /**
      * Overrides the visitPropertyAssignment method to compare property assignments.
@@ -835,10 +733,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other property assignment to compare with
      * @returns The visited property assignment, or undefined if the visit was aborted
      */
-    visitPropertyAssignment(propertyAssignment, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(propertyAssignment, other);
-        });
+    async visitPropertyAssignment(propertyAssignment, other) {
+        return this.visitElement(propertyAssignment, other);
     }
     /**
      * Overrides the visitSatisfiesExpression method to compare satisfies expressions.
@@ -847,10 +743,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other satisfies expression to compare with
      * @returns The visited satisfies expression, or undefined if the visit was aborted
      */
-    visitSatisfiesExpression(satisfiesExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(satisfiesExpression, other);
-        });
+    async visitSatisfiesExpression(satisfiesExpression, other) {
+        return this.visitElement(satisfiesExpression, other);
     }
     /**
      * Overrides the visitScopedVariableDeclarations method to compare scoped variable declarations.
@@ -859,10 +753,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other scoped variable declarations to compare with
      * @returns The visited scoped variable declarations, or undefined if the visit was aborted
      */
-    visitScopedVariableDeclarations(scopedVariableDeclarations, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(scopedVariableDeclarations, other);
-        });
+    async visitScopedVariableDeclarations(scopedVariableDeclarations, other) {
+        return this.visitElement(scopedVariableDeclarations, other);
     }
     /**
      * Overrides the visitShebang method to compare shebangs.
@@ -871,10 +763,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other shebang to compare with
      * @returns The visited shebang, or undefined if the visit was aborted
      */
-    visitShebang(shebang, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(shebang, other);
-        });
+    async visitShebang(shebang, other) {
+        return this.visitElement(shebang, other);
     }
     /**
      * Overrides the visitSpread method to compare spread expressions.
@@ -883,10 +773,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other spread expression to compare with
      * @returns The visited spread expression, or undefined if the visit was aborted
      */
-    visitSpread(spread, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(spread, other);
-        });
+    async visitSpread(spread, other) {
+        return this.visitElement(spread, other);
     }
     /**
      * Overrides the visitStatementExpression method to compare statement expressions.
@@ -895,10 +783,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other statement expression to compare with
      * @returns The visited statement expression, or undefined if the visit was aborted
      */
-    visitStatementExpression(statementExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(statementExpression, other);
-        });
+    async visitStatementExpression(statementExpression, other) {
+        return this.visitElement(statementExpression, other);
     }
     /**
      * Overrides the visitTaggedTemplateExpression method to compare tagged template expressions.
@@ -907,10 +793,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other tagged template expression to compare with
      * @returns The visited tagged template expression, or undefined if the visit was aborted
      */
-    visitTaggedTemplateExpression(taggedTemplateExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(taggedTemplateExpression, other);
-        });
+    async visitTaggedTemplateExpression(taggedTemplateExpression, other) {
+        return this.visitElement(taggedTemplateExpression, other);
     }
     /**
      * Overrides the visitTemplateExpression method to compare template expressions.
@@ -919,10 +803,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other template expression to compare with
      * @returns The visited template expression, or undefined if the visit was aborted
      */
-    visitTemplateExpression(templateExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(templateExpression, other);
-        });
+    async visitTemplateExpression(templateExpression, other) {
+        return this.visitElement(templateExpression, other);
     }
     /**
      * Overrides the visitTemplateExpressionSpan method to compare template expression spans.
@@ -931,10 +813,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other template expression span to compare with
      * @returns The visited template expression span, or undefined if the visit was aborted
      */
-    visitTemplateExpressionSpan(span, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(span, other);
-        });
+    async visitTemplateExpressionSpan(span, other) {
+        return this.visitElement(span, other);
     }
     /**
      * Overrides the visitTuple method to compare tuples.
@@ -943,10 +823,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other tuple to compare with
      * @returns The visited tuple, or undefined if the visit was aborted
      */
-    visitTuple(tuple, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(tuple, other);
-        });
+    async visitTuple(tuple, other) {
+        return this.visitElement(tuple, other);
     }
     /**
      * Overrides the visitTypeDeclaration method to compare type declarations.
@@ -955,10 +833,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type declaration to compare with
      * @returns The visited type declaration, or undefined if the visit was aborted
      */
-    visitTypeDeclaration(typeDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeDeclaration, other);
-        });
+    async visitTypeDeclaration(typeDeclaration, other) {
+        return this.visitElement(typeDeclaration, other);
     }
     /**
      * Overrides the visitTypeOf method to compare typeof expressions.
@@ -967,10 +843,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other typeof expression to compare with
      * @returns The visited typeof expression, or undefined if the visit was aborted
      */
-    visitTypeOf(typeOf, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeOf, other);
-        });
+    async visitTypeOf(typeOf, other) {
+        return this.visitElement(typeOf, other);
     }
     /**
      * Overrides the visitTypeTreeExpression method to compare type tree expressions.
@@ -979,10 +853,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type tree expression to compare with
      * @returns The visited type tree expression, or undefined if the visit was aborted
      */
-    visitTypeTreeExpression(typeTreeExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeTreeExpression, other);
-        });
+    async visitTypeTreeExpression(typeTreeExpression, other) {
+        return this.visitElement(typeTreeExpression, other);
     }
     /**
      * Overrides the visitAs method to compare as expressions.
@@ -991,10 +863,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other as expression to compare with
      * @returns The visited as expression, or undefined if the visit was aborted
      */
-    visitAs(as_, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(as_, other);
-        });
+    async visitAs(as_, other) {
+        return this.visitElement(as_, other);
     }
     /**
      * Overrides the visitAssignmentOperationExtensions method to compare assignment operations.
@@ -1003,10 +873,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other assignment operation to compare with
      * @returns The visited assignment operation, or undefined if the visit was aborted
      */
-    visitAssignmentOperationExtensions(assignmentOperation, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(assignmentOperation, other);
-        });
+    async visitAssignmentOperationExtensions(assignmentOperation, other) {
+        return this.visitElement(assignmentOperation, other);
     }
     /**
      * Overrides the visitIndexedAccessType method to compare indexed access types.
@@ -1015,10 +883,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other indexed access type to compare with
      * @returns The visited indexed access type, or undefined if the visit was aborted
      */
-    visitIndexedAccessType(indexedAccessType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(indexedAccessType, other);
-        });
+    async visitIndexedAccessType(indexedAccessType, other) {
+        return this.visitElement(indexedAccessType, other);
     }
     /**
      * Overrides the visitIndexType method to compare index types.
@@ -1027,10 +893,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other index type to compare with
      * @returns The visited index type, or undefined if the visit was aborted
      */
-    visitIndexedAccessTypeIndexType(indexType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(indexType, other);
-        });
+    async visitIndexedAccessTypeIndexType(indexType, other) {
+        return this.visitElement(indexType, other);
     }
     /**
      * Overrides the visitTypeQuery method to compare type queries.
@@ -1039,10 +903,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type query to compare with
      * @returns The visited type query, or undefined if the visit was aborted
      */
-    visitTypeQuery(typeQuery, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeQuery, other);
-        });
+    async visitTypeQuery(typeQuery, other) {
+        return this.visitElement(typeQuery, other);
     }
     /**
      * Overrides the visitTypeInfo method to compare type info.
@@ -1051,10 +913,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type info to compare with
      * @returns The visited type info, or undefined if the visit was aborted
      */
-    visitTypeInfo(typeInfo, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeInfo, other);
-        });
+    async visitTypeInfo(typeInfo, other) {
+        return this.visitElement(typeInfo, other);
     }
     /**
      * Overrides the visitComputedPropertyName method to compare computed property names.
@@ -1063,10 +923,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other computed property name to compare with
      * @returns The visited computed property name, or undefined if the visit was aborted
      */
-    visitComputedPropertyName(computedPropertyName, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(computedPropertyName, other);
-        });
+    async visitComputedPropertyName(computedPropertyName, other) {
+        return this.visitElement(computedPropertyName, other);
     }
     /**
      * Overrides the visitTypeOperator method to compare type operators.
@@ -1075,10 +933,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type operator to compare with
      * @returns The visited type operator, or undefined if the visit was aborted
      */
-    visitTypeOperator(typeOperator, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeOperator, other);
-        });
+    async visitTypeOperator(typeOperator, other) {
+        return this.visitElement(typeOperator, other);
     }
     /**
      * Overrides the visitTypePredicate method to compare type predicates.
@@ -1087,10 +943,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type predicate to compare with
      * @returns The visited type predicate, or undefined if the visit was aborted
      */
-    visitTypePredicate(typePredicate, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typePredicate, other);
-        });
+    async visitTypePredicate(typePredicate, other) {
+        return this.visitElement(typePredicate, other);
     }
     /**
      * Overrides the visitUnion method to compare unions.
@@ -1099,10 +953,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other union to compare with
      * @returns The visited union, or undefined if the visit was aborted
      */
-    visitUnion(union, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(union, other);
-        });
+    async visitUnion(union, other) {
+        return this.visitElement(union, other);
     }
     /**
      * Overrides the visitIntersection method to compare intersections.
@@ -1111,10 +963,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other intersection to compare with
      * @returns The visited intersection, or undefined if the visit was aborted
      */
-    visitIntersection(intersection, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(intersection, other);
-        });
+    async visitIntersection(intersection, other) {
+        return this.visitElement(intersection, other);
     }
     /**
      * Overrides the visitAnnotatedType method to compare annotated types.
@@ -1123,10 +973,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other annotated type to compare with
      * @returns The visited annotated type, or undefined if the visit was aborted
      */
-    visitAnnotatedType(annotatedType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(annotatedType, other);
-        });
+    async visitAnnotatedType(annotatedType, other) {
+        return this.visitElement(annotatedType, other);
     }
     /**
      * Overrides the visitAnnotation method to compare annotations.
@@ -1135,10 +983,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other annotation to compare with
      * @returns The visited annotation, or undefined if the visit was aborted
      */
-    visitAnnotation(annotation, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(annotation, other);
-        });
+    async visitAnnotation(annotation, other) {
+        return this.visitElement(annotation, other);
     }
     /**
      * Overrides the visitArrayAccess method to compare array access expressions.
@@ -1147,10 +993,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other array access expression to compare with
      * @returns The visited array access expression, or undefined if the visit was aborted
      */
-    visitArrayAccess(arrayAccess, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(arrayAccess, other);
-        });
+    async visitArrayAccess(arrayAccess, other) {
+        return this.visitElement(arrayAccess, other);
     }
     /**
      * Overrides the visitArrayDimension method to compare array dimensions.
@@ -1159,10 +1003,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other array dimension to compare with
      * @returns The visited array dimension, or undefined if the visit was aborted
      */
-    visitArrayDimension(arrayDimension, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(arrayDimension, other);
-        });
+    async visitArrayDimension(arrayDimension, other) {
+        return this.visitElement(arrayDimension, other);
     }
     /**
      * Overrides the visitArrayType method to compare array types.
@@ -1171,10 +1013,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other array type to compare with
      * @returns The visited array type, or undefined if the visit was aborted
      */
-    visitArrayType(arrayType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(arrayType, other);
-        });
+    async visitArrayType(arrayType, other) {
+        return this.visitElement(arrayType, other);
     }
     /**
      * Overrides the visitAssert method to compare assert statements.
@@ -1183,10 +1023,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other assert statement to compare with
      * @returns The visited assert statement, or undefined if the visit was aborted
      */
-    visitAssert(anAssert, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(anAssert, other);
-        });
+    async visitAssert(anAssert, other) {
+        return this.visitElement(anAssert, other);
     }
     /**
      * Overrides the visitAssignment method to compare assignment expressions.
@@ -1195,10 +1033,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other assignment expression to compare with
      * @returns The visited assignment expression, or undefined if the visit was aborted
      */
-    visitAssignment(assignment, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(assignment, other);
-        });
+    async visitAssignment(assignment, other) {
+        return this.visitElement(assignment, other);
     }
     /**
      * Overrides the visitAssignmentOperation method to compare assignment operation expressions.
@@ -1207,10 +1043,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other assignment operation expression to compare with
      * @returns The visited assignment operation expression, or undefined if the visit was aborted
      */
-    visitAssignmentOperation(assignOp, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(assignOp, other);
-        });
+    async visitAssignmentOperation(assignOp, other) {
+        return this.visitElement(assignOp, other);
     }
     /**
      * Overrides the visitBreak method to compare break statements.
@@ -1219,10 +1053,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other break statement to compare with
      * @returns The visited break statement, or undefined if the visit was aborted
      */
-    visitBreak(breakStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(breakStatement, other);
-        });
+    async visitBreak(breakStatement, other) {
+        return this.visitElement(breakStatement, other);
     }
     /**
      * Overrides the visitCase method to compare case statements.
@@ -1231,10 +1063,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other case statement to compare with
      * @returns The visited case statement, or undefined if the visit was aborted
      */
-    visitCase(aCase, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(aCase, other);
-        });
+    async visitCase(aCase, other) {
+        return this.visitElement(aCase, other);
     }
     /**
      * Overrides the visitClassDeclaration method to compare class declarations.
@@ -1243,10 +1073,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other class declaration to compare with
      * @returns The visited class declaration, or undefined if the visit was aborted
      */
-    visitClassDeclaration(classDecl, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(classDecl, other);
-        });
+    async visitClassDeclaration(classDecl, other) {
+        return this.visitElement(classDecl, other);
     }
     /**
      * Overrides the visitClassDeclarationKind method to compare class declaration kinds.
@@ -1255,10 +1083,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other class declaration kind to compare with
      * @returns The visited class declaration kind, or undefined if the visit was aborted
      */
-    visitClassDeclarationKind(kind, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(kind, other);
-        });
+    async visitClassDeclarationKind(kind, other) {
+        return this.visitElement(kind, other);
     }
     /**
      * Overrides the visitCompilationUnit method to compare compilation units.
@@ -1267,10 +1093,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other compilation unit to compare with
      * @returns The visited compilation unit, or undefined if the visit was aborted
      */
-    visitCompilationUnit(compilationUnit, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(compilationUnit, other);
-        });
+    async visitCompilationUnit(compilationUnit, other) {
+        return this.visitElement(compilationUnit, other);
     }
     /**
      * Overrides the visitContinue method to compare continue statements.
@@ -1279,10 +1103,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other continue statement to compare with
      * @returns The visited continue statement, or undefined if the visit was aborted
      */
-    visitContinue(continueStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(continueStatement, other);
-        });
+    async visitContinue(continueStatement, other) {
+        return this.visitElement(continueStatement, other);
     }
     /**
      * Overrides the visitControlParentheses method to compare control parentheses.
@@ -1291,10 +1113,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other control parentheses to compare with
      * @returns The visited control parentheses, or undefined if the visit was aborted
      */
-    visitControlParentheses(controlParens, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(controlParens, other);
-        });
+    async visitControlParentheses(controlParens, other) {
+        return this.visitElement(controlParens, other);
     }
     /**
      * Overrides the visitDeconstructionPattern method to compare deconstruction patterns.
@@ -1303,10 +1123,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other deconstruction pattern to compare with
      * @returns The visited deconstruction pattern, or undefined if the visit was aborted
      */
-    visitDeconstructionPattern(pattern, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(pattern, other);
-        });
+    async visitDeconstructionPattern(pattern, other) {
+        return this.visitElement(pattern, other);
     }
     /**
      * Overrides the visitDoWhileLoop method to compare do-while loops.
@@ -1315,10 +1133,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other do-while loop to compare with
      * @returns The visited do-while loop, or undefined if the visit was aborted
      */
-    visitDoWhileLoop(doWhileLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(doWhileLoop, other);
-        });
+    async visitDoWhileLoop(doWhileLoop, other) {
+        return this.visitElement(doWhileLoop, other);
     }
     /**
      * Overrides the visitEmpty method to compare empty statements.
@@ -1327,10 +1143,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other empty statement to compare with
      * @returns The visited empty statement, or undefined if the visit was aborted
      */
-    visitEmpty(empty, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(empty, other);
-        });
+    async visitEmpty(empty, other) {
+        return this.visitElement(empty, other);
     }
     /**
      * Overrides the visitEnumValue method to compare enum values.
@@ -1339,10 +1153,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other enum value to compare with
      * @returns The visited enum value, or undefined if the visit was aborted
      */
-    visitEnumValue(enumValue, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(enumValue, other);
-        });
+    async visitEnumValue(enumValue, other) {
+        return this.visitElement(enumValue, other);
     }
     /**
      * Overrides the visitEnumValueSet method to compare enum value sets.
@@ -1351,10 +1163,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other enum value set to compare with
      * @returns The visited enum value set, or undefined if the visit was aborted
      */
-    visitEnumValueSet(enumValueSet, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(enumValueSet, other);
-        });
+    async visitEnumValueSet(enumValueSet, other) {
+        return this.visitElement(enumValueSet, other);
     }
     /**
      * Overrides the visitErroneous method to compare erroneous nodes.
@@ -1363,10 +1173,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other erroneous node to compare with
      * @returns The visited erroneous node, or undefined if the visit was aborted
      */
-    visitErroneous(erroneous, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(erroneous, other);
-        });
+    async visitErroneous(erroneous, other) {
+        return this.visitElement(erroneous, other);
     }
     /**
      * Overrides the visitFieldAccess method to compare field access expressions.
@@ -1375,10 +1183,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other field access expression to compare with
      * @returns The visited field access expression, or undefined if the visit was aborted
      */
-    visitFieldAccess(fieldAccess, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(fieldAccess, other);
-        });
+    async visitFieldAccess(fieldAccess, other) {
+        return this.visitElement(fieldAccess, other);
     }
     /**
      * Overrides the visitForEachLoop method to compare for-each loops.
@@ -1387,10 +1193,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for-each loop to compare with
      * @returns The visited for-each loop, or undefined if the visit was aborted
      */
-    visitForEachLoop(forEachLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(forEachLoop, other);
-        });
+    async visitForEachLoop(forEachLoop, other) {
+        return this.visitElement(forEachLoop, other);
     }
     /**
      * Overrides the visitForEachLoopControl method to compare for-each loop controls.
@@ -1399,10 +1203,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for-each loop control to compare with
      * @returns The visited for-each loop control, or undefined if the visit was aborted
      */
-    visitForEachLoopControl(control, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(control, other);
-        });
+    async visitForEachLoopControl(control, other) {
+        return this.visitElement(control, other);
     }
     /**
      * Overrides the visitForLoop method to compare for loops.
@@ -1411,10 +1213,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for loop to compare with
      * @returns The visited for loop, or undefined if the visit was aborted
      */
-    visitForLoop(forLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(forLoop, other);
-        });
+    async visitForLoop(forLoop, other) {
+        return this.visitElement(forLoop, other);
     }
     /**
      * Overrides the visitForLoopControl method to compare for loop controls.
@@ -1423,10 +1223,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for loop control to compare with
      * @returns The visited for loop control, or undefined if the visit was aborted
      */
-    visitForLoopControl(control, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(control, other);
-        });
+    async visitForLoopControl(control, other) {
+        return this.visitElement(control, other);
     }
     /**
      * Overrides the visitIf method to compare if statements.
@@ -1435,10 +1233,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other if statement to compare with
      * @returns The visited if statement, or undefined if the visit was aborted
      */
-    visitIf(ifStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(ifStatement, other);
-        });
+    async visitIf(ifStatement, other) {
+        return this.visitElement(ifStatement, other);
     }
     /**
      * Overrides the visitElse method to compare else statements.
@@ -1447,10 +1243,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other else statement to compare with
      * @returns The visited else statement, or undefined if the visit was aborted
      */
-    visitElse(elseStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(elseStatement, other);
-        });
+    async visitElse(elseStatement, other) {
+        return this.visitElement(elseStatement, other);
     }
     /**
      * Overrides the visitImport method to compare import statements.
@@ -1459,10 +1253,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other import statement to compare with
      * @returns The visited import statement, or undefined if the visit was aborted
      */
-    visitImport(importStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(importStatement, other);
-        });
+    async visitImport(importStatement, other) {
+        return this.visitElement(importStatement, other);
     }
     /**
      * Overrides the visitInstanceOf method to compare instanceof expressions.
@@ -1471,10 +1263,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other instanceof expression to compare with
      * @returns The visited instanceof expression, or undefined if the visit was aborted
      */
-    visitInstanceOf(instanceOf, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(instanceOf, other);
-        });
+    async visitInstanceOf(instanceOf, other) {
+        return this.visitElement(instanceOf, other);
     }
     /**
      * Overrides the visitIntersectionType method to compare intersection types.
@@ -1483,10 +1273,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other intersection type to compare with
      * @returns The visited intersection type, or undefined if the visit was aborted
      */
-    visitIntersectionType(intersectionType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(intersectionType, other);
-        });
+    async visitIntersectionType(intersectionType, other) {
+        return this.visitElement(intersectionType, other);
     }
     /**
      * Overrides the visitLabel method to compare label statements.
@@ -1495,10 +1283,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other label statement to compare with
      * @returns The visited label statement, or undefined if the visit was aborted
      */
-    visitLabel(label, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(label, other);
-        });
+    async visitLabel(label, other) {
+        return this.visitElement(label, other);
     }
     /**
      * Overrides the visitLambda method to compare lambda expressions.
@@ -1507,10 +1293,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other lambda expression to compare with
      * @returns The visited lambda expression, or undefined if the visit was aborted
      */
-    visitLambda(lambda, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(lambda, other);
-        });
+    async visitLambda(lambda, other) {
+        return this.visitElement(lambda, other);
     }
     /**
      * Overrides the visitLambdaParameters method to compare lambda parameters.
@@ -1519,10 +1303,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other lambda parameters to compare with
      * @returns The visited lambda parameters, or undefined if the visit was aborted
      */
-    visitLambdaParameters(parameters, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(parameters, other);
-        });
+    async visitLambdaParameters(parameters, other) {
+        return this.visitElement(parameters, other);
     }
     /**
      * Overrides the visitMemberReference method to compare member references.
@@ -1531,10 +1313,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other member reference to compare with
      * @returns The visited member reference, or undefined if the visit was aborted
      */
-    visitMemberReference(memberReference, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(memberReference, other);
-        });
+    async visitMemberReference(memberReference, other) {
+        return this.visitElement(memberReference, other);
     }
     /**
      * Overrides the visitMethodDeclaration method to compare method declarations.
@@ -1543,10 +1323,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other method declaration to compare with
      * @returns The visited method declaration, or undefined if the visit was aborted
      */
-    visitMethodDeclaration(methodDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(methodDeclaration, other);
-        });
+    async visitMethodDeclaration(methodDeclaration, other) {
+        return this.visitElement(methodDeclaration, other);
     }
     /**
      * Overrides the visitMethodInvocation method to compare method invocations.
@@ -1555,10 +1333,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other method invocation to compare with
      * @returns The visited method invocation, or undefined if the visit was aborted
      */
-    visitMethodInvocation(methodInvocation, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(methodInvocation, other);
-        });
+    async visitMethodInvocation(methodInvocation, other) {
+        return this.visitElement(methodInvocation, other);
     }
     /**
      * Overrides the visitModifier method to compare modifiers.
@@ -1567,10 +1343,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other modifier to compare with
      * @returns The visited modifier, or undefined if the visit was aborted
      */
-    visitModifier(modifier, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(modifier, other);
-        });
+    async visitModifier(modifier, other) {
+        return this.visitElement(modifier, other);
     }
     /**
      * Overrides the visitMultiCatch method to compare multi-catch expressions.
@@ -1579,10 +1353,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other multi-catch expression to compare with
      * @returns The visited multi-catch expression, or undefined if the visit was aborted
      */
-    visitMultiCatch(multiCatch, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(multiCatch, other);
-        });
+    async visitMultiCatch(multiCatch, other) {
+        return this.visitElement(multiCatch, other);
     }
     /**
      * Overrides the visitNewArray method to compare new array expressions.
@@ -1591,10 +1363,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other new array expression to compare with
      * @returns The visited new array expression, or undefined if the visit was aborted
      */
-    visitNewArray(newArray, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(newArray, other);
-        });
+    async visitNewArray(newArray, other) {
+        return this.visitElement(newArray, other);
     }
     /**
      * Overrides the visitNewClass method to compare new class expressions.
@@ -1603,10 +1373,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other new class expression to compare with
      * @returns The visited new class expression, or undefined if the visit was aborted
      */
-    visitNewClass(newClass, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(newClass, other);
-        });
+    async visitNewClass(newClass, other) {
+        return this.visitElement(newClass, other);
     }
     /**
      * Overrides the visitNullableType method to compare nullable types.
@@ -1615,10 +1383,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other nullable type to compare with
      * @returns The visited nullable type, or undefined if the visit was aborted
      */
-    visitNullableType(nullableType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(nullableType, other);
-        });
+    async visitNullableType(nullableType, other) {
+        return this.visitElement(nullableType, other);
     }
     /**
      * Overrides the visitPackage method to compare package declarations.
@@ -1627,10 +1393,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other package declaration to compare with
      * @returns The visited package declaration, or undefined if the visit was aborted
      */
-    visitPackage(packageDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(packageDeclaration, other);
-        });
+    async visitPackage(packageDeclaration, other) {
+        return this.visitElement(packageDeclaration, other);
     }
     /**
      * Overrides the visitParameterizedType method to compare parameterized types.
@@ -1639,10 +1403,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other parameterized type to compare with
      * @returns The visited parameterized type, or undefined if the visit was aborted
      */
-    visitParameterizedType(parameterizedType, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(parameterizedType, other);
-        });
+    async visitParameterizedType(parameterizedType, other) {
+        return this.visitElement(parameterizedType, other);
     }
     /**
      * Overrides the visitParentheses method to compare parentheses expressions.
@@ -1651,10 +1413,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other parentheses expression to compare with
      * @returns The visited parentheses expression, or undefined if the visit was aborted
      */
-    visitParentheses(parentheses, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(parentheses, other);
-        });
+    async visitParentheses(parentheses, other) {
+        return this.visitElement(parentheses, other);
     }
     /**
      * Overrides the visitParenthesizedTypeTree method to compare parenthesized type trees.
@@ -1663,10 +1423,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other parenthesized type tree to compare with
      * @returns The visited parenthesized type tree, or undefined if the visit was aborted
      */
-    visitParenthesizedTypeTree(parenthesizedTypeTree, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(parenthesizedTypeTree, other);
-        });
+    async visitParenthesizedTypeTree(parenthesizedTypeTree, other) {
+        return this.visitElement(parenthesizedTypeTree, other);
     }
     /**
      * Overrides the visitPrimitive method to compare primitive types.
@@ -1675,10 +1433,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other primitive type to compare with
      * @returns The visited primitive type, or undefined if the visit was aborted
      */
-    visitPrimitive(primitive, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(primitive, other);
-        });
+    async visitPrimitive(primitive, other) {
+        return this.visitElement(primitive, other);
     }
     /**
      * Overrides the visitReturn method to compare return statements.
@@ -1687,10 +1443,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other return statement to compare with
      * @returns The visited return statement, or undefined if the visit was aborted
      */
-    visitReturn(returnStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(returnStatement, other);
-        });
+    async visitReturn(returnStatement, other) {
+        return this.visitElement(returnStatement, other);
     }
     /**
      * Overrides the visitSwitch method to compare switch statements.
@@ -1699,10 +1453,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other switch statement to compare with
      * @returns The visited switch statement, or undefined if the visit was aborted
      */
-    visitSwitch(switchStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(switchStatement, other);
-        });
+    async visitSwitch(switchStatement, other) {
+        return this.visitElement(switchStatement, other);
     }
     /**
      * Overrides the visitSwitchExpression method to compare switch expressions.
@@ -1711,10 +1463,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other switch expression to compare with
      * @returns The visited switch expression, or undefined if the visit was aborted
      */
-    visitSwitchExpression(switchExpression, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(switchExpression, other);
-        });
+    async visitSwitchExpression(switchExpression, other) {
+        return this.visitElement(switchExpression, other);
     }
     /**
      * Overrides the visitSynchronized method to compare synchronized statements.
@@ -1723,10 +1473,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other synchronized statement to compare with
      * @returns The visited synchronized statement, or undefined if the visit was aborted
      */
-    visitSynchronized(synchronizedStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(synchronizedStatement, other);
-        });
+    async visitSynchronized(synchronizedStatement, other) {
+        return this.visitElement(synchronizedStatement, other);
     }
     /**
      * Overrides the visitTernary method to compare ternary expressions.
@@ -1735,10 +1483,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other ternary expression to compare with
      * @returns The visited ternary expression, or undefined if the visit was aborted
      */
-    visitTernary(ternary, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(ternary, other);
-        });
+    async visitTernary(ternary, other) {
+        return this.visitElement(ternary, other);
     }
     /**
      * Overrides the visitThrow method to compare throw statements.
@@ -1747,10 +1493,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other throw statement to compare with
      * @returns The visited throw statement, or undefined if the visit was aborted
      */
-    visitThrow(throwStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(throwStatement, other);
-        });
+    async visitThrow(throwStatement, other) {
+        return this.visitElement(throwStatement, other);
     }
     /**
      * Overrides the visitTry method to compare try statements.
@@ -1759,10 +1503,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other try statement to compare with
      * @returns The visited try statement, or undefined if the visit was aborted
      */
-    visitTry(tryStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(tryStatement, other);
-        });
+    async visitTry(tryStatement, other) {
+        return this.visitElement(tryStatement, other);
     }
     /**
      * Overrides the visitTryResource method to compare try resources.
@@ -1771,10 +1513,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other try resource to compare with
      * @returns The visited try resource, or undefined if the visit was aborted
      */
-    visitTryResource(resource, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(resource, other);
-        });
+    async visitTryResource(resource, other) {
+        return this.visitElement(resource, other);
     }
     /**
      * Overrides the visitTryCatch method to compare try catch blocks.
@@ -1783,10 +1523,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other try catch block to compare with
      * @returns The visited try catch block, or undefined if the visit was aborted
      */
-    visitTryCatch(tryCatch, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(tryCatch, other);
-        });
+    async visitTryCatch(tryCatch, other) {
+        return this.visitElement(tryCatch, other);
     }
     /**
      * Overrides the visitTypeCast method to compare type cast expressions.
@@ -1795,10 +1533,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type cast expression to compare with
      * @returns The visited type cast expression, or undefined if the visit was aborted
      */
-    visitTypeCast(typeCast, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeCast, other);
-        });
+    async visitTypeCast(typeCast, other) {
+        return this.visitElement(typeCast, other);
     }
     /**
      * Overrides the visitTypeParameter method to compare type parameters.
@@ -1807,10 +1543,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type parameter to compare with
      * @returns The visited type parameter, or undefined if the visit was aborted
      */
-    visitTypeParameter(typeParameter, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeParameter, other);
-        });
+    async visitTypeParameter(typeParameter, other) {
+        return this.visitElement(typeParameter, other);
     }
     /**
      * Overrides the visitTypeParameters method to compare type parameters.
@@ -1819,10 +1553,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type parameters to compare with
      * @returns The visited type parameters, or undefined if the visit was aborted
      */
-    visitTypeParameters(typeParameters, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeParameters, other);
-        });
+    async visitTypeParameters(typeParameters, other) {
+        return this.visitElement(typeParameters, other);
     }
     /**
      * Overrides the visitUnary method to compare unary expressions.
@@ -1831,10 +1563,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other unary expression to compare with
      * @returns The visited unary expression, or undefined if the visit was aborted
      */
-    visitUnary(unary, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(unary, other);
-        });
+    async visitUnary(unary, other) {
+        return this.visitElement(unary, other);
     }
     /**
      * Overrides the visitUnknown method to compare unknown nodes.
@@ -1843,10 +1573,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other unknown node to compare with
      * @returns The visited unknown node, or undefined if the visit was aborted
      */
-    visitUnknown(unknown, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(unknown, other);
-        });
+    async visitUnknown(unknown, other) {
+        return this.visitElement(unknown, other);
     }
     /**
      * Overrides the visitUnknownSource method to compare unknown sources.
@@ -1855,10 +1583,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other unknown source to compare with
      * @returns The visited unknown source, or undefined if the visit was aborted
      */
-    visitUnknownSource(unknownSource, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(unknownSource, other);
-        });
+    async visitUnknownSource(unknownSource, other) {
+        return this.visitElement(unknownSource, other);
     }
     /**
      * Overrides the visitVariableDeclarations method to compare variable declarations.
@@ -1867,10 +1593,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other variable declarations to compare with
      * @returns The visited variable declarations, or undefined if the visit was aborted
      */
-    visitVariableDeclarations(variableDeclarations, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(variableDeclarations, other);
-        });
+    async visitVariableDeclarations(variableDeclarations, other) {
+        return this.visitElement(variableDeclarations, other);
     }
     /**
      * Overrides the visitVariable method to compare variable declarations.
@@ -1879,10 +1603,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other variable declaration to compare with
      * @returns The visited variable declaration, or undefined if the visit was aborted
      */
-    visitVariable(variable, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(variable, other);
-        });
+    async visitVariable(variable, other) {
+        return this.visitElement(variable, other);
     }
     /**
      * Overrides the visitWhileLoop method to compare while loops.
@@ -1891,10 +1613,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other while loop to compare with
      * @returns The visited while loop, or undefined if the visit was aborted
      */
-    visitWhileLoop(whileLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(whileLoop, other);
-        });
+    async visitWhileLoop(whileLoop, other) {
+        return this.visitElement(whileLoop, other);
     }
     /**
      * Overrides the visitWildcard method to compare wildcards.
@@ -1903,10 +1623,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other wildcard to compare with
      * @returns The visited wildcard, or undefined if the visit was aborted
      */
-    visitWildcard(wildcard, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(wildcard, other);
-        });
+    async visitWildcard(wildcard, other) {
+        return this.visitElement(wildcard, other);
     }
     /**
      * Overrides the visitYield method to compare yield statements.
@@ -1915,10 +1633,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other yield statement to compare with
      * @returns The visited yield statement, or undefined if the visit was aborted
      */
-    visitYield(yieldStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(yieldStatement, other);
-        });
+    async visitYield(yieldStatement, other) {
+        return this.visitElement(yieldStatement, other);
     }
     /**
      * Overrides the visitVoid method to compare void expressions.
@@ -1927,10 +1643,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other void expression to compare with
      * @returns The visited void expression, or undefined if the visit was aborted
      */
-    visitVoid(void_, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(void_, other);
-        });
+    async visitVoid(void_, other) {
+        return this.visitElement(void_, other);
     }
     /**
      * Overrides the visitWithStatement method to compare with statements.
@@ -1939,10 +1653,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other with statement to compare with
      * @returns The visited with statement, or undefined if the visit was aborted
      */
-    visitWithStatement(withStatement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(withStatement, other);
-        });
+    async visitWithStatement(withStatement, other) {
+        return this.visitElement(withStatement, other);
     }
     /**
      * Overrides the visitIndexSignatureDeclaration method to compare index signature declarations.
@@ -1951,10 +1663,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other index signature declaration to compare with
      * @returns The visited index signature declaration, or undefined if the visit was aborted
      */
-    visitIndexSignatureDeclaration(indexSignatureDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(indexSignatureDeclaration, other);
-        });
+    async visitIndexSignatureDeclaration(indexSignatureDeclaration, other) {
+        return this.visitElement(indexSignatureDeclaration, other);
     }
     /**
      * Overrides the visitForOfLoop method to compare for-of loops.
@@ -1963,10 +1673,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for-of loop to compare with
      * @returns The visited for-of loop, or undefined if the visit was aborted
      */
-    visitForOfLoop(forOfLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(forOfLoop, other);
-        });
+    async visitForOfLoop(forOfLoop, other) {
+        return this.visitElement(forOfLoop, other);
     }
     /**
      * Overrides the visitForInLoop method to compare for-in loops.
@@ -1975,10 +1683,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other for-in loop to compare with
      * @returns The visited for-in loop, or undefined if the visit was aborted
      */
-    visitForInLoop(forInLoop, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(forInLoop, other);
-        });
+    async visitForInLoop(forInLoop, other) {
+        return this.visitElement(forInLoop, other);
     }
     /**
      * Overrides the visitNamespaceDeclaration method to compare namespace declarations.
@@ -1987,10 +1693,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other namespace declaration to compare with
      * @returns The visited namespace declaration, or undefined if the visit was aborted
      */
-    visitNamespaceDeclaration(namespaceDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(namespaceDeclaration, other);
-        });
+    async visitNamespaceDeclaration(namespaceDeclaration, other) {
+        return this.visitElement(namespaceDeclaration, other);
     }
     /**
      * Overrides the visitTypeLiteral method to compare type literals.
@@ -1999,10 +1703,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other type literal to compare with
      * @returns The visited type literal, or undefined if the visit was aborted
      */
-    visitTypeLiteral(typeLiteral, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(typeLiteral, other);
-        });
+    async visitTypeLiteral(typeLiteral, other) {
+        return this.visitElement(typeLiteral, other);
     }
     /**
      * Overrides the visitBindingElement method to compare binding elements.
@@ -2011,10 +1713,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other binding element to compare with
      * @returns The visited binding element, or undefined if the visit was aborted
      */
-    visitBindingElement(bindingElement, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(bindingElement, other);
-        });
+    async visitBindingElement(bindingElement, other) {
+        return this.visitElement(bindingElement, other);
     }
     /**
      * Overrides the visitArrayBindingPattern method to compare array binding patterns.
@@ -2023,10 +1723,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other array binding pattern to compare with
      * @returns The visited array binding pattern, or undefined if the visit was aborted
      */
-    visitArrayBindingPattern(arrayBindingPattern, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(arrayBindingPattern, other);
-        });
+    async visitArrayBindingPattern(arrayBindingPattern, other) {
+        return this.visitElement(arrayBindingPattern, other);
     }
     /**
      * Overrides the visitExportDeclaration method to compare export declarations.
@@ -2035,10 +1733,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other export declaration to compare with
      * @returns The visited export declaration, or undefined if the visit was aborted
      */
-    visitExportDeclaration(exportDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(exportDeclaration, other);
-        });
+    async visitExportDeclaration(exportDeclaration, other) {
+        return this.visitElement(exportDeclaration, other);
     }
     /**
      * Overrides the visitExportAssignment method to compare export assignments.
@@ -2047,10 +1743,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other export assignment to compare with
      * @returns The visited export assignment, or undefined if the visit was aborted
      */
-    visitExportAssignment(exportAssignment, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(exportAssignment, other);
-        });
+    async visitExportAssignment(exportAssignment, other) {
+        return this.visitElement(exportAssignment, other);
     }
     /**
      * Overrides the visitNamedExports method to compare named exports.
@@ -2059,10 +1753,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other named exports to compare with
      * @returns The visited named exports, or undefined if the visit was aborted
      */
-    visitNamedExports(namedExports, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(namedExports, other);
-        });
+    async visitNamedExports(namedExports, other) {
+        return this.visitElement(namedExports, other);
     }
     /**
      * Overrides the visitExportSpecifier method to compare export specifiers.
@@ -2071,10 +1763,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other export specifier to compare with
      * @returns The visited export specifier, or undefined if the visit was aborted
      */
-    visitExportSpecifier(exportSpecifier, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(exportSpecifier, other);
-        });
+    async visitExportSpecifier(exportSpecifier, other) {
+        return this.visitElement(exportSpecifier, other);
     }
     /**
      * Overrides the visitComputedPropertyMethodDeclaration method to compare computed property method declarations.
@@ -2083,10 +1773,8 @@ class JavaScriptComparatorVisitor extends visitor_1.JavaScriptVisitor {
      * @param other The other computed property method declaration to compare with
      * @returns The visited computed property method declaration, or undefined if the visit was aborted
      */
-    visitComputedPropertyMethodDeclaration(computedPropMethod, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.visitElement(computedPropMethod, other);
-        });
+    async visitComputedPropertyMethodDeclaration(computedPropMethod, other) {
+        return this.visitElement(computedPropMethod, other);
     }
 }
 exports.JavaScriptComparatorVisitor = JavaScriptComparatorVisitor;
@@ -2129,27 +1817,25 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
         }
         return tree;
     }
-    visit(j, p, parent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If we've already found a mismatch, abort further processing
-            if (!this.match)
-                return j;
-            // Unwrap parentheses from both trees before comparing
-            const unwrappedJ = this.unwrap(j) || j;
-            const unwrappedP = this.unwrap(p) || p;
-            // Skip the kind check that the base class does - semantic matching allows different kinds
-            // (e.g., undefined identifier matching void expression)
-            // Update targetCursor to track the target node in parallel with the pattern cursor
-            const savedTargetCursor = this.targetCursor;
-            this.targetCursor = new tree_2.Cursor(unwrappedP, this.targetCursor);
-            try {
-                // Call the grandparent's visit to do actual visitation without the kind check
-                return yield visitor_1.JavaScriptVisitor.prototype.visit.call(this, unwrappedJ, unwrappedP);
-            }
-            finally {
-                this.targetCursor = savedTargetCursor;
-            }
-        });
+    async visit(j, p, parent) {
+        // If we've already found a mismatch, abort further processing
+        if (!this.match)
+            return j;
+        // Unwrap parentheses from both trees before comparing
+        const unwrappedJ = this.unwrap(j) || j;
+        const unwrappedP = this.unwrap(p) || p;
+        // Skip the kind check that the base class does - semantic matching allows different kinds
+        // (e.g., undefined identifier matching void expression)
+        // Update targetCursor to track the target node in parallel with the pattern cursor
+        const savedTargetCursor = this.targetCursor;
+        this.targetCursor = new tree_2.Cursor(unwrappedP, this.targetCursor);
+        try {
+            // Call the grandparent's visit to do actual visitation without the kind check
+            return await visitor_1.JavaScriptVisitor.prototype.visit.call(this, unwrappedJ, unwrappedP);
+        }
+        finally {
+            this.targetCursor = savedTargetCursor;
+        }
     }
     /**
      * Override visitArrowFunction to allow semantic equivalence between expression body
@@ -2159,66 +1845,64 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * - `x => x + 1` matches `x => { return x + 1; }`
      * - `(x, y) => x + y` matches `(x, y) => { return x + y; }`
      */
-    visitArrowFunction(arrowFunction, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return arrowFunction;
-            if (other.kind !== tree_1.JS.Kind.ArrowFunction) {
-                return this.kindMismatch();
-            }
-            const otherArrow = other;
-            // Compare all properties reflectively except lambda (handled specially below)
-            for (const key of Object.keys(arrowFunction)) {
-                if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'lambda') {
-                    continue;
-                }
-                const jValue = arrowFunction[key];
-                const otherValue = otherArrow[key];
-                // Handle arrays
-                if (Array.isArray(jValue)) {
-                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.arrayLengthMismatch(key);
-                    }
-                    for (let i = 0; i < jValue.length; i++) {
-                        yield this.visitProperty(jValue[i], otherValue[i]);
-                        if (!this.match)
-                            return arrowFunction;
-                    }
+    async visitArrowFunction(arrowFunction, other) {
+        if (!this.match)
+            return arrowFunction;
+        if (other.kind !== tree_1.JS.Kind.ArrowFunction) {
+            return this.kindMismatch();
+        }
+        const otherArrow = other;
+        // Compare all properties reflectively except lambda (handled specially below)
+        for (const key of Object.keys(arrowFunction)) {
+            if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'lambda') {
+                continue;
+            }
+            const jValue = arrowFunction[key];
+            const otherValue = otherArrow[key];
+            // Handle arrays
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.arrayLengthMismatch(key);
                 }
-                else {
-                    yield this.visitProperty(jValue, otherValue);
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i]);
                     if (!this.match)
                         return arrowFunction;
                 }
             }
-            // Compare lambda parameters
-            const params1 = arrowFunction.lambda.parameters.parameters;
-            const params2 = otherArrow.lambda.parameters.parameters;
-            if (params1.length !== params2.length) {
-                return this.arrayLengthMismatch('lambda.parameters.parameters');
-            }
-            for (let i = 0; i < params1.length; i++) {
-                yield this.visitProperty(params1[i], params2[i]);
+            else {
+                await this.visitProperty(jValue, otherValue);
                 if (!this.match)
                     return arrowFunction;
             }
-            // Handle semantic equivalence for lambda bodies
-            const body1 = arrowFunction.lambda.body;
-            const body2 = otherArrow.lambda.body;
-            // Try to extract the expression from each body
-            const expr1 = this.extractExpression(body1);
-            const expr2 = this.extractExpression(body2);
-            if (expr1 && expr2) {
-                // Both have extractable expressions - compare them
-                yield this.visit(expr1, expr2);
-            }
-            else {
-                // At least one is not a simple expression or block-with-return
-                // Fall back to exact comparison
-                yield this.visit(body1, body2);
-            }
-            return arrowFunction;
-        });
+        }
+        // Compare lambda parameters
+        const params1 = arrowFunction.lambda.parameters.parameters;
+        const params2 = otherArrow.lambda.parameters.parameters;
+        if (params1.length !== params2.length) {
+            return this.arrayLengthMismatch('lambda.parameters.parameters');
+        }
+        for (let i = 0; i < params1.length; i++) {
+            await this.visitProperty(params1[i], params2[i]);
+            if (!this.match)
+                return arrowFunction;
+        }
+        // Handle semantic equivalence for lambda bodies
+        const body1 = arrowFunction.lambda.body;
+        const body2 = otherArrow.lambda.body;
+        // Try to extract the expression from each body
+        const expr1 = this.extractExpression(body1);
+        const expr2 = this.extractExpression(body2);
+        if (expr1 && expr2) {
+            // Both have extractable expressions - compare them
+            await this.visit(expr1, expr2);
+        }
+        else {
+            // At least one is not a simple expression or block-with-return
+            // Fall back to exact comparison
+            await this.visit(body1, body2);
+        }
+        return arrowFunction;
     }
     /**
      * Override visitLambdaParameters to allow semantic equivalence between
@@ -2227,40 +1911,38 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * Examples:
      * - `x => x + 1` matches `(x) => x + 1`
      */
-    visitLambdaParameters(parameters, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return parameters;
-            if (other.kind !== java_1.J.Kind.LambdaParameters) {
-                return this.kindMismatch();
-            }
-            const otherParams = other;
-            // Compare all properties except 'parenthesized' using reflection
-            for (const key of Object.keys(parameters)) {
-                if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'parenthesized') {
-                    continue;
-                }
-                const jValue = parameters[key];
-                const otherValue = otherParams[key];
-                // Handle arrays
-                if (Array.isArray(jValue)) {
-                    if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
-                        return this.arrayLengthMismatch(key);
-                    }
-                    for (let i = 0; i < jValue.length; i++) {
-                        yield this.visitProperty(jValue[i], otherValue[i]);
-                        if (!this.match)
-                            return parameters;
-                    }
+    async visitLambdaParameters(parameters, other) {
+        if (!this.match)
+            return parameters;
+        if (other.kind !== java_1.J.Kind.LambdaParameters) {
+            return this.kindMismatch();
+        }
+        const otherParams = other;
+        // Compare all properties except 'parenthesized' using reflection
+        for (const key of Object.keys(parameters)) {
+            if (key.startsWith('_') || key === 'id' || key === 'markers' || key === 'parenthesized') {
+                continue;
+            }
+            const jValue = parameters[key];
+            const otherValue = otherParams[key];
+            // Handle arrays
+            if (Array.isArray(jValue)) {
+                if (!Array.isArray(otherValue) || jValue.length !== otherValue.length) {
+                    return this.arrayLengthMismatch(key);
                 }
-                else {
-                    yield this.visitProperty(jValue, otherValue);
+                for (let i = 0; i < jValue.length; i++) {
+                    await this.visitProperty(jValue[i], otherValue[i]);
                     if (!this.match)
                         return parameters;
                 }
             }
-            return parameters;
-        });
+            else {
+                await this.visitProperty(jValue, otherValue);
+                if (!this.match)
+                    return parameters;
+            }
+        }
+        return parameters;
     }
     /**
      * Override visitPropertyAssignment to allow semantic equivalence between
@@ -2270,44 +1952,39 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * - `{ x }` matches `{ x: x }`
      * - `{ x: x, y: y }` matches `{ x, y }`
      */
-    visitPropertyAssignment(propertyAssignment, other) {
-        const _super = Object.create(null, {
-            visitPropertyAssignment: { get: () => super.visitPropertyAssignment }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return propertyAssignment;
-            if (other.kind !== tree_1.JS.Kind.PropertyAssignment) {
-                return this.kindMismatch();
-            }
-            const otherProp = other;
-            // Extract property names for semantic comparison
-            const propName = this.getPropertyName(propertyAssignment);
-            const otherPropName = this.getPropertyName(otherProp);
-            // Names must match
-            if (!propName || !otherPropName || propName !== otherPropName) {
-                // Can't do semantic comparison without identifiers, fall back to exact comparison
-                return yield _super.visitPropertyAssignment.call(this, propertyAssignment, other);
-            }
-            // Detect shorthand (no initializer) vs longhand (has initializer)
-            const isShorthand1 = !propertyAssignment.initializer;
-            const isShorthand2 = !otherProp.initializer;
-            if (isShorthand1 === isShorthand2) {
-                // Both shorthand or both longhand - use base comparison
-                return yield _super.visitPropertyAssignment.call(this, propertyAssignment, other);
-            }
-            // One is shorthand, one is longhand - check semantic equivalence
-            const longhandProp = isShorthand1 ? otherProp : propertyAssignment;
-            // Check if the longhand's initializer is an identifier with the same name as the property
-            if (this.isIdentifierWithName(longhandProp.initializer, propName)) {
-                // Semantically equivalent!
-                return propertyAssignment;
-            }
-            else {
-                // Not equivalent (e.g., { x: y })
-                return this.structuralMismatch('initializer');
-            }
-        });
+    async visitPropertyAssignment(propertyAssignment, other) {
+        if (!this.match)
+            return propertyAssignment;
+        if (other.kind !== tree_1.JS.Kind.PropertyAssignment) {
+            return this.kindMismatch();
+        }
+        const otherProp = other;
+        // Extract property names for semantic comparison
+        const propName = this.getPropertyName(propertyAssignment);
+        const otherPropName = this.getPropertyName(otherProp);
+        // Names must match
+        if (!propName || !otherPropName || propName !== otherPropName) {
+            // Can't do semantic comparison without identifiers, fall back to exact comparison
+            return await super.visitPropertyAssignment(propertyAssignment, other);
+        }
+        // Detect shorthand (no initializer) vs longhand (has initializer)
+        const isShorthand1 = !propertyAssignment.initializer;
+        const isShorthand2 = !otherProp.initializer;
+        if (isShorthand1 === isShorthand2) {
+            // Both shorthand or both longhand - use base comparison
+            return await super.visitPropertyAssignment(propertyAssignment, other);
+        }
+        // One is shorthand, one is longhand - check semantic equivalence
+        const longhandProp = isShorthand1 ? otherProp : propertyAssignment;
+        // Check if the longhand's initializer is an identifier with the same name as the property
+        if (this.isIdentifierWithName(longhandProp.initializer, propName)) {
+            // Semantically equivalent!
+            return propertyAssignment;
+        }
+        else {
+            // Not equivalent (e.g., { x: y })
+            return this.structuralMismatch('initializer');
+        }
     }
     /**
      * Extracts the property name from a PropertyAssignment.
@@ -2354,24 +2031,19 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * When lenientTypeMatching is enabled, null vs Type comparisons are allowed
      * (where one value is null/undefined and the other is a Type object).
      */
-    visitProperty(j, other, propertyName) {
-        const _super = Object.create(null, {
-            visitProperty: { get: () => super.visitProperty }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Handle null/undefined with lenient type matching
-            if (this.lenientTypeMatching && (j == null || other == null)) {
-                if (j !== other) {
-                    // Don't abort if one is null and the other is a Type
-                    if (!java_1.Type.isType(j) && !java_1.Type.isType(other)) {
-                        this.structuralMismatch(propertyName);
-                    }
+    async visitProperty(j, other, propertyName) {
+        // Handle null/undefined with lenient type matching
+        if (this.lenientTypeMatching && (j == null || other == null)) {
+            if (j !== other) {
+                // Don't abort if one is null and the other is a Type
+                if (!java_1.Type.isType(j) && !java_1.Type.isType(other)) {
+                    this.structuralMismatch(propertyName);
                 }
-                return j;
             }
-            // Otherwise, use base class behavior
-            return _super.visitProperty.call(this, j, other);
-        });
+            return j;
+        }
+        // Otherwise, use base class behavior
+        return super.visitProperty(j, other);
     }
     /**
      * Checks if two types are semantically equal.
@@ -2444,253 +2116,239 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * When types match semantically, we allow matching even if one has a receiver
      * and the other doesn't (e.g., `isDate(x)` vs `util.isDate(x)`).
      */
-    visitMethodInvocation(method, other) {
-        const _super = Object.create(null, {
-            visitMethodInvocation: { get: () => super.visitMethodInvocation }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (other.kind !== java_1.J.Kind.MethodInvocation) {
-                return this.kindMismatch();
+    async visitMethodInvocation(method, other) {
+        if (other.kind !== java_1.J.Kind.MethodInvocation) {
+            return this.kindMismatch();
+        }
+        const otherMethod = other;
+        // Check if we can skip name checking based on type attribution
+        // We can only skip the name check if both have method types AND they represent the SAME method
+        // (not just type-compatible methods, but the actual same function with same FQN)
+        let canSkipNameCheck = false;
+        if (method.methodType && otherMethod.methodType) {
+            // Check if both method types have fully qualified declaring types with the same FQN
+            // This indicates they're the same method from the same module (possibly aliased)
+            const methodDeclaringType = method.methodType.declaringType;
+            const otherDeclaringType = otherMethod.methodType.declaringType;
+            if (methodDeclaringType && otherDeclaringType &&
+                java_1.Type.isFullyQualified(methodDeclaringType) && java_1.Type.isFullyQualified(otherDeclaringType)) {
+                const methodFQN = java_1.Type.FullyQualified.getFullyQualifiedName(methodDeclaringType);
+                const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
+                // Same module/class AND same method name in the type = same method (can be aliased)
+                if (methodFQN === otherFQN && method.methodType.name === otherMethod.methodType.name) {
+                    canSkipNameCheck = true;
+                }
+                // If FQNs or method names don't match, we can't skip name check - fall through to name checking
+            }
+            // If one or both don't have fully qualified types, we can't safely skip name checking
+            // Fall through to normal name comparison below
+        }
+        // Check names unless we determined we can skip based on type FQN matching
+        if (!canSkipNameCheck) {
+            if (method.name.simpleName !== otherMethod.name.simpleName) {
+                return this.valueMismatch('name.simpleName', method.name.simpleName, otherMethod.name.simpleName);
+            }
+            // In strict mode, check type attribution requirements
+            if (!this.lenientTypeMatching) {
+                // Strict mode: if one has type but the other doesn't, they don't match
+                if ((method.methodType && !otherMethod.methodType) ||
+                    (!method.methodType && otherMethod.methodType)) {
+                    return this.typeMismatch('methodType');
+                }
+            }
+            // If neither has type, use structural comparison
+            if (!method.methodType && !otherMethod.methodType) {
+                return super.visitMethodInvocation(method, other);
             }
-            const otherMethod = other;
-            // Check if we can skip name checking based on type attribution
-            // We can only skip the name check if both have method types AND they represent the SAME method
-            // (not just type-compatible methods, but the actual same function with same FQN)
-            let canSkipNameCheck = false;
+            // If both have types with FQ declaring types, verify they're compatible
+            // (This prevents matching completely different methods like util.isArray vs util.isBoolean)
             if (method.methodType && otherMethod.methodType) {
-                // Check if both method types have fully qualified declaring types with the same FQN
-                // This indicates they're the same method from the same module (possibly aliased)
                 const methodDeclaringType = method.methodType.declaringType;
                 const otherDeclaringType = otherMethod.methodType.declaringType;
                 if (methodDeclaringType && otherDeclaringType &&
                     java_1.Type.isFullyQualified(methodDeclaringType) && java_1.Type.isFullyQualified(otherDeclaringType)) {
                     const methodFQN = java_1.Type.FullyQualified.getFullyQualifiedName(methodDeclaringType);
                     const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
-                    // Same module/class AND same method name in the type = same method (can be aliased)
-                    if (methodFQN === otherFQN && method.methodType.name === otherMethod.methodType.name) {
-                        canSkipNameCheck = true;
+                    // Different declaring types = different methods, even with same name
+                    if (methodFQN !== otherFQN) {
+                        return this.valueMismatch('methodType.declaringType');
                     }
-                    // If FQNs or method names don't match, we can't skip name check - fall through to name checking
                 }
-                // If one or both don't have fully qualified types, we can't safely skip name checking
-                // Fall through to normal name comparison below
             }
-            // Check names unless we determined we can skip based on type FQN matching
-            if (!canSkipNameCheck) {
-                if (method.name.simpleName !== otherMethod.name.simpleName) {
-                    return this.valueMismatch('name.simpleName', method.name.simpleName, otherMethod.name.simpleName);
-                }
-                // In strict mode, check type attribution requirements
-                if (!this.lenientTypeMatching) {
-                    // Strict mode: if one has type but the other doesn't, they don't match
-                    if ((method.methodType && !otherMethod.methodType) ||
-                        (!method.methodType && otherMethod.methodType)) {
-                        return this.typeMismatch('methodType');
-                    }
-                }
-                // If neither has type, use structural comparison
-                if (!method.methodType && !otherMethod.methodType) {
-                    return _super.visitMethodInvocation.call(this, method, other);
-                }
-                // If both have types with FQ declaring types, verify they're compatible
-                // (This prevents matching completely different methods like util.isArray vs util.isBoolean)
-                if (method.methodType && otherMethod.methodType) {
-                    const methodDeclaringType = method.methodType.declaringType;
-                    const otherDeclaringType = otherMethod.methodType.declaringType;
-                    if (methodDeclaringType && otherDeclaringType &&
-                        java_1.Type.isFullyQualified(methodDeclaringType) && java_1.Type.isFullyQualified(otherDeclaringType)) {
-                        const methodFQN = java_1.Type.FullyQualified.getFullyQualifiedName(methodDeclaringType);
-                        const otherFQN = java_1.Type.FullyQualified.getFullyQualifiedName(otherDeclaringType);
-                        // Different declaring types = different methods, even with same name
-                        if (methodFQN !== otherFQN) {
-                            return this.valueMismatch('methodType.declaringType');
-                        }
-                    }
-                }
-            }
-            // When types match (canSkipNameCheck = true), we can skip select comparison entirely.
-            // This allows matching forwardRef() vs React.forwardRef() where types indicate same method.
-            if (!canSkipNameCheck) {
-                // Types didn't provide a match - must compare receivers structurally
-                if ((method.select === undefined) !== (otherMethod.select === undefined)) {
-                    return this.structuralMismatch('select');
-                }
-                if (method.select && otherMethod.select) {
-                    yield this.visitRightPaddedProperty('select', method.select, otherMethod.select);
-                    if (!this.match)
-                        return method;
-                }
-            }
-            // else: types matched, skip select comparison (allows namespace vs named imports)
-            // Compare type parameters
-            if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
-                return this.structuralMismatch('typeParameters');
-            }
-            if (method.typeParameters && otherMethod.typeParameters) {
-                yield this.visitContainerProperty('typeParameters', method.typeParameters, otherMethod.typeParameters);
-                if (!this.match)
-                    return method;
-            }
-            // Compare name
-            // If we determined we can skip name check (same FQN method, possibly aliased), skip it
-            // This allows matching aliased imports where names differ but types are the same
-            if (!canSkipNameCheck) {
-                yield this.visit(method.name, otherMethod.name);
+        }
+        // When types match (canSkipNameCheck = true), we can skip select comparison entirely.
+        // This allows matching forwardRef() vs React.forwardRef() where types indicate same method.
+        if (!canSkipNameCheck) {
+            // Types didn't provide a match - must compare receivers structurally
+            if ((method.select === undefined) !== (otherMethod.select === undefined)) {
+                return this.structuralMismatch('select');
+            }
+            if (method.select && otherMethod.select) {
+                await this.visitRightPaddedProperty('select', method.select, otherMethod.select);
                 if (!this.match)
                     return method;
             }
-            // Compare arguments
-            yield this.visitContainerProperty('arguments', method.arguments, otherMethod.arguments);
+        }
+        // else: types matched, skip select comparison (allows namespace vs named imports)
+        // Compare type parameters
+        if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
+            return this.structuralMismatch('typeParameters');
+        }
+        if (method.typeParameters && otherMethod.typeParameters) {
+            await this.visitContainerProperty('typeParameters', method.typeParameters, otherMethod.typeParameters);
             if (!this.match)
                 return method;
+        }
+        // Compare name
+        // If we determined we can skip name check (same FQN method, possibly aliased), skip it
+        // This allows matching aliased imports where names differ but types are the same
+        if (!canSkipNameCheck) {
+            await this.visit(method.name, otherMethod.name);
+            if (!this.match)
+                return method;
+        }
+        // Compare arguments
+        await this.visitContainerProperty('arguments', method.arguments, otherMethod.arguments);
+        if (!this.match)
             return method;
-        });
+        return method;
     }
     /**
      * Override identifier comparison to include:
      * 1. Type checking for field access
      * 2. Semantic equivalence between `undefined` identifier and void expressions
      */
-    visitIdentifier(identifier, other) {
-        const _super = Object.create(null, {
-            visitIdentifier: { get: () => super.visitIdentifier }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check if this identifier is "undefined" and the other is a void expression
-            if (identifier.simpleName === 'undefined' && other.kind === tree_1.JS.Kind.Void) {
-                // Both evaluate to undefined, so they match
-                return identifier;
-            }
-            if (other.kind !== java_1.J.Kind.Identifier) {
-                return this.kindMismatch();
-            }
-            const otherIdentifier = other;
-            // Check name matches
-            if (identifier.simpleName !== otherIdentifier.simpleName) {
-                return this.valueMismatch('simpleName');
-            }
-            // For identifiers with field types, check type attribution
-            if (identifier.fieldType && otherIdentifier.fieldType) {
-                if (!this.isOfType(identifier.fieldType, otherIdentifier.fieldType)) {
-                    return this.typeMismatch('fieldType');
-                }
+    async visitIdentifier(identifier, other) {
+        // Check if this identifier is "undefined" and the other is a void expression
+        if (identifier.simpleName === 'undefined' && other.kind === tree_1.JS.Kind.Void) {
+            // Both evaluate to undefined, so they match
+            return identifier;
+        }
+        if (other.kind !== java_1.J.Kind.Identifier) {
+            return this.kindMismatch();
+        }
+        const otherIdentifier = other;
+        // Check name matches
+        if (identifier.simpleName !== otherIdentifier.simpleName) {
+            return this.valueMismatch('simpleName');
+        }
+        // For identifiers with field types, check type attribution
+        if (identifier.fieldType && otherIdentifier.fieldType) {
+            if (!this.isOfType(identifier.fieldType, otherIdentifier.fieldType)) {
+                return this.typeMismatch('fieldType');
             }
-            else if (identifier.fieldType || otherIdentifier.fieldType) {
-                // Lenient mode: if either has no type, allow structural matching
-                if (!this.lenientTypeMatching) {
-                    // Strict mode: if only one has a type, they don't match
-                    return this.typeMismatch('fieldType');
-                }
+        }
+        else if (identifier.fieldType || otherIdentifier.fieldType) {
+            // Lenient mode: if either has no type, allow structural matching
+            if (!this.lenientTypeMatching) {
+                // Strict mode: if only one has a type, they don't match
+                return this.typeMismatch('fieldType');
             }
-            return _super.visitIdentifier.call(this, identifier, other);
-        });
+        }
+        return super.visitIdentifier(identifier, other);
     }
     /**
      * Override variable declarations comparison to handle lenient type matching.
      * When lenientTypeMatching is true, patterns without typeExpression can match
      * code with typeExpression.
      */
-    visitVariableDeclarations(variableDeclarations, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const otherVariableDeclarations = other;
-            // Visit leading annotations
-            yield this.visitArrayProperty(variableDeclarations, 'leadingAnnotations', variableDeclarations.leadingAnnotations, otherVariableDeclarations.leadingAnnotations, (ann1, ann2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(ann1, ann2); }));
-            if (!this.match)
-                return variableDeclarations;
-            // Visit modifiers
-            yield this.visitArrayProperty(variableDeclarations, 'modifiers', variableDeclarations.modifiers, otherVariableDeclarations.modifiers, (mod1, mod2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(mod1, mod2); }));
-            if (!this.match)
-                return variableDeclarations;
-            // Compare typeExpression - lenient matching allows one to be undefined
-            if ((variableDeclarations.typeExpression === undefined) !== (otherVariableDeclarations.typeExpression === undefined)) {
-                if (!this.lenientTypeMatching) {
-                    return this.structuralMismatch('typeExpression');
-                }
-                // In lenient mode, skip type comparison and continue
-            }
-            else if (variableDeclarations.typeExpression && otherVariableDeclarations.typeExpression) {
-                // Both have typeExpression, visit them
-                yield this.visit(variableDeclarations.typeExpression, otherVariableDeclarations.typeExpression);
-                if (!this.match)
-                    return variableDeclarations;
-            }
-            // Compare varargs
-            if ((variableDeclarations.varargs === undefined) !== (otherVariableDeclarations.varargs === undefined)) {
-                return this.structuralMismatch('varargs');
+    async visitVariableDeclarations(variableDeclarations, other) {
+        const otherVariableDeclarations = other;
+        // Visit leading annotations
+        await this.visitArrayProperty(variableDeclarations, 'leadingAnnotations', variableDeclarations.leadingAnnotations, otherVariableDeclarations.leadingAnnotations, async (ann1, ann2) => { await this.visit(ann1, ann2); });
+        if (!this.match)
+            return variableDeclarations;
+        // Visit modifiers
+        await this.visitArrayProperty(variableDeclarations, 'modifiers', variableDeclarations.modifiers, otherVariableDeclarations.modifiers, async (mod1, mod2) => { await this.visit(mod1, mod2); });
+        if (!this.match)
+            return variableDeclarations;
+        // Compare typeExpression - lenient matching allows one to be undefined
+        if ((variableDeclarations.typeExpression === undefined) !== (otherVariableDeclarations.typeExpression === undefined)) {
+            if (!this.lenientTypeMatching) {
+                return this.structuralMismatch('typeExpression');
             }
-            // Compare variables
-            yield this.visitArrayProperty(variableDeclarations, 'variables', variableDeclarations.variables, otherVariableDeclarations.variables, (var1, var2) => __awaiter(this, void 0, void 0, function* () { yield this.visitRightPadded(var1, var2); }));
+            // In lenient mode, skip type comparison and continue
+        }
+        else if (variableDeclarations.typeExpression && otherVariableDeclarations.typeExpression) {
+            // Both have typeExpression, visit them
+            await this.visit(variableDeclarations.typeExpression, otherVariableDeclarations.typeExpression);
             if (!this.match)
                 return variableDeclarations;
+        }
+        // Compare varargs
+        if ((variableDeclarations.varargs === undefined) !== (otherVariableDeclarations.varargs === undefined)) {
+            return this.structuralMismatch('varargs');
+        }
+        // Compare variables
+        await this.visitArrayProperty(variableDeclarations, 'variables', variableDeclarations.variables, otherVariableDeclarations.variables, async (var1, var2) => { await this.visitRightPadded(var1, var2); });
+        if (!this.match)
             return variableDeclarations;
-        });
+        return variableDeclarations;
     }
     /**
      * Override method declaration comparison to handle lenient type matching.
      * When lenientTypeMatching is true, patterns without returnTypeExpression can match
      * code with returnTypeExpression.
      */
-    visitMethodDeclaration(methodDeclaration, other) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const otherMethodDeclaration = other;
-            // Visit leading annotations
-            yield this.visitArrayProperty(methodDeclaration, 'leadingAnnotations', methodDeclaration.leadingAnnotations, otherMethodDeclaration.leadingAnnotations, (ann1, ann2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(ann1, ann2); }));
+    async visitMethodDeclaration(methodDeclaration, other) {
+        const otherMethodDeclaration = other;
+        // Visit leading annotations
+        await this.visitArrayProperty(methodDeclaration, 'leadingAnnotations', methodDeclaration.leadingAnnotations, otherMethodDeclaration.leadingAnnotations, async (ann1, ann2) => { await this.visit(ann1, ann2); });
+        if (!this.match)
+            return methodDeclaration;
+        // Visit modifiers
+        await this.visitArrayProperty(methodDeclaration, 'modifiers', methodDeclaration.modifiers, otherMethodDeclaration.modifiers, async (mod1, mod2) => { await this.visit(mod1, mod2); });
+        if (!this.match)
+            return methodDeclaration;
+        // Visit type parameters if present
+        if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
+            return this.structuralMismatch('typeParameters');
+        }
+        if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
+            await this.visit(methodDeclaration.typeParameters, otherMethodDeclaration.typeParameters);
             if (!this.match)
                 return methodDeclaration;
-            // Visit modifiers
-            yield this.visitArrayProperty(methodDeclaration, 'modifiers', methodDeclaration.modifiers, otherMethodDeclaration.modifiers, (mod1, mod2) => __awaiter(this, void 0, void 0, function* () { yield this.visit(mod1, mod2); }));
+        }
+        // Compare returnTypeExpression - lenient matching allows one to be undefined
+        if ((methodDeclaration.returnTypeExpression === undefined) !== (otherMethodDeclaration.returnTypeExpression === undefined)) {
+            if (!this.lenientTypeMatching) {
+                return this.typeMismatch('returnTypeExpression');
+            }
+            // In lenient mode, skip type comparison and continue
+        }
+        else if (methodDeclaration.returnTypeExpression && otherMethodDeclaration.returnTypeExpression) {
+            // Both have returnTypeExpression, visit them
+            await this.visit(methodDeclaration.returnTypeExpression, otherMethodDeclaration.returnTypeExpression);
             if (!this.match)
                 return methodDeclaration;
-            // Visit type parameters if present
-            if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
-                return this.structuralMismatch('typeParameters');
-            }
-            if (methodDeclaration.typeParameters && otherMethodDeclaration.typeParameters) {
-                yield this.visit(methodDeclaration.typeParameters, otherMethodDeclaration.typeParameters);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            // Compare returnTypeExpression - lenient matching allows one to be undefined
-            if ((methodDeclaration.returnTypeExpression === undefined) !== (otherMethodDeclaration.returnTypeExpression === undefined)) {
-                if (!this.lenientTypeMatching) {
-                    return this.typeMismatch('returnTypeExpression');
-                }
-                // In lenient mode, skip type comparison and continue
-            }
-            else if (methodDeclaration.returnTypeExpression && otherMethodDeclaration.returnTypeExpression) {
-                // Both have returnTypeExpression, visit them
-                yield this.visit(methodDeclaration.returnTypeExpression, otherMethodDeclaration.returnTypeExpression);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            // Visit name
-            yield this.visit(methodDeclaration.name, otherMethodDeclaration.name);
+        }
+        // Visit name
+        await this.visit(methodDeclaration.name, otherMethodDeclaration.name);
+        if (!this.match)
+            return methodDeclaration;
+        // Compare parameters
+        await this.visitContainer(methodDeclaration.parameters, otherMethodDeclaration.parameters);
+        if (!this.match)
+            return methodDeclaration;
+        // Visit throws if present
+        if (!!methodDeclaration.throws !== !!otherMethodDeclaration.throws) {
+            return this.structuralMismatch('throws');
+        }
+        if (methodDeclaration.throws && otherMethodDeclaration.throws) {
+            await this.visitContainer(methodDeclaration.throws, otherMethodDeclaration.throws);
             if (!this.match)
                 return methodDeclaration;
-            // Compare parameters
-            yield this.visitContainer(methodDeclaration.parameters, otherMethodDeclaration.parameters);
+        }
+        // Visit body if present
+        if (!!methodDeclaration.body !== !!otherMethodDeclaration.body) {
+            return this.structuralMismatch('body');
+        }
+        if (methodDeclaration.body && otherMethodDeclaration.body) {
+            await this.visit(methodDeclaration.body, otherMethodDeclaration.body);
             if (!this.match)
                 return methodDeclaration;
-            // Visit throws if present
-            if (!!methodDeclaration.throws !== !!otherMethodDeclaration.throws) {
-                return this.structuralMismatch('throws');
-            }
-            if (methodDeclaration.throws && otherMethodDeclaration.throws) {
-                yield this.visitContainer(methodDeclaration.throws, otherMethodDeclaration.throws);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            // Visit body if present
-            if (!!methodDeclaration.body !== !!otherMethodDeclaration.body) {
-                return this.structuralMismatch('body');
-            }
-            if (methodDeclaration.body && otherMethodDeclaration.body) {
-                yield this.visit(methodDeclaration.body, otherMethodDeclaration.body);
-                if (!this.match)
-                    return methodDeclaration;
-            }
-            return methodDeclaration;
-        });
+        }
+        return methodDeclaration;
     }
     /**
      * Override visitVoid to allow semantic equivalence with undefined identifier.
@@ -2702,24 +2360,19 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * - `void(0)` matches `undefined`
      * - `void 1` matches `undefined`
      */
-    visitVoid(voidExpr, other) {
-        const _super = Object.create(null, {
-            visitVoid: { get: () => super.visitVoid }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
+    async visitVoid(voidExpr, other) {
+        if (!this.match)
+            return voidExpr;
+        // Check if the other is an undefined identifier
+        if (other.kind === java_1.J.Kind.Identifier) {
+            const identifier = other;
+            if (identifier.simpleName === 'undefined') {
+                // Both evaluate to undefined, so they match
                 return voidExpr;
-            // Check if the other is an undefined identifier
-            if (other.kind === java_1.J.Kind.Identifier) {
-                const identifier = other;
-                if (identifier.simpleName === 'undefined') {
-                    // Both evaluate to undefined, so they match
-                    return voidExpr;
-                }
             }
-            // Otherwise delegate to parent
-            return _super.visitVoid.call(this, voidExpr, other);
-        });
+        }
+        // Otherwise delegate to parent
+        return super.visitVoid(voidExpr, other);
     }
     /**
      * Override visitLiteral to allow semantic equivalence between
@@ -2731,26 +2384,21 @@ class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVisitor {
      * - `255` matches `0b11111111`
      * - `1000` matches `1e3`
      */
-    visitLiteral(literal, other) {
-        const _super = Object.create(null, {
-            visitLiteral: { get: () => super.visitLiteral }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.match)
-                return literal;
-            if (other.kind !== java_1.J.Kind.Literal) {
-                return yield _super.visitLiteral.call(this, literal, other);
-            }
-            const otherLiteral = other;
-            // Only compare value and type, ignoring valueSource (text representation) and unicodeEscapes
-            yield this.visitProperty(literal.value, otherLiteral.value, 'value');
-            if (!this.match)
-                return literal;
-            yield this.visitProperty(literal.type, otherLiteral.type, 'type');
-            if (!this.match)
-                return literal;
+    async visitLiteral(literal, other) {
+        if (!this.match)
+            return literal;
+        if (other.kind !== java_1.J.Kind.Literal) {
+            return await super.visitLiteral(literal, other);
+        }
+        const otherLiteral = other;
+        // Only compare value and type, ignoring valueSource (text representation) and unicodeEscapes
+        await this.visitProperty(literal.value, otherLiteral.value, 'value');
+        if (!this.match)
+            return literal;
+        await this.visitProperty(literal.type, otherLiteral.type, 'type');
+        if (!this.match)
             return literal;
-        });
+        return literal;
     }
 }
 exports.JavaScriptSemanticComparatorVisitor = JavaScriptSemanticComparatorVisitor;