astronomical 1.0.0-beta.12 → 1.0.0-beta.14

package/lib/cjs/index.js

@@ -1,32 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSource = exports.multiQuery = exports.query = exports.isAvailableFunction = exports.functions = void 0;
-const traverse_1 = __importStar(require("./traverse"));
+const traverse_1 = __importDefault(require("./traverse"));
 const parseQuery_1 = require("./parseQuery");
 const meriyah_1 = require("meriyah");
+const nodeutils_1 = require("./nodeutils");
 const debugLogEnabled = false;
 const log = {
     debug: (...args) => {
@@ -83,10 +64,6 @@ function isAvailableFunction(name) {
     return functionNames.includes(name);
 }
 exports.isAvailableFunction = isAvailableFunction;
-function beginHandle(queries, path) {
-    const rootPath = (0, traverse_1.createNodePath)(path, undefined, undefined, undefined);
-    return travHandle(queries, rootPath);
-}
 function breadCrumb(path) {
     return {
         valueOf() {
@@ -96,349 +73,369 @@ function breadCrumb(path) {
         }
     };
 }
-function createFilter(filter, filterResult) {
-    if (filter.type == "and" || filter.type == "or" || filter.type == "equals") {
-        return {
-            type: filter.type,
-            left: createFilter(filter.left, []),
-            right: createFilter(filter.right, [])
-        };
+function createQuerier() {
+    const traverser = (0, traverse_1.default)();
+    const { getChildren, getBinding, createNodePath, traverse } = traverser;
+    function createFilter(filter, filterResult) {
+        if (filter.type == "and" || filter.type == "or" || filter.type == "equals") {
+            return {
+                type: filter.type,
+                left: createFilter(filter.left, []),
+                right: createFilter(filter.right, [])
+            };
+        }
+        else if (filter.type == "literal") {
+            const r = [filter.value];
+            return {
+                node: filter,
+                result: r
+            };
+        }
+        return createFNode(filter, filterResult);
     }
-    else if (filter.type == "literal") {
-        const r = [filter.value];
+    function createFNode(token, result) {
         return {
-            node: filter,
-            result: r
+            node: token,
+            result: result
         };
     }
-    return createFNode(filter, filterResult);
-}
-function createFNode(token, result) {
-    return {
-        node: token,
-        result: result
-    };
-}
-function addFilterChildrenToState(filter, state) {
-    if ("type" in filter && (filter.type == "and" || filter.type == "or" || filter.type == "equals")) {
-        addFilterChildrenToState(filter.left, state);
-        addFilterChildrenToState(filter.right, state);
-    }
-    else if ("node" in filter) {
-        if (filter.node.type == "child") {
-            log.debug("ADDING FILTER CHILD", filter.node);
-            state.child[state.depth + 1].push(filter);
+    function addFilterChildrenToState(filter, state) {
+        if ("type" in filter && (filter.type == "and" || filter.type == "or" || filter.type == "equals")) {
+            addFilterChildrenToState(filter.left, state);
+            addFilterChildrenToState(filter.right, state);
         }
-        if (filter.node.type == "descendant") {
-            log.debug("ADDING FILTER DESCENDANT", filter.node);
-            state.descendant[state.depth + 1].push(filter);
+        else if ("node" in filter) {
+            if (filter.node.type == "child") {
+                log.debug("ADDING FILTER CHILD", filter.node);
+                state.child[state.depth + 1].push(filter);
+            }
+            if (filter.node.type == "descendant") {
+                log.debug("ADDING FILTER DESCENDANT", filter.node);
+                state.descendant[state.depth + 1].push(filter);
+            }
         }
     }
-}
-function createFNodeAndAddToState(token, result, state) {
-    log.debug("ADDING FNODE", token);
-    const fnode = createFNode(token, result);
-    if (token.type == "child") {
-        state.child[state.depth + 1].push(fnode);
-    }
-    else if (token.type == "descendant") {
-        state.descendant[state.depth + 1].push(fnode);
+    function createFNodeAndAddToState(token, result, state) {
+        log.debug("ADDING FNODE", token);
+        const fnode = createFNode(token, result);
+        if (token.type == "child") {
+            state.child[state.depth + 1].push(fnode);
+        }
+        else if (token.type == "descendant") {
+            state.descendant[state.depth + 1].push(fnode);
+        }
+        return fnode;
     }
-    return fnode;
-}
-function isMatch(fnode, path) {
-    if (fnode.node.attribute) {
-        const m = fnode.node.value == path.parentKey || fnode.node.value == path.key;
+    function isMatch(fnode, path) {
+        if (fnode.node.attribute) {
+            const m = fnode.node.value == path.parentKey || fnode.node.value == path.key;
+            if (m)
+                log.debug("ATTR MATCH", fnode.node.value, breadCrumb(path));
+            return m;
+        }
+        if (fnode.node.value == "*") {
+            return true;
+        }
+        const m = fnode.node.value == path.node.type;
         if (m)
-            log.debug("ATTR MATCH", fnode.node.value, breadCrumb(path));
+            log.debug("NODE MATCH", fnode.node.value, breadCrumb(path));
         return m;
     }
-    if (fnode.node.value == "*") {
-        return true;
-    }
-    const m = fnode.node.value == path.node.type;
-    if (m)
-        log.debug("NODE MATCH", fnode.node.value, breadCrumb(path));
-    return m;
-}
-function addIfTokenMatch(fnode, path, state) {
-    if (!isMatch(fnode, path))
-        return;
-    state.matches[state.depth].push([fnode, path]);
-    if (fnode.node.filter) {
-        const filter = createFilter(fnode.node.filter, []);
-        const filteredResult = [];
-        state.filters[state.depth].push({ filter: filter, qNode: fnode.node, node: path.node, result: filteredResult });
-        addFilterChildrenToState(filter, state);
-        const child = fnode.node.child;
-        if (child) {
-            if (child.type == "function") {
+    function addIfTokenMatch(fnode, path, state) {
+        if (!isMatch(fnode, path))
+            return;
+        state.matches[state.depth].push([fnode, path]);
+        if (fnode.node.filter) {
+            const filter = createFilter(fnode.node.filter, []);
+            const filteredResult = [];
+            state.filters[state.depth].push({ filter: filter, qNode: fnode.node, node: path.node, result: filteredResult });
+            addFilterChildrenToState(filter, state);
+            const child = fnode.node.child;
+            if (child) {
+                if (child.type == "function") {
+                    const fr = addFunction(fnode, child, path, state);
+                    state.functionCalls[state.depth].push(fr);
+                }
+                else {
+                    createFNodeAndAddToState(child, filteredResult, state);
+                }
+            }
+        }
+        else {
+            const child = fnode.node.child;
+            if (child?.type == "function") {
                 const fr = addFunction(fnode, child, path, state);
                 state.functionCalls[state.depth].push(fr);
             }
-            else {
-                createFNodeAndAddToState(child, filteredResult, state);
+            else if (child && !fnode.node.binding && !fnode.node.resolve) {
+                createFNodeAndAddToState(child, fnode.result, state);
             }
         }
     }
-    else {
-        const child = fnode.node.child;
-        if (child?.type == "function") {
-            const fr = addFunction(fnode, child, path, state);
-            state.functionCalls[state.depth].push(fr);
-        }
-        else if (child && !fnode.node.binding && !fnode.node.resolve) {
-            createFNodeAndAddToState(child, fnode.result, state);
-        }
-    }
-}
-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") {
-            functionNode.parameters.push({ node: param, result: [param.value] });
-        }
-        else {
-            if (param.type == "function") {
-                functionNode.parameters.push(addFunction(functionNode, param, path, state));
+    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") {
+                functionNode.parameters.push({ node: param, result: [param.value] });
             }
             else {
-                functionNode.parameters.push(createFNodeAndAddToState(param, [], state));
+                if (param.type == "function") {
+                    functionNode.parameters.push(addFunction(functionNode, param, path, state));
+                }
+                else {
+                    functionNode.parameters.push(createFNodeAndAddToState(param, [], state));
+                }
             }
         }
+        return functionNode;
     }
-    return functionNode;
-}
-function isPrimitive(value) {
-    return typeof value == "string" || typeof value == "number" || typeof value == "boolean";
-}
-function addPrimitiveAttributeIfMatch(fnode, path) {
-    if (!fnode.node.attribute || !fnode.node.value)
-        return;
-    if (fnode.node.child || fnode.node.filter)
-        return;
-    if (!Object.hasOwn(path.node, fnode.node.value))
-        return;
-    const lookup = path.get(fnode.node.value);
-    const nodes = (Array.isArray(lookup) ? lookup : [lookup])
-        .filter(n => n.node != undefined)
-        .filter(n => isPrimitive(n.node));
-    if (nodes.length == 0)
-        return;
-    log.debug("PRIMITIVE", fnode.node.value, nodes.map(n => n.node));
-    fnode.result.push(...nodes.map(n => n.node));
-}
-function evaluateFilter(filter, path) {
-    log.debug("EVALUATING FILTER", filter);
-    if ("type" in filter) {
-        if (filter.type == "and") {
-            const left = evaluateFilter(filter.left, path);
-            if (left.length == 0)
-                return [];
-            return evaluateFilter(filter.right, path);
+    function addPrimitiveAttributeIfMatch(fnode, path) {
+        if (!fnode.node.attribute || !fnode.node.value)
+            return;
+        if (fnode.node.child || fnode.node.filter)
+            return;
+        if (!Object.hasOwn(path.node, fnode.node.value))
+            return;
+        const lookup = getChildren(fnode.node.value, path);
+        const nodes = toArray(lookup)
+            .filter(n => n.node != undefined)
+            .filter(n => (0, nodeutils_1.isPrimitive)(n.node));
+        if (nodes.length == 0)
+            return;
+        log.debug("PRIMITIVE", fnode.node.value, nodes.map(n => n.node));
+        fnode.result.push(...nodes.map(n => n.node));
+    }
+    function evaluateFilter(filter, path) {
+        log.debug("EVALUATING FILTER", filter, breadCrumb(path));
+        if ("type" in filter) {
+            if (filter.type == "and") {
+                const left = evaluateFilter(filter.left, path);
+                if (left.length == 0)
+                    return [];
+                return evaluateFilter(filter.right, path);
+            }
+            if (filter.type == "or") {
+                const left = evaluateFilter(filter.left, path);
+                if (left.length > 0)
+                    return left;
+                return evaluateFilter(filter.right, path);
+            }
+            if (filter.type == "equals") {
+                const left = evaluateFilter(filter.left, path);
+                const right = evaluateFilter(filter.right, path);
+                return left.filter(x => right.includes(x));
+            }
+            throw new Error("Unknown filter type: " + filter.type);
         }
-        if (filter.type == "or") {
-            const left = evaluateFilter(filter.left, path);
-            if (left.length > 0)
-                return left;
-            return evaluateFilter(filter.right, path);
+        if (filter.node.type == "parent") {
+            return resolveFilterWithParent(filter.node, path);
         }
-        if (filter.type == "equals") {
-            const left = evaluateFilter(filter.left, path);
-            const right = evaluateFilter(filter.right, path);
-            return left.filter(x => right.includes(x));
+        return filter.result;
+    }
+    function resolveBinding(path) {
+        if (!(0, nodeutils_1.isIdentifier)(path.node))
+            return undefined;
+        log.debug("RESOLVING BINDING FOR ", path.node);
+        const name = path.node.name;
+        if (name == undefined || typeof name != "string")
+            return undefined;
+        //const binding = path.scope.getBinding(name);
+        const binding = getBinding(path.scopeId, name);
+        if (!binding)
+            return undefined;
+        log.debug("THIS IS THE BINDING", binding);
+        return binding.path;
+    }
+    function resolveFilterWithParent(node, path) {
+        let startNode = node;
+        let startPath = path;
+        while (startNode.type == "parent") {
+            if (!startNode.child)
+                throw new Error("Parent filter must have child");
+            if (!startPath.parentPath)
+                return [];
+            log.debug("STEP OUT", startNode, breadCrumb(startPath));
+            startNode = startNode.child;
+            startPath = startPath.parentPath;
         }
-        throw new Error("Unknown filter type: " + filter.type);
+        return resolveDirectly(startNode, startPath);
     }
-    if (filter.node.type == "parent") {
-        return resolveFilterWithParent(filter.node, path);
+    const toArray = (value) => Array.isArray(value) ? value : [value];
+    function isDefined(value) {
+        return value != undefined && value != null;
     }
-    return filter.result;
-}
-function isIdentifier(node) {
-    return node.type == "Identifier";
-}
-function resolveBinding(path) {
-    if (!isIdentifier(path.node))
-        return undefined;
-    log.debug("RESOLVING BINDING FOR ", path.node);
-    const name = path.node.name;
-    if (name == undefined || typeof name != "string")
-        return undefined;
-    //const binding = path.scope.getBinding(name);
-    const binding = (0, traverse_1.getBinding)(path.scopeId, name);
-    if (!binding)
-        return undefined;
-    log.debug("THIS IS THE BINDING", binding);
-    return binding.path;
-}
-function resolveFilterWithParent(node, path) {
-    let startNode = node;
-    let startPath = path;
-    while (startNode.type == "parent") {
-        if (!startNode.child)
-            throw new Error("Parent filter must have child");
-        if (!startPath.parentPath)
-            return [];
-        log.debug("STEP OUT", startNode, breadCrumb(startPath));
-        startNode = startNode.child;
-        startPath = startPath.parentPath;
+    let subQueryCounter = 0;
+    function resolveDirectly(node, path) {
+        let startNode = node;
+        const startPath = path;
+        let paths = [startPath];
+        while (startNode.attribute && startNode.type == "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.map(n => getChildren(lookup, n)).map(toArray).flat().filter(n => n.node != undefined);
+            log.debug("LOOKUP", lookup, path.node.type, nodes.map(n => n.node), nodes.filter(n => n.node == undefined));
+            if (nodes.length == 0)
+                return [];
+            paths = nodes;
+            if (startNode.resolve) {
+                const resolved = paths.map(p => resolveBinding(p)).filter(isDefined).map(p => getChildren("init", p)).flatMap(toArray).filter(p => p.node != undefined).filter(isDefined);
+                if (resolved.length > 0)
+                    paths = resolved;
+            }
+            else if (startNode.binding) {
+                paths = paths.map(p => resolveBinding(p)).filter(isDefined);
+            }
+            const filter = startNode.filter;
+            if (filter) {
+                paths = paths.filter(p => travHandle({ subquery: filter }, p).subquery.length > 0);
+            }
+            if (!startNode.child) {
+                return paths.map(p => p.node);
+            }
+            startNode = startNode.child;
+        }
+        log.debug("DIRECT TRAV RESOLVE", startNode, paths.map(p => breadCrumb(p)));
+        const result = paths.flatMap(path => {
+            const subQueryKey = "subquery-" + subQueryCounter++;
+            return travHandle({ [subQueryKey]: startNode }, path)[subQueryKey];
+        });
+        log.debug("DIRECT TRAV RESOLVE RESULT", result);
+        return result;
     }
-    return resolveDirectly(startNode, startPath);
-}
-const toArray = (value) => Array.isArray(value) ? value : [value];
-function isDefined(value) {
-    return value != undefined && value != null;
-}
-let subQueryCounter = 0;
-function resolveDirectly(node, path) {
-    let startNode = node;
-    const startPath = path;
-    let paths = [startPath];
-    while (startNode.attribute) {
-        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.map(n => n.get(lookup)).map(toArray).flat().filter(n => n.node != undefined);
-        log.debug("LOOKUP", lookup, nodes.map(n => n.node), nodes.filter(n => n.node == undefined));
-        if (nodes.length == 0)
-            return [];
-        paths = nodes;
-        if (startNode.resolve) {
-            const resolved = paths.map(p => resolveBinding(p)).filter(isDefined).map(p => p.get("init")).flatMap(toArray).filter(p => p.node != undefined).filter(isDefined);
-            if (resolved.length > 0)
-                paths = resolved;
+    function addResultIfTokenMatch(fnode, path, state) {
+        const filters = state.filters[state.depth].filter(f => f.node == path.node && f.qNode == fnode.node);
+        const matchingFilters = filters.filter(f => evaluateFilter(f.filter, path).length > 0);
+        log.debug("RESULT MATCH", fnode.node.value, breadCrumb(path), filters.length, matchingFilters.length);
+        if (filters.length > 0 && matchingFilters.length == 0)
+            return;
+        if (fnode.node.resolve) {
+            const binding = resolveBinding(path);
+            const resolved = binding ? getChildren("init", binding)[0] : undefined;
+            if (fnode.node.child) {
+                const result = resolveDirectly(fnode.node.child, resolved ?? path);
+                fnode.result.push(...result);
+            }
+            else {
+                fnode.result.push(path.node);
+            }
         }
-        else if (startNode.binding) {
-            paths = paths.map(p => resolveBinding(p)).filter(isDefined);
+        else if (fnode.node.binding) {
+            const binding = resolveBinding(path);
+            if (binding) {
+                if (fnode.node.child) {
+                    const result = resolveDirectly(fnode.node.child, binding);
+                    fnode.result.push(...result);
+                }
+                else {
+                    fnode.result.push(binding.node);
+                }
+            }
         }
-        if (!startNode.child) {
-            return paths.map(p => p.node);
+        else if (!fnode.node.child) {
+            fnode.result.push(path.node);
         }
-        startNode = startNode.child;
-    }
-    log.debug("DIRECT TRAV RESOLVE", startNode, paths.map(p => breadCrumb(p)));
-    const result = paths.flatMap(path => {
-        const subQueryKey = "subquery-" + subQueryCounter++;
-        return travHandle({ [subQueryKey]: startNode }, path)[subQueryKey];
-    });
-    log.debug("DIRECT TRAV RESOLVE RESULT", result);
-    return result;
-}
-function addResultIfTokenMatch(fnode, path, state) {
-    const filters = state.filters[state.depth].filter(f => f.node == path.node && f.qNode == fnode.node);
-    const matchingFilters = filters.filter(f => evaluateFilter(f.filter, path).length > 0);
-    log.debug("RESULT MATCH", fnode.node.value, breadCrumb(path), filters.length, matchingFilters.length);
-    if (filters.length > 0 && matchingFilters.length == 0)
-        return;
-    if (fnode.node.resolve) {
-        const [resolved] = toArray(resolveBinding(path)?.get("init")).filter(isDefined).filter(p => p.node != undefined);
-        if (fnode.node.child) {
-            const result = resolveDirectly(fnode.node.child, resolved ?? path);
-            fnode.result.push(...result);
+        else if (fnode.node.child.type == "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);
+            resolveFunctionCalls(fnode, functionCallResult, path, state);
         }
-        else {
-            fnode.result.push(path.node);
+        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));
         }
     }
-    else if (fnode.node.binding) {
-        const binding = resolveBinding(path);
-        if (binding) {
-            if (fnode.node.child) {
-                const result = resolveDirectly(fnode.node.child, binding);
-                fnode.result.push(...result);
+    function resolveFunctionCalls(fnode, functionCallResult, path, state) {
+        const parameterResults = [];
+        for (const p of functionCallResult.parameters) {
+            if ("parameters" in p) {
+                resolveFunctionCalls(p, p, path, state);
+                parameterResults.push(p.result);
             }
             else {
-                fnode.result.push(binding.node);
+                parameterResults.push(p.result);
             }
         }
+        const functionResult = exports.functions[functionCallResult.functionCall.function].fn(parameterResults);
+        log.debug("PARAMETER RESULTS", functionCallResult.functionCall.function, parameterResults, functionResult);
+        fnode.result.push(...functionResult);
     }
-    else if (!fnode.node.child) {
-        fnode.result.push(path.node);
-    }
-    else if (fnode.node.child.type == "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);
-        resolveFunctionCalls(fnode, functionCallResult, path, state);
-    }
-    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));
+    function travHandle(queries, root) {
+        const results = Object.fromEntries(Object.keys(queries).map(name => [name, []]));
+        const state = {
+            depth: 0,
+            child: [[], []],
+            descendant: [[], []],
+            filters: [[], []],
+            matches: [[]],
+            functionCalls: [[]]
+        };
+        Object.entries(queries).forEach(([name, node]) => {
+            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)));
+        traverse(root.node, {
+            enter(path, state) {
+                log.debug("ENTER", breadCrumb(path));
+                state.depth++;
+                state.child.push([]);
+                state.descendant.push([]);
+                state.filters.push([]);
+                state.matches.push([]);
+                state.functionCalls.push([]);
+                state.child[state.depth].forEach(fnode => addIfTokenMatch(fnode, path, state));
+                state.descendant.slice(0, state.depth + 1).forEach(fnodes => fnodes.forEach(fnode => addIfTokenMatch(fnode, path, state)));
+            },
+            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));
+                state.descendant.forEach(fnodes => fnodes.forEach(fnode => addPrimitiveAttributeIfMatch(fnode, path)));
+                state.matches[state.depth].forEach(([fNode, path]) => addResultIfTokenMatch(fNode, path, state));
+                state.depth--;
+                state.child.pop();
+                state.descendant.pop();
+                state.filters.pop();
+                state.matches.pop();
+                state.functionCalls.pop();
+            }
+        }, root.scopeId, state, root);
+        return results;
     }
-}
-function resolveFunctionCalls(fnode, functionCallResult, path, state) {
-    const parameterResults = [];
-    for (const p of functionCallResult.parameters) {
-        if ("parameters" in p) {
-            resolveFunctionCalls(p, p, path, state);
-            parameterResults.push(p.result);
-        }
-        else {
-            parameterResults.push(p.result);
-        }
+    function beginHandle(queries, path) {
+        const rootPath = createNodePath(path, undefined, undefined, undefined);
+        return travHandle(queries, rootPath);
     }
-    const functionResult = exports.functions[functionCallResult.functionCall.function].fn(parameterResults);
-    log.debug("PARAMETER RESULTS", functionCallResult.functionCall.function, parameterResults, functionResult);
-    fnode.result.push(...functionResult);
-}
-function travHandle(queries, root) {
-    const results = Object.fromEntries(Object.keys(queries).map(name => [name, []]));
-    const state = {
-        depth: 0,
-        child: [[], []],
-        descendant: [[], []],
-        filters: [[], []],
-        matches: [[]],
-        functionCalls: [[]]
+    return {
+        beginHandle
     };
-    Object.entries(queries).forEach(([name, node]) => {
-        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)));
-    (0, traverse_1.default)(root.node, {
-        enter(path, state) {
-            log.debug("ENTER", breadCrumb(path));
-            state.depth++;
-            state.child.push([]);
-            state.descendant.push([]);
-            state.filters.push([]);
-            state.matches.push([]);
-            state.functionCalls.push([]);
-            state.child[state.depth].forEach(fnode => addIfTokenMatch(fnode, path, state));
-            state.descendant.slice(0, state.depth + 1).forEach(fnodes => fnodes.forEach(fnode => addIfTokenMatch(fnode, path, state)));
-        },
-        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));
-            state.descendant.forEach(fnodes => fnodes.forEach(fnode => addPrimitiveAttributeIfMatch(fnode, path)));
-            state.matches[state.depth].forEach(([fNode, path]) => addResultIfTokenMatch(fNode, path, state));
-            state.depth--;
-            state.child.pop();
-            state.descendant.pop();
-            state.filters.pop();
-            state.matches.pop();
-            state.functionCalls.pop();
-        }
-    }, root.scopeId, state, root);
-    return results;
 }
 const defaultKey = "__default__";
-function query(code, query) {
-    return multiQuery(code, { [defaultKey]: query })[defaultKey];
+function query(code, query, returnAST) {
+    const result = multiQuery(code, { [defaultKey]: query }, returnAST);
+    if (returnAST) {
+        const r = result[defaultKey];
+        r.__AST = result.__AST;
+        return r;
+    }
+    return result[defaultKey];
 }
 exports.query = query;
-function multiQuery(code, namedQueries) {
+function multiQuery(code, namedQueries, returnAST) {
     const start = Date.now();
     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)]));
-    const result = beginHandle(queries, ast);
+    const querier = createQuerier();
+    const result = querier.beginHandle(queries, ast);
     log.debug("Query time: ", Date.now() - start);
+    if (returnAST) {
+        return { ...result, __AST: ast };
+    }
     return result;
 }
 exports.multiQuery = multiQuery;