astronomical 2.0.0 → 2.1.1-rc.1

package/lib/cjs/index.js

@@ -34,9 +34,16 @@ exports.functions = {
     },
     "concat": {
         fn: (result) => {
-            if (result.some(x => x.length == 0))
-                return [];
-            return [result.flat().join("")];
+            // Optimize: combine empty check with manual flattening
+            const flattened = [];
+            for (let i = 0; i < result.length; i++) {
+                if (result[i].length === 0)
+                    return [];
+                for (let j = 0; j < result[i].length; j++) {
+                    flattened.push(result[i][j]);
+                }
+            }
+            return [flattened.join("")];
         }
     },
     "first": {
@@ -45,7 +52,7 @@ exports.functions = {
                 throw new Error("Invalid number of arugments for first");
             if (result[0].length == 0)
                 return [];
-            return [result.map(r => r[0])[0]];
+            return [result[0][0]];
         }
     },
     "nthchild": {
@@ -79,14 +86,14 @@ function createQuerier() {
     const traverser = createTraverser();
     const { getChildren, getPrimitiveChildren, getPrimitiveChildrenOrNodePaths, getBinding, createNodePath, traverse } = traverser;
     function createFilter(filter, filterResult) {
-        if (filter.type == "and" || filter.type == "or" || filter.type == "equals") {
+        if (filter.type == parseQuery_1.NodeType.AND || filter.type == parseQuery_1.NodeType.OR || filter.type == parseQuery_1.NodeType.EQUALS) {
             return {
                 type: filter.type,
                 left: createFilter(filter.left, []),
                 right: createFilter(filter.right, [])
             };
         }
-        else if (filter.type == "literal") {
+        else if (filter.type == parseQuery_1.NodeType.LITERAL) {
             const r = [filter.value];
             return {
                 node: filter,
@@ -102,16 +109,16 @@ function createQuerier() {
         };
     }
     function addFilterChildrenToState(filter, state) {
-        if ("type" in filter && (filter.type == "and" || filter.type == "or" || filter.type == "equals")) {
+        if ("type" in filter && (filter.type == parseQuery_1.NodeType.AND || filter.type == parseQuery_1.NodeType.OR || filter.type == parseQuery_1.NodeType.EQUALS)) {
             addFilterChildrenToState(filter.left, state);
             addFilterChildrenToState(filter.right, state);
         }
         else if ("node" in filter) {
-            if (filter.node.type == "child") {
+            if (filter.node.type == parseQuery_1.NodeType.CHILD) {
                 log?.debug("ADDING FILTER CHILD", filter.node);
                 state.child[state.depth + 1].push(filter);
             }
-            if (filter.node.type == "descendant") {
+            if (filter.node.type == parseQuery_1.NodeType.DESCENDANT) {
                 log?.debug("ADDING FILTER DESCENDANT", filter.node);
                 state.descendant[state.depth + 1].push(filter);
             }
@@ -120,10 +127,10 @@ function createQuerier() {
     function createFNodeAndAddToState(token, result, state) {
         log?.debug("ADDING FNODE", token);
         const fnode = createFNode(token, result);
-        if (token.type == "child") {
+        if (token.type == parseQuery_1.NodeType.CHILD) {
             state.child[state.depth + 1].push(fnode);
         }
-        else if (token.type == "descendant") {
+        else if (token.type == parseQuery_1.NodeType.DESCENDANT) {
             state.descendant[state.depth + 1].push(fnode);
         }
         return fnode;
@@ -161,7 +168,7 @@ function createQuerier() {
             addFilterChildrenToState(filter, state);
             const child = fnode.node.child;
             if (child) {
-                if (child.type == "function") {
+                if (child.type == parseQuery_1.NodeType.FUNCTION) {
                     const fr = addFunction(fnode, child, path, state);
                     state.functionCalls[state.depth].push(fr);
                 }
@@ -172,7 +179,7 @@ function createQuerier() {
         }
         else {
             const child = fnode.node.child;
-            if (child?.type == "function") {
+            if (child?.type == parseQuery_1.NodeType.FUNCTION) {
                 const fr = addFunction(fnode, child, path, state);
                 state.functionCalls[state.depth].push(fr);
             }
@@ -184,11 +191,11 @@ function createQuerier() {
     function addFunction(rootNode, functionCall, path, state) {
         const functionNode = { node: rootNode.node, functionCall: functionCall, parameters: [], result: [] };
         for (const param of functionCall.parameters) {
-            if (param.type == "literal") {
+            if (param.type == parseQuery_1.NodeType.LITERAL) {
                 functionNode.parameters.push({ node: param, result: [param.value] });
             }
             else {
-                if (param.type == "function") {
+                if (param.type == parseQuery_1.NodeType.FUNCTION) {
                     functionNode.parameters.push(addFunction(functionNode, param, path, state));
                 }
                 else {
@@ -214,7 +221,7 @@ function createQuerier() {
     function evaluateFilter(filter, path) {
         log?.debug("EVALUATING FILTER", filter, breadCrumb(path));
         if ("type" in filter) {
-            if (filter.type == "and") {
+            if (filter.type == parseQuery_1.NodeType.AND) {
                 const left = evaluateFilter(filter.left, path);
                 if (left.length == 0) {
                     return [];
@@ -222,7 +229,7 @@ function createQuerier() {
                 const r = evaluateFilter(filter.right, path);
                 return r;
             }
-            if (filter.type == "or") {
+            if (filter.type == parseQuery_1.NodeType.OR) {
                 const left = evaluateFilter(filter.left, path);
                 if (left.length > 0) {
                     return left;
@@ -230,15 +237,30 @@ function createQuerier() {
                 const r = evaluateFilter(filter.right, path);
                 return r;
             }
-            if (filter.type == "equals") {
+            if (filter.type == parseQuery_1.NodeType.EQUALS) {
                 const left = evaluateFilter(filter.left, path);
                 const right = evaluateFilter(filter.right, path);
-                const r = left.filter(x => right.includes(x));
+                // Optimize: use Set for O(1) lookups instead of O(n) includes
+                if (right.length > 3) {
+                    const rightSet = new Set(right);
+                    const r = [];
+                    for (let i = 0; i < left.length; i++) {
+                        if (rightSet.has(left[i]))
+                            r.push(left[i]);
+                    }
+                    return r;
+                }
+                // For small arrays, includes is faster than Set creation
+                const r = [];
+                for (let i = 0; i < left.length; i++) {
+                    if (right.includes(left[i]))
+                        r.push(left[i]);
+                }
                 return r;
             }
             throw new Error("Unknown filter type: " + filter.type);
         }
-        if (filter.node.type == "parent") {
+        if (filter.node.type == parseQuery_1.NodeType.PARENT) {
             const r = resolveFilterWithParent(filter.node, path);
             return r;
         }
@@ -261,7 +283,7 @@ function createQuerier() {
     function resolveFilterWithParent(node, path) {
         let startNode = node;
         let startPath = path;
-        while (startNode.type == "parent") {
+        while (startNode.type == parseQuery_1.NodeType.PARENT) {
             if (!startNode.child)
                 throw new Error("Parent filter must have child");
             if (!startPath.parentPath)
@@ -272,40 +294,80 @@ function createQuerier() {
         }
         return resolveDirectly(startNode, startPath);
     }
-    function isDefined(value) {
-        return value != undefined && value != null;
-    }
     let subQueryCounter = 0;
     const memo = new Map();
     function resolveDirectly(node, path) {
         let startNode = node;
         const startPath = path;
         let paths = [startPath];
-        while (startNode.attribute && startNode.type == "child") {
+        while (startNode.attribute && startNode.type == parseQuery_1.NodeType.CHILD) {
             const lookup = startNode.value;
             if (!lookup)
                 throw new Error("Selector must have a value");
             //log?.debug("STEP IN ", lookup, paths.map(p => breadCrumb(p)));
-            const nodes = paths.filter(nodeutils_1.isNodePath).map(n => getPrimitiveChildrenOrNodePaths(lookup, n)).flat();
-            //log?.debug("LOOKUP", lookup, path.node.type, nodes.map(n => n.node));
-            //console.log(nodes);
+            // Optimize: avoid filter().map().flat() chain - use single loop
+            const nodes = [];
+            for (let i = 0; i < paths.length; i++) {
+                const p = paths[i];
+                if (!(0, nodeutils_1.isNodePath)(p))
+                    continue;
+                const arr = getPrimitiveChildrenOrNodePaths(lookup, p);
+                for (let j = 0; j < arr.length; j++) {
+                    nodes.push(arr[j]);
+                }
+            }
             if (nodes.length == 0)
                 return [];
             paths = nodes;
             if (startNode.resolve) {
-                const resolved = paths.filter(nodeutils_1.isNodePath).map(p => resolveBinding(p)).filter(isDefined).map(p => getChildren("init", p)).flat();
+                const resolved = [];
+                for (let i = 0; i < paths.length; i++) {
+                    const p = paths[i];
+                    if (!(0, nodeutils_1.isNodePath)(p))
+                        continue;
+                    const binding = resolveBinding(p);
+                    if (!binding)
+                        continue;
+                    const children = getChildren("init", binding);
+                    for (let j = 0; j < children.length; j++) {
+                        resolved.push(children[j]);
+                    }
+                }
                 if (resolved.length > 0)
                     paths = resolved;
             }
             else if (startNode.binding) {
-                paths = paths.filter(nodeutils_1.isNodePath).map(p => resolveBinding(p)).filter(isDefined);
+                const bindings = [];
+                for (let i = 0; i < paths.length; i++) {
+                    const p = paths[i];
+                    if (!(0, nodeutils_1.isNodePath)(p))
+                        continue;
+                    const binding = resolveBinding(p);
+                    if (binding)
+                        bindings.push(binding);
+                }
+                paths = bindings;
             }
             const filter = startNode.filter;
             if (filter) {
-                paths = paths.filter(nodeutils_1.isNodePath).filter(p => travHandle({ subquery: filter }, p).subquery.length > 0);
+                const filtered = [];
+                for (let i = 0; i < paths.length; i++) {
+                    const p = paths[i];
+                    if (!(0, nodeutils_1.isNodePath)(p))
+                        continue;
+                    if (travHandle({ subquery: filter }, p).subquery.length > 0) {
+                        filtered.push(p);
+                    }
+                }
+                paths = filtered;
             }
             if (!startNode.child) {
-                return paths.map(p => (0, nodeutils_1.isPrimitive)(p) ? p : p.node);
+                const results = new Array(paths.length);
+                for (let i = 0; i < paths.length; i++) {
+                    const p = paths[i];
+                    results[i] = (0, nodeutils_1.isPrimitive)(p) ? p : p.node;
+                }
+                return results;
             }
             startNode = startNode.child;
         }
@@ -315,7 +377,10 @@ function createQuerier() {
         for (const path of paths) {
             if ((0, nodeutils_1.isNodePath)(path)) {
                 if (memo.has(startNode) && memo.get(startNode).has(path)) {
-                    result.push(...memo.get(startNode).get(path));
+                    const cached = memo.get(startNode).get(path);
+                    for (let i = 0; i < cached.length; i++) {
+                        result.push(cached[i]);
+                    }
                 }
                 else {
                     const subQueryKey = "subquery-" + subQueryCounter++;
@@ -323,7 +388,9 @@ function createQuerier() {
                     if (!memo.has(startNode))
                         memo.set(startNode, new Map());
                     memo.get(startNode)?.set(path, subQueryResult);
-                    result.push(...subQueryResult);
+                    for (let i = 0; i < subQueryResult.length; i++) {
+                        result.push(subQueryResult[i]);
+                    }
                 }
             }
         }
@@ -336,14 +403,16 @@ function createQuerier() {
         const filters = [];
         const nodeFilters = state.filtersMap[state.depth].get(fnode.node);
         if (nodeFilters) {
-            for (const f of nodeFilters) {
+            for (let i = 0; i < nodeFilters.length; i++) {
+                const f = nodeFilters[i];
                 if (f.qNode !== fnode.node)
                     continue;
                 if (f.node !== path.node)
                     continue;
                 filters.push(f);
             }
-            for (const f of filters) {
+            for (let i = 0; i < filters.length; i++) {
+                const f = filters[i];
                 if (evaluateFilter(f.filter, path).length > 0) {
                     matchingFilters.push(f);
                 }
@@ -356,7 +425,9 @@ function createQuerier() {
             const resolved = binding ? getChildren("init", binding)[0] : undefined;
             if (fnode.node.child) {
                 const result = resolveDirectly(fnode.node.child, resolved ?? path);
-                fnode.result.push(...result);
+                for (let i = 0; i < result.length; i++) {
+                    fnode.result.push(result[i]);
+                }
             }
             else {
                 fnode.result.push(path.node);
@@ -367,7 +438,9 @@ function createQuerier() {
             if (binding) {
                 if (fnode.node.child) {
                     const result = resolveDirectly(fnode.node.child, binding);
-                    fnode.result.push(...result);
+                    for (let i = 0; i < result.length; i++) {
+                        fnode.result.push(result[i]);
+                    }
                 }
                 else {
                     fnode.result.push(binding.node);
@@ -377,7 +450,7 @@ function createQuerier() {
         else if (!fnode.node.child) {
             fnode.result.push(path.node);
         }
-        else if (fnode.node.child.type == "function") {
+        else if (fnode.node.child.type == parseQuery_1.NodeType.FUNCTION) {
             const functionCallResult = state.functionCalls[state.depth].find(f => f.node == fnode.node);
             if (!functionCallResult)
                 throw new Error("Did not find expected function call for " + fnode.node.child.function);
@@ -385,12 +458,18 @@ function createQuerier() {
         }
         else if (matchingFilters.length > 0) {
             log?.debug("HAS MATCHING FILTER", fnode.result.length, matchingFilters.length, breadCrumb(path));
-            fnode.result.push(...matchingFilters.flatMap(f => f.result));
+            for (let i = 0; i < matchingFilters.length; i++) {
+                const filterResult = matchingFilters[i].result;
+                for (let j = 0; j < filterResult.length; j++) {
+                    fnode.result.push(filterResult[j]);
+                }
+            }
         }
     }
     function resolveFunctionCalls(fnode, functionCallResult, path, state) {
         const parameterResults = [];
-        for (const p of functionCallResult.parameters) {
+        for (let i = 0; i < functionCallResult.parameters.length; i++) {
+            const p = functionCallResult.parameters[i];
             if ("parameters" in p) {
                 resolveFunctionCalls(p, p, path, state);
                 parameterResults.push(p.result);
@@ -401,10 +480,17 @@ function createQuerier() {
         }
         const functionResult = exports.functions[functionCallResult.functionCall.function].fn(parameterResults);
         log?.debug("PARAMETER RESULTS", functionCallResult.functionCall.function, parameterResults, functionResult);
-        fnode.result.push(...functionResult);
+        for (let i = 0; i < functionResult.length; i++) {
+            fnode.result.push(functionResult[i]);
+        }
     }
     function travHandle(queries, root) {
-        const results = Object.fromEntries(Object.keys(queries).map(name => [name, []]));
+        // Optimize: create results object directly instead of Object.fromEntries + map
+        const results = {};
+        const queryKeys = Object.keys(queries);
+        for (let i = 0; i < queryKeys.length; i++) {
+            results[queryKeys[i]] = [];
+        }
         const state = {
             depth: 0,
             child: [[], []],
@@ -417,8 +503,18 @@ function createQuerier() {
         for (const [name, node] of Object.entries(queries)) {
             createFNodeAndAddToState(node, results[name], state);
         }
-        state.child[state.depth + 1].forEach(fnode => addPrimitiveAttributeIfMatch(fnode, root));
-        state.descendant.slice(0, state.depth + 1).forEach(fnodes => fnodes.forEach(fnode => addPrimitiveAttributeIfMatch(fnode, root)));
+        // Optimize: replace forEach with for loop
+        const childAtDepth = state.child[state.depth + 1];
+        for (let i = 0; i < childAtDepth.length; i++) {
+            addPrimitiveAttributeIfMatch(childAtDepth[i], root);
+        }
+        const descendantSlice = state.descendant.slice(0, state.depth + 1);
+        for (let i = 0; i < descendantSlice.length; i++) {
+            const fnodes = descendantSlice[i];
+            for (let j = 0; j < fnodes.length; j++) {
+                addPrimitiveAttributeIfMatch(fnodes[j], root);
+            }
+        }
         traverse(root.node, {
             enter(path, state) {
                 //log?.debug("ENTER", breadCrumb(path));
@@ -441,14 +537,20 @@ function createQuerier() {
             exit(path, state) {
                 log?.debug("EXIT", breadCrumb(path));
                 // Check for attributes as not all attributes are visited
-                state.child[state.depth + 1].forEach(fnode => addPrimitiveAttributeIfMatch(fnode, path));
-                for (const fnodes of state.descendant) {
-                    for (const fnode of fnodes) {
-                        addPrimitiveAttributeIfMatch(fnode, path);
+                // Optimize: replace forEach with for loop
+                const childAtDepthPlusOne = state.child[state.depth + 1];
+                for (let i = 0; i < childAtDepthPlusOne.length; i++) {
+                    addPrimitiveAttributeIfMatch(childAtDepthPlusOne[i], path);
+                }
+                for (let i = 0; i < state.descendant.length; i++) {
+                    const fnodes = state.descendant[i];
+                    for (let j = 0; j < fnodes.length; j++) {
+                        addPrimitiveAttributeIfMatch(fnodes[j], path);
                     }
                 }
-                for (const [fNode, path] of state.matches[state.depth]) {
-                    addResultIfTokenMatch(fNode, path, state);
+                const matchesAtDepth = state.matches[state.depth];
+                for (let i = 0; i < matchesAtDepth.length; i++) {
+                    addResultIfTokenMatch(matchesAtDepth[i][0], matchesAtDepth[i][1], state);
                 }
                 state.depth--;
                 state.child.pop();
@@ -464,6 +566,7 @@ function createQuerier() {
     function beginHandle(queries, path) {
         const rootPath = createNodePath(path, undefined, undefined, undefined, undefined);
         const r = travHandle(queries, rootPath);
+        memo.clear();
         return r;
     }
     return {
@@ -485,7 +588,13 @@ function multiQuery(code, namedQueries, returnAST) {
     const ast = typeof code == "string" ? parseSource(code) : code;
     if (ast == null)
         throw new Error("Could not pase code");
-    const queries = Object.fromEntries(Object.entries(namedQueries).map(([name, query]) => [name, (0, parseQuery_1.parse)(query)]));
+    // Optimize: parse queries directly instead of Object.fromEntries + map
+    const queries = {};
+    const entries = Object.entries(namedQueries);
+    for (let i = 0; i < entries.length; i++) {
+        const [name, queryStr] = entries[i];
+        queries[name] = (0, parseQuery_1.parse)(queryStr);
+    }
     const querier = createQuerier();
     const result = querier.beginHandle(queries, ast);
     log?.debug("Query time: ", Date.now() - start);
@@ -503,9 +612,9 @@ function parseSource(source, optimize = true) {
         return (0, meriyah_1.parseScript)(source, { module: false, next: true, ...parsingOptions, webcompat: true });
     }
 }
-const scopes = new Map();
 function createTraverser() {
     let scopeIdCounter = 0;
+    const scopes = new Map();
     let removedScopes = 0;
     const nodePathsCreated = {};
     function createScope(parentScopeId) {
@@ -553,7 +662,12 @@ function createTraverser() {
         if (key in path.node) {
             const r = path.node[key];
             if (Array.isArray(r)) {
-                return r.map((n, i) => createNodePath(n, i, key, path.scopeId, path.functionScopeId, path));
+                const len = r.length;
+                const result = new Array(len);
+                for (let i = 0; i < len; i++) {
+                    result[i] = createNodePath(r[i], i, key, path.scopeId, path.functionScopeId, path);
+                }
+                return result;
             }
             else if (r != undefined) {
                 return [createNodePath(r, key, key, path.scopeId, path.functionScopeId, path)];
@@ -564,7 +678,16 @@ function createTraverser() {
     function getPrimitiveChildren(key, path) {
         if (key in path.node) {
             const r = path.node[key];
-            return (0, utils_1.toArray)(r).filter(utils_1.isDefined).filter(nodeutils_1.isPrimitive);
+            const arr = (0, utils_1.toArray)(r);
+            // Optimize: single loop instead of chained filter()
+            const result = [];
+            for (let i = 0; i < arr.length; i++) {
+                const item = arr[i];
+                if ((0, utils_1.isDefined)(item) && (0, nodeutils_1.isPrimitive)(item)) {
+                    result.push(item);
+                }
+            }
+            return result;
         }
         return [];
     }
@@ -572,23 +695,29 @@ function createTraverser() {
         if (key in path.node) {
             const r = path.node[key];
             if (Array.isArray(r)) {
-                return r.map((n, i) => (0, nodeutils_1.isPrimitive)(n) ? n :
-                    // isLiteral(n) ? n.value as PrimitiveValue :
-                    createNodePath(n, i, key, path.scopeId, path.functionScopeId, path));
+                const len = r.length;
+                const result = new Array(len);
+                for (let i = 0; i < len; i++) {
+                    const n = r[i];
+                    result[i] = (0, nodeutils_1.isPrimitive)(n) ? n : createNodePath(n, i, key, path.scopeId, path.functionScopeId, path);
+                }
+                return result;
             }
             else if (r != undefined) {
                 return [
                     (0, nodeutils_1.isPrimitive)(r) ? r :
-                        // isLiteral(r) ? r.value as PrimitiveValue :
                         createNodePath(r, key, key, path.scopeId, path.functionScopeId, path)
                 ];
             }
         }
         return [];
     }
+    const nodePathMap = new WeakMap();
     function createNodePath(node, key, parentKey, scopeId, functionScopeId, nodePath) {
-        if (node.extra?.nodePath) {
-            const path = node.extra.nodePath;
+        if (nodePathMap.has(node)) {
+            //if (node.extra?.nodePath) {
+            //const path = node.extra.nodePath;
+            const path = nodePathMap.get(node);
             if (nodePath && (0, nodeutils_1.isExportSpecifier)(nodePath.node) && key == "exported" && path.key == "local") {
                 //Special handling for "export { someName }" as id is both local and exported
                 path.key = "exported";
@@ -614,9 +743,10 @@ function createTraverser() {
             parentKey
         };
         if ((0, nodeutils_1.isNode)(node)) {
-            node.extra = node.extra ?? {};
-            node.extra.nodePath = path;
-            Object.defineProperty(node.extra, "nodePath", { enumerable: false });
+            //node.extra = node.extra ?? {};
+            //node.extra.nodePath = path;
+            //Object.defineProperty(node.extra, "nodePath", { enumerable: false });
+            nodePathMap.set(node, path);
         }
         nodePathsCreated[node.type] = (nodePathsCreated[node.type] ?? 0) + 1;
         pathsCreated++;
@@ -670,11 +800,13 @@ function createTraverser() {
         if ((0, nodeutils_1.isScopable)(node)) {
             childScopeId = createScope(scopeId);
         }
-        for (const key of keys) {
+        for (let keyIdx = 0; keyIdx < keys.length; keyIdx++) {
+            const key = keys[keyIdx];
             const childNodes = node[key];
-            const children = (0, utils_1.toArray)(childNodes).filter(utils_1.isDefined);
-            for (const [i, child] of children.entries()) {
-                if (!(0, nodeutils_1.isNode)(child))
+            const children = (0, utils_1.toArray)(childNodes);
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if (!(0, utils_1.isDefined)(child) || !(0, nodeutils_1.isNode)(child))
                     continue;
                 const f = key === "body" && ((0, nodeutils_1.isFunctionDeclaration)(node) || (0, nodeutils_1.isFunctionExpression)(node)) ? childScopeId : functionScopeId;
                 stack.push(child);
@@ -695,20 +827,37 @@ function createTraverser() {
     }
     function traverseInner(node, visitor, scopeId, functionScopeId, state, path) {
         const nodePath = path ?? createNodePath(node, undefined, undefined, scopeId, functionScopeId);
-        const keys = nodeutils_1.VISITOR_KEYS[node.type] ?? [];
-        if (nodePath.parentPath)
-            registerBindings([nodePath.parentPath.parentPath?.node, nodePath.parentPath.node, nodePath.node].filter(utils_1.isDefined), nodePath.scopeId, nodePath.functionScopeId);
-        for (const key of keys) {
+        const keys = nodeutils_1.VISITOR_KEYS[node.type];
+        if (nodePath.parentPath) {
+            const stack = [];
+            if (nodePath.parentPath.parentPath?.node)
+                stack.push(nodePath.parentPath.parentPath.node);
+            stack.push(nodePath.parentPath.node, nodePath.node);
+            registerBindings(stack, nodePath.scopeId, nodePath.functionScopeId);
+        }
+        // Optimization: Check if we need to traverse children at all
+        // If there are no descendant queries and no child queries at next depth, skip traversal
+        const stateTyped = state;
+        const hasDescendantQueries = stateTyped.descendant && stateTyped.descendant.some(arr => arr.length > 0);
+        const hasChildQueriesAtNextDepth = stateTyped.child && stateTyped.child[stateTyped.depth + 1] && stateTyped.child[stateTyped.depth + 1].length > 0;
+        // If no queries would match in this subtree, skip traversal entirely
+        if (!hasDescendantQueries && !hasChildQueriesAtNextDepth) {
+            return;
+        }
+        for (let keyIdx = 0; keyIdx < keys.length; keyIdx++) {
+            const key = keys[keyIdx];
             const childNodes = node[key];
             const children = Array.isArray(childNodes) ? childNodes : childNodes ? [childNodes] : [];
             const nodePaths = [];
-            for (const [i, child] of children.entries()) {
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
                 if ((0, nodeutils_1.isNode)(child)) {
                     const childPath = createNodePath(child, Array.isArray(childNodes) ? i : key, key, nodePath.scopeId, nodePath.functionScopeId, nodePath);
                     nodePaths.push(childPath);
                 }
             }
-            for (const childPath of nodePaths) {
+            for (let i = 0; i < nodePaths.length; i++) {
+                const childPath = nodePaths[i];
                 visitor.enter(childPath, state);
                 traverseInner(childPath.node, visitor, nodePath.scopeId, nodePath.functionScopeId, state, childPath);
                 visitor.exit(childPath, state);