astronomical 1.0.0-beta.12

package/lib/esm/index.mjs

@@ -0,0 +1,453 @@
+"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;
+};
+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 parseQuery_1 = require("./parseQuery");
+const meriyah_1 = require("meriyah");
+const debugLogEnabled = false;
+const log = {
+    debug: (...args) => {
+        if (debugLogEnabled)
+            console.debug(...args.map(x => typeof (x) == "object" && x != null && "valueOf" in x ? x.valueOf() : x));
+    }
+};
+exports.functions = {
+    "join": {
+        fn: (result) => {
+            if (result.length != 2)
+                throw new Error("Invalid number of arugments for join");
+            const [values, separators] = result;
+            if (separators.length != 1)
+                throw new Error("Invalid number of separators for join");
+            const separator = separators[0];
+            if (typeof separator != "string")
+                throw new Error("Separator must be a string");
+            if (values.length == 0)
+                return [];
+            return [values.join(separator)];
+        }
+    },
+    "concat": {
+        fn: (result) => {
+            if (result.some(x => x.length == 0))
+                return [];
+            return [result.flat().join("")];
+        }
+    },
+    "first": {
+        fn: (result) => {
+            if (result.length != 1)
+                throw new Error("Invalid number of arugments for first");
+            if (result[0].length == 0)
+                return [];
+            return [result.map(r => r[0])[0]];
+        }
+    },
+    "nthchild": {
+        fn: (result) => {
+            if (result.length != 2)
+                throw new Error("Invalid number of arguments for nthchild");
+            if (result[1].length != 1)
+                throw new Error("Invalid number of arguments for nthchild");
+            const x = result[1][0];
+            const number = typeof x == "number" ? x : parseInt(x);
+            return [result[0][number]];
+        }
+    }
+};
+const functionNames = Object.keys(exports.functions);
+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() {
+            if (path.parentPath == undefined)
+                return "@" + path.node.type;
+            return breadCrumb(path.parentPath) + "." + (path.parentKey == path.key ? path.key : path.parentKey + "[" + path.key + "]") + "@" + path.node.type;
+        }
+    };
+}
+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);
+}
+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);
+        }
+        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);
+    }
+    return fnode;
+}
+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("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") {
+                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 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));
+            }
+            else {
+                functionNode.parameters.push(createFNodeAndAddToState(param, [], state));
+            }
+        }
+    }
+    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);
+        }
+        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.node.type == "parent") {
+        return resolveFilterWithParent(filter.node, path);
+    }
+    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;
+    }
+    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;
+        }
+        else if (startNode.binding) {
+            paths = paths.map(p => resolveBinding(p)).filter(isDefined);
+        }
+        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;
+}
+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 {
+            fnode.result.push(path.node);
+        }
+    }
+    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);
+            }
+        }
+    }
+    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 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);
+        }
+    }
+    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: [[]]
+    };
+    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];
+}
+exports.query = query;
+function multiQuery(code, namedQueries) {
+    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);
+    log.debug("Query time: ", Date.now() - start);
+    return result;
+}
+exports.multiQuery = multiQuery;
+function parseSource(source) {
+    try {
+        return (0, meriyah_1.parseScript)(source, { module: true, next: true, specDeviation: true });
+    }
+    catch (e) {
+        return (0, meriyah_1.parseScript)(source, { module: false, next: true, specDeviation: true });
+    }
+}
+exports.parseSource = parseSource;

package/lib/esm/nodeutils.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExportSpecifier = exports.isScopable = exports.isScope = exports.VISITOR_KEYS = exports.isBinding = exports.isVariableDeclarator = exports.isFunctionExpression = exports.isFunctionDeclaration = exports.isIdentifier = exports.isMemberExpression = exports.isAssignmentExpression = exports.isNode = void 0;
+function isNode(candidate) {
+    return typeof candidate === "object" && candidate != null && "type" in candidate;
+}
+exports.isNode = isNode;
+function isAssignmentExpression(node) {
+    return node.type === "AssignmentExpression";
+}
+exports.isAssignmentExpression = isAssignmentExpression;
+function isMemberExpression(node) {
+    return node.type === "MemberExpression";
+}
+exports.isMemberExpression = isMemberExpression;
+function isIdentifier(node) {
+    return node.type === "Identifier";
+}
+exports.isIdentifier = isIdentifier;
+function isFunctionDeclaration(node) {
+    return node.type === "FunctionDeclaration";
+}
+exports.isFunctionDeclaration = isFunctionDeclaration;
+function isFunctionExpression(node) {
+    return node.type === "FunctionExpression";
+}
+exports.isFunctionExpression = isFunctionExpression;
+function isVariableDeclarator(node) {
+    return node.type === "VariableDeclarator";
+}
+exports.isVariableDeclarator = isVariableDeclarator;
+function isBinding(node, parentNode, grandParentNode) {
+    if (grandParentNode &&
+        node.type === "Identifier" &&
+        parentNode.type === "Property" &&
+        grandParentNode.type === "ObjectExpression") {
+        return false;
+    }
+    const keys = bindingIdentifiersKeys[parentNode.type] ?? [];
+    if (keys) {
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const val = 
+            // @ts-expect-error key must present in parent
+            parentNode[key];
+            if (Array.isArray(val)) {
+                if (val.indexOf(node) >= 0)
+                    return true;
+            }
+            else {
+                if (val === node)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+exports.isBinding = isBinding;
+const bindingIdentifiersKeys = {
+    DeclareClass: ["id"],
+    DeclareFunction: ["id"],
+    DeclareModule: ["id"],
+    DeclareVariable: ["id"],
+    DeclareInterface: ["id"],
+    DeclareTypeAlias: ["id"],
+    DeclareOpaqueType: ["id"],
+    InterfaceDeclaration: ["id"],
+    TypeAlias: ["id"],
+    OpaqueType: ["id"],
+    CatchClause: ["param"],
+    LabeledStatement: ["label"],
+    UnaryExpression: ["argument"],
+    AssignmentExpression: ["left"],
+    ImportSpecifier: ["local"],
+    ImportNamespaceSpecifier: ["local"],
+    ImportDefaultSpecifier: ["local"],
+    ImportDeclaration: ["specifiers"],
+    ExportSpecifier: ["exported"],
+    ExportNamespaceSpecifier: ["exported"],
+    ExportDefaultSpecifier: ["exported"],
+    FunctionDeclaration: ["id", "params"],
+    FunctionExpression: ["id", "params"],
+    ArrowFunctionExpression: ["params"],
+    ObjectMethod: ["params"],
+    ClassMethod: ["params"],
+    ClassPrivateMethod: ["params"],
+    ForInStatement: ["left"],
+    ForOfStatement: ["left"],
+    ClassDeclaration: ["id"],
+    ClassExpression: ["id"],
+    RestElement: ["argument"],
+    UpdateExpression: ["argument"],
+    ObjectProperty: ["value"],
+    AssignmentPattern: ["left"],
+    ArrayPattern: ["elements"],
+    ObjectPattern: ["properties"],
+    VariableDeclaration: ["declarations"],
+    VariableDeclarator: ["id"],
+};
+exports.VISITOR_KEYS = {
+    ArrayExpression: ["elements"],
+    ArrayPattern: ["elements"],
+    ArrowFunctionExpression: ["params", "body"],
+    AssignmentExpression: ["left", "right"],
+    AssignmentPattern: ["left", "right"],
+    AwaitExpression: ["argument"],
+    BinaryExpression: ["left", "right"],
+    BlockStatement: ["body"],
+    BreakStatement: [],
+    CallExpression: ["callee", "arguments"],
+    CatchClause: ["param", "body"],
+    ChainExpression: ["expression"],
+    ClassBody: ["body"],
+    ClassDeclaration: ["id", "superClass", "body"],
+    ClassExpression: ["id", "superClass", "body"],
+    ConditionalExpression: ["test", "consequent", "alternate"],
+    ContinueStatement: [],
+    DebuggerStatement: [],
+    DoWhileStatement: ["body", "test"],
+    EmptyStatement: [],
+    ExportAllDeclaration: ["source"],
+    ExportDefaultDeclaration: ["declaration"],
+    ExportNamedDeclaration: ["declaration", "specifiers", "source"],
+    ExportSpecifier: ["local", "exported"],
+    ExpressionStatement: ["expression"],
+    ForInStatement: ["left", "right", "body"],
+    ForOfStatement: ["left", "right", "body"],
+    ForStatement: ["init", "test", "update", "body"],
+    FunctionDeclaration: ["id", "params", "body"],
+    FunctionExpression: ["id", "params", "body"],
+    Identifier: [],
+    IfStatement: ["test", "consequent", "alternate"],
+    ImportDeclaration: ["specifiers", "source"],
+    ImportDefaultSpecifier: ["local"],
+    ImportNamespaceSpecifier: ["local"],
+    ImportSpecifier: ["local", "imported"],
+    LabeledStatement: ["label", "body"],
+    Literal: [],
+    LogicalExpression: ["left", "right"],
+    MemberExpression: ["object", "property"],
+    MetaProperty: ["meta", "property"],
+    MethodDefinition: ["key", "value"],
+    NewExpression: ["callee", "arguments"],
+    ObjectExpression: ["properties"],
+    ObjectPattern: ["properties"],
+    Program: ["body"],
+    Property: ["key", "value"],
+    RestElement: ["argument"],
+    ReturnStatement: ["argument"],
+    SequenceExpression: ["expressions"],
+    SpreadElement: ["argument"],
+    Super: [],
+    SwitchCase: ["test", "consequent"],
+    SwitchStatement: ["discriminant", "cases"],
+    TaggedTemplateExpression: ["tag", "quasi"],
+    TemplateElement: [],
+    TemplateLiteral: ["quasis", "expressions"],
+    ThisExpression: [],
+    ThrowStatement: ["argument"],
+    TryStatement: ["block", "handler", "finalizer"],
+    UnaryExpression: ["argument"],
+    UpdateExpression: ["argument"],
+    VariableDeclaration: ["declarations"],
+    VariableDeclarator: ["id", "init"],
+    WhileStatement: ["test", "body"],
+    WithStatement: ["object", "body"],
+    YieldExpression: ["argument"],
+    ImportExpression: ["source"],
+    Decorator: ["expression"],
+    PropertyDefinition: ["key", "value"],
+    Import: ["source"],
+    JSXAttribute: ["name", "value"],
+    JSXNamespacedName: ["namespace", "name"],
+    JSXElement: ["openingElement", "closingElement", "children"],
+    JSXClosingElement: ["name"],
+    JSXOpeningElement: ["name", "attributes"],
+    JSXFragment: ["openingFragment", "closingFragment", "children"],
+    JSXOpeningFragment: [],
+    JSXClosingFragment: [],
+    JSXText: [],
+    JSXExpressionContainer: ["expression"],
+    JSXSpreadChild: ["expression"],
+    JSXEmptyExpression: [],
+    JSXSpreadAttribute: ["argument"],
+    JSXIdentifier: [],
+    PrivateIdentifier: [],
+    JSXMemberExpression: ["object", "property"],
+    ParenthesizedExpression: ["expression"],
+    StaticBlock: ["body"],
+};
+function isBlockStatement(node) { return node.type === "BlockStatement"; }
+function isFunction(node) {
+    return node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function isCatchClause(node) { return node.type === "CatchClause"; }
+function isPattern(node) {
+    switch (node.type) {
+        case "AssignmentPattern":
+        case "ArrayPattern":
+        case "ObjectPattern":
+            return true;
+    }
+    return false;
+}
+function isScope(node, parentNode) {
+    if (isBlockStatement(node) && (isFunction(parentNode) || isCatchClause(parentNode))) {
+        return false;
+    }
+    if (isPattern(node) && (isFunction(parentNode) || isCatchClause(parentNode))) {
+        return true;
+    }
+    return isFunctionDeclaration(parentNode) || isFunctionExpression(parentNode) || isScopable(node);
+}
+exports.isScope = isScope;
+function isScopable(node) {
+    switch (node.type) {
+        case "BlockStatement":
+        case "CatchClause":
+        case "DoWhileStatement":
+        case "ForInStatement":
+        case "ForStatement":
+        case "FunctionDeclaration":
+        case "FunctionExpression":
+        case "Program":
+        case "MethodDefinition":
+        case "SwitchStatement":
+        case "WhileStatement":
+        case "ArrowFunctionExpression":
+        case "ClassExpression":
+        case "ClassDeclaration":
+        case "ForOfStatement":
+        case "StaticBlock":
+            return true;
+    }
+    return false;
+}
+exports.isScopable = isScopable;
+function isExportSpecifier(node) {
+    return node.type === "ExportSpecifier";
+}
+exports.isExportSpecifier = isExportSpecifier;