astronomical 3.0.4 → 3.0.6

package/lib/index.mjs

@@ -537,7 +537,7 @@ function parse(input) {
 }
 
 // src/index.ts
-import { parseScript } from "meriyah";
+import { parse as parseJS } from "meriyah";
 
 // src/utils.ts
 function toArray(value) {
@@ -634,6 +634,42 @@ function createQuerier() {
       result
     };
   }
+  function activateDescendant(fnode, state) {
+    state.descendant[state.depth + 1].push(fnode);
+    fnode.seq = state.seqCounter++;
+    const value = fnode.node.value;
+    if (fnode.node.attribute) {
+      state.descendantOther.push(fnode);
+      state.descendantAttr.push(fnode);
+    } else if (value == "*") {
+      state.descendantOther.push(fnode);
+    } else if (value != void 0) {
+      let bucket = state.descendantByType.get(value);
+      if (!bucket) {
+        bucket = [];
+        state.descendantByType.set(value, bucket);
+      }
+      bucket.push(fnode);
+    }
+    state.descendantActiveCount++;
+  }
+  function removeFromBucket(arr, fnode) {
+    const i = arr.lastIndexOf(fnode);
+    if (i >= 0) arr.splice(i, 1);
+  }
+  function deactivateDescendant(fnode, state) {
+    const value = fnode.node.value;
+    if (fnode.node.attribute) {
+      removeFromBucket(state.descendantOther, fnode);
+      removeFromBucket(state.descendantAttr, fnode);
+    } else if (value == "*") {
+      removeFromBucket(state.descendantOther, fnode);
+    } else if (value != void 0) {
+      const bucket = state.descendantByType.get(value);
+      if (bucket) removeFromBucket(bucket, fnode);
+    }
+    state.descendantActiveCount--;
+  }
   function addFilterChildrenToState(filter, state) {
     if ("type" in filter && (filter.type == NodeType.AND || filter.type == NodeType.OR || filter.type == NodeType.EQUALS)) {
       addFilterChildrenToState(filter.left, state);
@@ -645,7 +681,7 @@ function createQuerier() {
       }
       if (filter.node.type == NodeType.DESCENDANT) {
         log2?.debug("ADDING FILTER DESCENDANT", filter.node);
-        state.descendant[state.depth + 1].push(filter);
+        activateDescendant(filter, state);
       }
     }
   }
@@ -655,7 +691,7 @@ function createQuerier() {
     if (token.type == NodeType.CHILD) {
       state.child[state.depth + 1].push(fnode);
     } else if (token.type == NodeType.DESCENDANT) {
-      state.descendant[state.depth + 1].push(fnode);
+      activateDescendant(fnode, state);
     }
     return fnode;
   }
@@ -674,16 +710,24 @@ function createQuerier() {
   }
   function addIfTokenMatch(fnode, path, state) {
     if (!isMatch(fnode, path)) return;
+    addMatch(fnode, path, state);
+  }
+  function addMatch(fnode, path, state) {
     state.matches[state.depth].push([fnode, path]);
     if (fnode.node.filter) {
       const filter = createFilter(fnode.node.filter, []);
       const filteredResult = [];
       const f = { filter, qNode: fnode.node, node: path.node, result: filteredResult };
       state.filters[state.depth].push(f);
-      let fmap = state.filtersMap[state.depth].get(fnode.node);
+      let fmapContainer = state.filtersMap[state.depth];
+      if (!fmapContainer) {
+        fmapContainer = /* @__PURE__ */ new Map();
+        state.filtersMap[state.depth] = fmapContainer;
+      }
+      let fmap = fmapContainer.get(fnode.node);
       if (!fmap) {
         fmap = [];
-        state.filtersMap[state.depth].set(fnode.node, fmap);
+        fmapContainer.set(fnode.node, fmap);
       }
       fmap.push(f);
       addFilterChildrenToState(filter, state);
@@ -889,7 +933,8 @@ function createQuerier() {
   function addResultIfTokenMatch(fnode, path, state) {
     const matchingFilters = [];
     const filters = [];
-    const nodeFilters = state.filtersMap[state.depth].get(fnode.node);
+    const fmapContainer = state.filtersMap[state.depth];
+    const nodeFilters = fmapContainer ? fmapContainer.get(fnode.node) : void 0;
     if (nodeFilters) {
       for (let i = 0; i < nodeFilters.length; i++) {
         const f = nodeFilters[i];
@@ -987,9 +1032,14 @@ function createQuerier() {
       child: [[], []],
       descendant: [[], []],
       filters: [[], []],
-      filtersMap: [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()],
+      filtersMap: [void 0, void 0],
       matches: [[]],
-      functionCalls: [[]]
+      functionCalls: [[]],
+      descendantByType: /* @__PURE__ */ new Map(),
+      descendantOther: [],
+      descendantAttr: [],
+      descendantActiveCount: 0,
+      seqCounter: 0
     };
     for (const [name, node] of Object.entries(queries)) {
       createFNodeAndAddToState(node, results[name], state);
@@ -998,12 +1048,8 @@ function createQuerier() {
     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);
-      }
+    for (let i = 0; i < state.descendantAttr.length; i++) {
+      addPrimitiveAttributeIfMatch(state.descendantAttr[i], root);
     }
     traverse(root.node, {
       enter(path, state2) {
@@ -1011,15 +1057,31 @@ function createQuerier() {
         state2.child.push([]);
         state2.descendant.push([]);
         state2.filters.push([]);
-        state2.filtersMap.push(/* @__PURE__ */ new Map());
+        state2.filtersMap.push(void 0);
         state2.matches.push([]);
         state2.functionCalls.push([]);
         for (const fnode of state2.child[state2.depth]) {
           addIfTokenMatch(fnode, path, state2);
         }
-        for (const fnodes of state2.descendant.slice(0, state2.depth + 1)) {
-          for (const fnode of fnodes) {
-            addIfTokenMatch(fnode, path, state2);
+        const bucket = state2.descendantByType.get(path.node.type);
+        const other = state2.descendantOther;
+        const bucketLen = bucket ? bucket.length : 0;
+        const otherLen = other.length;
+        if (otherLen == 0) {
+          for (let i = 0; i < bucketLen; i++) {
+            addMatch(bucket[i], path, state2);
+          }
+        } else if (bucketLen == 0) {
+          for (let i = 0; i < otherLen; i++) {
+            addIfTokenMatch(other[i], path, state2);
+          }
+        } else {
+          const cands = [];
+          for (let i = 0; i < bucketLen; i++) cands.push(bucket[i]);
+          for (let i = 0; i < otherLen; i++) cands.push(other[i]);
+          cands.sort((a, b) => a.seq - b.seq);
+          for (let i = 0; i < cands.length; i++) {
+            addIfTokenMatch(cands[i], path, state2);
           }
         }
       },
@@ -1029,16 +1091,17 @@ function createQuerier() {
         for (let i = 0; i < childAtDepthPlusOne.length; i++) {
           addPrimitiveAttributeIfMatch(childAtDepthPlusOne[i], path);
         }
-        for (let i = 0; i < state2.descendant.length; i++) {
-          const fnodes = state2.descendant[i];
-          for (let j = 0; j < fnodes.length; j++) {
-            addPrimitiveAttributeIfMatch(fnodes[j], path);
-          }
+        for (let i = 0; i < state2.descendantAttr.length; i++) {
+          addPrimitiveAttributeIfMatch(state2.descendantAttr[i], path);
         }
         const matchesAtDepth = state2.matches[state2.depth];
         for (let i = 0; i < matchesAtDepth.length; i++) {
           addResultIfTokenMatch(matchesAtDepth[i][0], matchesAtDepth[i][1], state2);
         }
+        const leavingDescendants = state2.descendant[state2.descendant.length - 1];
+        for (let i = 0; i < leavingDescendants.length; i++) {
+          deactivateDescendant(leavingDescendants[i], state2);
+        }
         state2.depth--;
         state2.child.pop();
         state2.descendant.pop();
@@ -1090,16 +1153,17 @@ function multiQuery(code, namedQueries, returnAST) {
 }
 function parseSource(source, optimize = true) {
   const parsingOptions = optimize ? { loc: false, ranges: false } : { loc: true, ranges: true };
+  const base = { next: true, validateRegex: false, ...parsingOptions };
   try {
-    return parseScript(source, { module: true, next: true, ...parsingOptions });
+    return parseJS(source, { ...base, sourceType: "module" });
   } catch {
     try {
-      return parseScript(source, { module: false, next: true, ...parsingOptions, webcompat: true });
+      return parseJS(source, { ...base, sourceType: "script", webcompat: true });
     } catch {
       try {
-        return parseScript(source, { module: true, next: true, ...parsingOptions, jsx: true });
+        return parseJS(source, { ...base, sourceType: "module", jsx: true });
       } catch {
-        return parseScript(source, { module: false, next: true, ...parsingOptions, webcompat: true, jsx: true });
+        return parseJS(source, { ...base, sourceType: "script", webcompat: true, jsx: true });
       }
     }
   }
@@ -1295,7 +1359,7 @@ function createTraverser() {
       registerBindings(stack, nodePath.scopeId, nodePath.functionScopeId);
     }
     const stateTyped = state;
-    const hasDescendantQueries = stateTyped.descendant && stateTyped.descendant.some((arr) => arr.length > 0);
+    const hasDescendantQueries = stateTyped.descendantActiveCount > 0;
     const hasChildQueriesAtNextDepth = stateTyped.child && stateTyped.child[stateTyped.depth + 1] && stateTyped.child[stateTyped.depth + 1].length > 0;
     if (!hasDescendantQueries && !hasChildQueriesAtNextDepth) {
       return;
@@ -1303,17 +1367,18 @@ function createTraverser() {
     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 (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        if (isNode(child)) {
-          const childPath = createNodePath(child, Array.isArray(childNodes) ? i : key, key, nodePath.scopeId, nodePath.functionScopeId, nodePath);
-          nodePaths.push(childPath);
+      if (childNodes == void 0) continue;
+      if (Array.isArray(childNodes)) {
+        for (let i = 0; i < childNodes.length; i++) {
+          const child = childNodes[i];
+          if (!isNode(child)) continue;
+          const childPath = createNodePath(child, i, key, nodePath.scopeId, nodePath.functionScopeId, nodePath);
+          visitor.enter(childPath, state);
+          traverseInner(childPath.node, visitor, nodePath.scopeId, nodePath.functionScopeId, state, childPath);
+          visitor.exit(childPath, state);
         }
-      }
-      for (let i = 0; i < nodePaths.length; i++) {
-        const childPath = nodePaths[i];
+      } else if (isNode(childNodes)) {
+        const childPath = createNodePath(childNodes, key, key, nodePath.scopeId, nodePath.functionScopeId, nodePath);
         visitor.enter(childPath, state);
         traverseInner(childPath.node, visitor, nodePath.scopeId, nodePath.functionScopeId, state, childPath);
         visitor.exit(childPath, state);