astronomical 1.0.0-beta.12

package/lib/esm/parseQuery.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.tokenize = void 0;
+const _1 = require(".");
+const nodeutils_1 = require("./nodeutils");
+const debugLogEnabled = false;
+const log = {
+    debug: (...args) => {
+        if (debugLogEnabled)
+            console.debug(...args);
+    }
+};
+const supportedIdentifiers = Object.fromEntries(Object.keys(nodeutils_1.VISITOR_KEYS).map(k => [k, k]));
+function isIdentifierToken(token) {
+    if (token == undefined)
+        return false;
+    if (token.type != "identifier" && token.type != "wildcard")
+        return false;
+    if (!token.value)
+        return false;
+    if (!(token.value in supportedIdentifiers) && token.value != "*") {
+        throw new Error("Unsupported identifier: " + token.value);
+    }
+    ;
+    return true;
+}
+const whitespace = " \n\r\t";
+function isCharacter(c) {
+    const charcode = c.charCodeAt(0);
+    return (charcode >= 65 && charcode <= 90) || (charcode >= 97 && charcode <= 122);
+}
+function isInteger(c) {
+    const charcode = c.charCodeAt(0);
+    return (charcode >= 48 && charcode <= 57);
+}
+function tokenize(input) {
+    let s = 0;
+    const result = [];
+    while (s < input.length) {
+        while (whitespace.includes(input[s]))
+            s++;
+        if (s >= input.length)
+            break;
+        if (input[s] == "/") {
+            if (input[s + 1] == "/") {
+                result.push({ type: "descendant" });
+                s += 2;
+                continue;
+            }
+            result.push({ type: "child" });
+            s++;
+            continue;
+        }
+        if (input[s] == ":") {
+            result.push({ type: "attributeSelector" });
+            s++;
+            continue;
+        }
+        if (input[s] == "$" && input[s + 1] == "$") {
+            result.push({ type: "resolveSelector" });
+            s += 2;
+            continue;
+        }
+        if (input[s] == "$") {
+            result.push({ type: "bindingSelector" });
+            s++;
+            continue;
+        }
+        if (input[s] == "[") {
+            result.push({ type: "filterBegin" });
+            s++;
+            continue;
+        }
+        if (input[s] == "]") {
+            result.push({ type: "filterEnd" });
+            s++;
+            continue;
+        }
+        if (input[s] == ",") {
+            result.push({ type: "separator" });
+            s++;
+            continue;
+        }
+        if (input[s] == "(") {
+            result.push({ type: "parametersBegin" });
+            s++;
+            continue;
+        }
+        if (input[s] == "f" && input[s + 1] == "n" && input[s + 2] == ":") {
+            result.push({ type: "function" });
+            s += 3;
+            continue;
+        }
+        if (input[s] == ")") {
+            result.push({ type: "parametersEnd" });
+            s++;
+            continue;
+        }
+        if (input[s] == "&" && input[s + 1] == "&") {
+            result.push({ type: "and" });
+            s += 2;
+            continue;
+        }
+        if (input[s] == "|" && input[s + 1] == "|") {
+            result.push({ type: "or" });
+            s += 2;
+            continue;
+        }
+        if (input[s] == "=" && input[s + 1] == "=") {
+            result.push({ type: "eq" });
+            s += 2;
+            continue;
+        }
+        if (input[s] == "'" || input[s] == '"') {
+            const begin = input[s];
+            const start = s;
+            s++;
+            while (s < input.length && input[s] != begin)
+                s++;
+            result.push({ type: "literal", value: input.slice(start + 1, s) });
+            s++;
+            continue;
+        }
+        if (input[s] == "." && input[s + 1] == ".") {
+            result.push({ type: "parent" });
+            s += 2;
+            continue;
+        }
+        if (input[s] == "*") {
+            result.push({ type: "wildcard", value: "*" });
+            s++;
+            continue;
+        }
+        if (isCharacter(input[s])) {
+            const start = s;
+            while (s < input.length && isCharacter(input[s]))
+                s++;
+            result.push({ type: "identifier", value: input.slice(start, s) });
+            continue;
+        }
+        if (isInteger(input[s])) {
+            const start = s;
+            while (s < input.length && isInteger(input[s]))
+                s++;
+            result.push({ type: "literal", value: input.slice(start, s) });
+            continue;
+        }
+        throw new Error("Unexpected token: " + input[s]);
+    }
+    return result;
+}
+exports.tokenize = tokenize;
+function buildFilter(tokens) {
+    log.debug("BUILD FILTER", tokens);
+    tokens.shift();
+    const p = buildTree(tokens);
+    const next = tokens[0];
+    if (next.type == "and") {
+        return {
+            type: "and",
+            left: p,
+            right: buildFilter(tokens)
+        };
+    }
+    if (next.type == "or") {
+        return {
+            type: "or",
+            left: p,
+            right: buildFilter(tokens)
+        };
+    }
+    if (next.type == "eq") {
+        const right = buildFilter(tokens);
+        if (right.type == "or" || right.type == "and") {
+            return {
+                type: right.type,
+                left: {
+                    type: "equals",
+                    left: p,
+                    right: right.left
+                },
+                right: right.right
+            };
+        }
+        if (right.type == "equals")
+            throw new Error("Unexpected equals in equals");
+        return {
+            type: "equals",
+            left: p,
+            right: right
+        };
+    }
+    if (next.type == "filterEnd") {
+        tokens.shift();
+        return p;
+    }
+    throw new Error("Unexpected token in filter: " + next?.type);
+}
+const subNodes = ["child", "descendant"];
+function buildTree(tokens) {
+    log.debug("BUILD TREE", tokens);
+    if (tokens.length == 0)
+        throw new Error("Unexpected end of input");
+    const token = tokens.shift();
+    if (token == undefined)
+        throw new Error("Unexpected end of input");
+    if (token.type == "parent") {
+        return {
+            type: "parent",
+            child: buildTree(tokens)
+        };
+    }
+    if (subNodes.includes(token.type)) {
+        let next = tokens.shift();
+        if (next?.type == "function") {
+            const name = tokens.shift();
+            if (name == undefined || name.type != "identifier" || name.value == undefined || typeof (name.value) != "string")
+                throw new Error("Unexpected token: " + name?.type + ". Expecting function name");
+            const value = name.value;
+            if (!(0, _1.isAvailableFunction)(value)) {
+                throw new Error("Unsupported function: " + name.value);
+            }
+            return buildFunctionCall(value, tokens);
+        }
+        if (next?.type == "parent") {
+            return { type: "parent", child: buildTree(tokens) };
+        }
+        const modifiers = [];
+        while (next && (next?.type == "attributeSelector" || next?.type == "bindingSelector" || next?.type == "resolveSelector")) {
+            modifiers.push(next);
+            next = tokens.shift();
+        }
+        const isAttribute = modifiers.some(m => m.type == "attributeSelector");
+        const isBinding = modifiers.some(m => m.type == "bindingSelector");
+        const isResolve = modifiers.some(m => m.type == "resolveSelector");
+        if (isResolve && isBinding)
+            throw new Error("Cannot have both resolve and binding");
+        if (!next || !next.value || (!isAttribute && !isIdentifierToken(next)))
+            throw new Error("Unexpected or missing token: " + next?.type);
+        const identifer = next.value;
+        let filter = undefined;
+        if (tokens.length > 0 && tokens[0].type == "filterBegin") {
+            filter = buildFilter(tokens);
+            log.debug("FILTER", filter, tokens);
+        }
+        let child = undefined;
+        if (tokens.length > 0 && subNodes.includes(tokens[0].type)) {
+            child = buildTree(tokens);
+        }
+        if (typeof (identifer) != "string")
+            throw new Error("Identifier must be a string");
+        return {
+            type: token.type,
+            value: identifer,
+            attribute: isAttribute,
+            binding: isBinding,
+            resolve: isResolve,
+            filter: filter,
+            child: child
+        };
+    }
+    if (token.type == "literal") {
+        return {
+            type: "literal",
+            value: token.value
+        };
+    }
+    throw new Error("Unexpected token: " + token.type);
+}
+function buildFunctionCall(name, tokens) {
+    log.debug("BUILD FUNCTION", name, tokens);
+    const parameters = [];
+    const next = tokens.shift();
+    if (next?.type != "parametersBegin")
+        throw new Error("Unexpected token: " + next?.type);
+    while (tokens.length > 0 && tokens[0].type != "parametersEnd") {
+        parameters.push(buildTree(tokens));
+        if (tokens[0].type == "separator")
+            tokens.shift();
+    }
+    if (tokens.length == 0)
+        throw new Error("Unexpected end of input");
+    tokens.shift();
+    return {
+        type: "function",
+        function: name,
+        parameters: parameters
+    };
+}
+function parse(input) {
+    const tokens = tokenize(input);
+    const result = buildTree(tokens);
+    log.debug("RESULT", result);
+    if (!result)
+        throw new Error("No root element found");
+    return result;
+}
+exports.parse = parse;

package/lib/esm/traverse.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodePath = exports.getBinding = void 0;
+const nodeutils_1 = require("./nodeutils");
+const debugLogEnabled = false;
+const log = {
+    debug: (...args) => {
+        if (debugLogEnabled)
+            console.debug(...args);
+    }
+};
+const scopes = new Array(100000);
+const voidFn = () => { };
+let scopeIdCounter = 0;
+let removedScopes = 0;
+function createScope(parentScopeId) {
+    const id = scopeIdCounter++;
+    /*const bindings: Record<string, Binding> = {};
+    const s: Scope = {
+      bindings,
+      id,
+      parentScopeId,
+      hasEntries: false
+    }*/
+    scopes[id] = parentScopeId ?? -1;
+    return id;
+}
+function getBinding(scopeId, name) {
+    const scope = scopes[scopeId];
+    if (typeof scope == "number") {
+        if (scope == -1)
+            return undefined;
+        return getBinding(scope, name);
+    }
+    const s = scope.bindings[name];
+    if (s)
+        return s;
+    if (scope.parentScopeId != undefined && scope.parentScopeId >= 0) {
+        return getBinding(scope.parentScopeId, name);
+    }
+    return undefined;
+}
+exports.getBinding = getBinding;
+function setBinding(scopeId, name, binding) {
+    let scope;
+    const s = scopes[scopeId];
+    if (typeof s == "number") {
+        scope = {
+            bindings: {},
+            id: scopeId,
+            parentScopeId: s == -1 ? undefined : s,
+            hasEntries: false
+        };
+        scopes[scopeId] = scope;
+    }
+    else {
+        scope = s;
+    }
+    scope.bindings[name] = binding;
+    scope.hasEntries = true;
+}
+let pathsCreated = 0;
+const nodeKey = "ASTronomical-path";
+function createNodePath(node, key, parentKey, scopeId, nodePath) {
+    if (node.extra && node.extra[nodeKey]) {
+        const path = node.extra[nodeKey];
+        path.key = key;
+        path.parentKey = parentKey;
+        path.parentPath = nodePath;
+        return path;
+    }
+    const finalScope = ((node.extra && node.extra["scopeId"]) ? node.extra["scopeId"] : scopeId) ?? createScope();
+    const path = {
+        node,
+        scopeId: finalScope,
+        shouldStop: false,
+        stop: voidFn,
+        get: (key) => {
+            if (key in node) {
+                const r = node[key];
+                if (Array.isArray(r)) {
+                    return r.map((n, i) => createNodePath(n, i.toString(), key, scopeId, nodePath));
+                }
+                else if (r != undefined) {
+                    return [createNodePath(r, key, key, scopeId, nodePath)];
+                }
+            }
+            return [];
+        },
+        parentPath: nodePath,
+        key,
+        parentKey
+    };
+    path.stop = () => { path.shouldStop = true; };
+    if ((0, nodeutils_1.isNode)(node)) {
+        node.extra = node.extra ?? {};
+        node.extra[nodeKey] = path;
+        Object.defineProperty(node.extra, nodeKey, { enumerable: false });
+    }
+    pathsCreated++;
+    return path;
+}
+exports.createNodePath = createNodePath;
+function registerBinding(node, parentNode, grandParentNode, scopeId) {
+    //console.log("x registerBinding?", isIdentifier(node) ? node.name : node.type, parentNode.type, grandParentNode?.type, scopeId, isBinding(node, parentNode, grandParentNode));
+    if ((0, nodeutils_1.isBinding)(node, parentNode, grandParentNode)) {
+        if ((0, nodeutils_1.isIdentifier)(node) && !(0, nodeutils_1.isAssignmentExpression)(parentNode) && !(0, nodeutils_1.isMemberExpression)(parentNode)) {
+            //console.log("x registerBinding!", node.name, parentNode.type, grandParentNode?.type, scopeId);
+            //A bit of a hack here as well. Needs some further investigation
+            if ((0, nodeutils_1.isScope)(node, parentNode)) {
+                setBinding(scopeId, node.name, { path: createNodePath(node, undefined, undefined, scopeId) });
+            }
+            else {
+                setBinding(scopeId, node.name, { path: createNodePath(parentNode, undefined, undefined, scopeId) });
+            }
+        }
+    }
+}
+function registerBindings(node, parentNode, grandParentNode, scopeId) {
+    if (typeof node == "object" && node != null) {
+        node.extra = node.extra ?? {};
+        if (node.extra["scopeId"])
+            return;
+        node.extra["scopeId"] = scopeId;
+    }
+    const keys = nodeutils_1.VISITOR_KEYS[node.type];
+    //console.log(keys, node);
+    if (!keys) {
+        return;
+    }
+    let childScopeId = scopeId;
+    // This is also buggy. Need to investigate what creates a new scope
+    if ((0, nodeutils_1.isScopable)(node)) {
+        childScopeId = createScope(scopeId);
+    }
+    for (const key of keys) {
+        const childNodes = node[key];
+        const children = Array.isArray(childNodes) ? childNodes : childNodes ? [childNodes] : [];
+        children.forEach((child) => {
+            if ((0, nodeutils_1.isNode)(child)) {
+                // This feels like a hack. Need to figure out how to make this work 
+                // for other types of scopes as well (classes, etc.)
+                const s = key == "id" ? scopeId : childScopeId;
+                registerBinding(child, node, parentNode, s);
+                registerBindings(child, node, parentNode, s);
+            }
+        });
+    }
+    if (childScopeId != scopeId && typeof scopes[childScopeId] == "number") { // Scope has not been populated
+        scopes[childScopeId] = scopes[scopeId];
+        removedScopes++;
+    }
+}
+function traverseInner(node, visitor, scopeId, state, path) {
+    const nodePath = path ?? createNodePath(node, undefined, undefined, scopeId);
+    const keys = nodeutils_1.VISITOR_KEYS[node.type];
+    if (nodePath.parentPath)
+        registerBindings(nodePath.node, nodePath.parentPath.node, nodePath.parentPath.parentPath?.node, nodePath.scopeId);
+    if (!keys) {
+        return;
+    }
+    for (const key of keys) {
+        const childNodes = node[key];
+        const children = Array.isArray(childNodes) ? childNodes : childNodes ? [childNodes] : [];
+        const nodePaths = children.map((child, i) => {
+            if ((0, nodeutils_1.isNode)(child)) {
+                return createNodePath(child, key, Array.isArray(childNodes) ? i.toString() : key, nodePath.scopeId, nodePath);
+            }
+            return undefined;
+        }).filter(x => x != undefined);
+        nodePaths.forEach((childPath) => {
+            visitor.enter(childPath, state);
+            if (childPath.shouldStop) {
+                childPath.shouldStop = false;
+                nodePath.shouldStop = true;
+                return;
+            }
+            traverseInner(childPath.node, visitor, nodePath.scopeId, state, childPath);
+            if (visitor.exit)
+                visitor.exit(childPath, state);
+            if (childPath.shouldStop) {
+                childPath.shouldStop = false;
+                nodePath.shouldStop = true;
+                return;
+            }
+        });
+    }
+}
+const sOut = [];
+function traverse(node, visitor, scopeId, state, path) {
+    traverseInner(node, visitor, scopeId, state, path);
+    if (!sOut.includes(scopeIdCounter)) {
+        log.debug("Scopes created", scopeIdCounter, " Scopes removed", removedScopes, "Paths created", pathsCreated);
+        sOut.push(scopeIdCounter);
+    }
+}
+exports.default = traverse;

package/lib/esm/types/index.d.ts

@@ -0,0 +1,23 @@
+import { ASTNode } from "./nodeutils";
+export declare const functions: {
+    join: {
+        fn: (result: Result[][]) => Result[];
+    };
+    concat: {
+        fn: (result: Result[][]) => Result[];
+    };
+    first: {
+        fn: (result: Result[][]) => Result[];
+    };
+    nthchild: {
+        fn: (result: Result[][]) => Result[];
+    };
+};
+export type AvailableFunction = keyof typeof functions;
+export declare function isAvailableFunction(name: string): name is AvailableFunction;
+type Result = ASTNode | string | number | boolean;
+export declare function query(code: ASTNode | string, query: string): Result[];
+export declare function multiQuery<T extends Record<string, string>>(code: ASTNode | string, namedQueries: T): Record<keyof T, Result[]>;
+export declare function parseSource(source: string): ASTNode;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAUtC,eAAO,MAAM,SAAS;;qBAEL,MAAM,EAAE,EAAE,KAAG,MAAM,EAAE;;;qBAWrB,MAAM,EAAE,EAAE,KAAG,MAAM,EAAE;;;qBAMrB,MAAM,EAAE,EAAE,KAAG,MAAM,EAAE;;;qBAOrB,MAAM,EAAE,EAAE,KAAG,MAAM,EAAE;;CASrC,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,SAAS,CAAC;AACvD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAI,IAAI,IAAI,iBAAiB,CAE5E;AAOD,KAAK,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAiXlD,wBAAgB,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,GAAI,MAAM,EAAE,CAEtE;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,YAAY,EAAE,CAAC,GAAI,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAQhI;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAI,OAAO,CAMpD"}

package/lib/esm/types/nodeutils.d.ts

@@ -0,0 +1,17 @@
+import { ESTree } from "meriyah";
+export declare function isNode(candidate: unknown): candidate is ASTNode;
+export declare function isAssignmentExpression(node: ESTree.Node): node is ESTree.AssignmentExpression;
+export declare function isMemberExpression(node: ESTree.Node): node is ESTree.MemberExpression;
+export declare function isIdentifier(node: ESTree.Node): node is ESTree.Identifier;
+export declare function isFunctionDeclaration(node: ESTree.Node): node is ESTree.FunctionDeclaration;
+export declare function isFunctionExpression(node: ESTree.Node): node is ESTree.FunctionExpression;
+export declare function isVariableDeclarator(node: ESTree.Node): node is ESTree.VariableDeclarator;
+export declare function isBinding(node: ESTree.Node, parentNode: ESTree.Node, grandParentNode: ESTree.Node | undefined): boolean;
+export declare const VISITOR_KEYS: Record<ESTree.Node["type"], string[]>;
+export declare function isScope(node: ESTree.Node, parentNode: ESTree.Node): boolean;
+export declare function isScopable(node: ESTree.Node): boolean;
+export declare function isExportSpecifier(node: ESTree.Node): node is ESTree.ExportSpecifier;
+export type ASTNode = ESTree.Node & {
+    extra?: Record<string, unknown>;
+};
+//# sourceMappingURL=nodeutils.d.ts.map

package/lib/esm/types/nodeutils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeutils.d.ts","sourceRoot":"","sources":["../../../src/nodeutils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,GAAI,SAAS,IAAI,OAAO,CAEhE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,oBAAoB,CAE7F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,gBAAgB,CAErF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,UAAU,CAEzE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,mBAAmB,CAE3F;AACD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,kBAAkB,CAEzF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,kBAAkB,CAEzF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,IAAI,GAAG,SAAS,GAAG,OAAO,CA0BvH;AAuDD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CA0F9D,CAAC;AAqBF,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAS3E;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAqBrD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,IAAI,IAAI,MAAM,CAAC,eAAe,CAEnF;AAGD,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC"}

package/lib/esm/types/parseQuery.d.ts

@@ -0,0 +1,42 @@
+import { AvailableFunction } from ".";
+type Token = {
+    type: string;
+    value?: string;
+};
+export declare function tokenize(input: string): Token[];
+type BaseNode = {
+    type: string;
+    attribute?: boolean;
+    binding?: boolean;
+    resolve?: boolean;
+    filter?: QNode;
+    value?: string;
+    child?: QNode;
+};
+export type Selector = BaseNode & ({
+    type: "child" | "descendant";
+    attribute: boolean;
+    binding: boolean;
+    value: string;
+    resolve: boolean;
+} | {
+    type: "parent";
+});
+export type Condition = BaseNode & {
+    type: "and" | "or" | "equals";
+    left: QNode;
+    right: QNode;
+};
+export type Literal = BaseNode & {
+    type: "literal";
+    value: string;
+};
+export type FunctionCall = BaseNode & {
+    type: "function";
+    function: AvailableFunction;
+    parameters: QNode[];
+};
+export type QNode = Selector | Condition | Literal | FunctionCall;
+export declare function parse(input: string): QNode;
+export {};
+//# sourceMappingURL=parseQuery.d.ts.map

package/lib/esm/types/parseQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseQuery.d.ts","sourceRoot":"","sources":["../../../src/parseQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAuB,MAAM,GAAG,CAAC;AAa3D,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAA;AA2BD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAI,KAAK,EAAE,CA8GhD;AACD,KAAK,QAAQ,GAAG;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,CAAC;IACjC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG;IACF,IAAI,EAAE,QAAQ,CAAA;CACf,CAAC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG;IACjC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,QAAQ,CAAC;IAC9B,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;CACd,CAAA;AACD,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG;IAC/B,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IACpC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,KAAK,EAAE,CAAC;CACrB,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,YAAY,CAAE;AAyInE,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAM1C"}

package/lib/esm/types/traverse.d.ts

@@ -0,0 +1,29 @@
+import { ASTNode } from "./nodeutils";
+export type Binding = {
+    path: NodePath<ASTNode>;
+};
+export type Scope = {
+    bindings: Record<string, Binding>;
+    parentScopeId?: number;
+    id: number;
+    hasEntries: boolean;
+};
+export type NodePath<T> = {
+    node: T;
+    key?: string;
+    parentPath?: NodePath<T>;
+    parentKey?: string;
+    stop: () => void;
+    get(key: string): NodePath<ASTNode>[];
+    scopeId: number;
+    shouldStop: boolean;
+};
+type Visitor<T> = {
+    enter: (path: NodePath<ASTNode>, state: T) => void;
+    exit?: (path: NodePath<ASTNode>, state: T) => void;
+};
+export declare function getBinding(scopeId: number, name: string): Binding | undefined;
+export declare function createNodePath(node: ASTNode, key: string | undefined, parentKey: string | undefined, scopeId: number | undefined, nodePath?: NodePath<ASTNode>): NodePath<ASTNode>;
+export default function traverse<T>(node: ASTNode, visitor: Visitor<T>, scopeId: number | undefined, state: T, path?: NodePath<ASTNode>): void;
+export {};
+//# sourceMappingURL=traverse.d.ts.map

package/lib/esm/types/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../../src/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkH,MAAM,aAAa,CAAC;AAStJ,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;CACzB,CAAA;AAED,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAMF,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,IAAI,EAAE,CAAC,CAAC;IACR,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACnD,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CACpD,CAAA;AAmBD,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAYvD;AAwBD,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAI,QAAQ,CAAC,OAAO,CAAC,CAsCnL;AAuGD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,CAAC,EAAI,IAAI,EAAE,OAAO,EACjD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,KAAK,EAAE,CAAC,EACR,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,QAMzB"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "astronomical",
+  "version": "1.0.0-beta.12",
+  "description": "offers a way to query a Javascript AST to find specific patterns using a syntax somewhat similar to XPath.",
+  "scripts": {
+    "lint": "eslint . --ext .ts --fix --ignore-path .gitignore",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf lib && mkdir lib",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc && mv lib/esm/index.js lib/esm/index.mjs",
+    "build:cjs": "tsc -p ./tsconfig.cjs.json",
+    "watch": "tsc --watch",
+    "check": "npm run lint && npm run typecheck",
+    "dev": "tsc --watch",
+    "testWatch": "jest --watchAll",
+    "test": "jest --ci",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RetireJS/babel-q.git"
+  },
+  "author": "Erlend Oftedal <erlend@oftedal.no>",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.11.5",
+    "@typescript-eslint/eslint-plugin": "^6.20.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.2.4",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "meriyah": "^4.3.9"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/esm/types/index.d.ts",
+        "default": "./lib/esm/index.mjs"
+      },
+      "require": {
+        "types": "./lib/cjs/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "types": "./lib/cjs/types/index.d.ts",
+  "main": "./lib/cjs/index.js"
+}