astronomical 2.0.1 → 3.0.0

package/lib/esm/nodeutils.js

@@ -1,260 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VISITOR_KEYS = exports.isBinding = exports.isVariableDeclaration = exports.isVariableDeclarator = exports.isFunctionExpression = exports.isFunctionDeclaration = exports.isIdentifier = exports.isMemberExpression = exports.isAssignmentExpression = exports.isUpdateExpression = exports.isPrimitive = exports.isLiteral = exports.isNodePath = exports.isNode = void 0;
-exports.isScope = isScope;
-exports.isScopable = isScopable;
-exports.isExportSpecifier = isExportSpecifier;
-const isNode = (candidate) => {
-    return typeof candidate === "object" && candidate != null && "type" in candidate;
-};
-exports.isNode = isNode;
-const isNodePath = (candidate) => {
-    return typeof candidate === "object" && candidate != null && "node" in candidate;
-};
-exports.isNodePath = isNodePath;
-const isLiteral = (candidate) => {
-    return (0, exports.isNode)(candidate) && candidate.type === "Literal";
-};
-exports.isLiteral = isLiteral;
-const isPrimitive = (value) => {
-    return typeof value == "string" || typeof value == "number" || typeof value == "boolean";
-};
-exports.isPrimitive = isPrimitive;
-const isUpdateExpression = (value) => {
-    return (0, exports.isNode)(value) && value.type === "UpdateExpression";
-};
-exports.isUpdateExpression = isUpdateExpression;
-const isAssignmentExpression = (node) => {
-    return node.type === "AssignmentExpression";
-};
-exports.isAssignmentExpression = isAssignmentExpression;
-const isMemberExpression = (node) => {
-    return node.type === "MemberExpression";
-};
-exports.isMemberExpression = isMemberExpression;
-const isIdentifier = (node) => {
-    return node.type === "Identifier";
-};
-exports.isIdentifier = isIdentifier;
-const isFunctionDeclaration = (node) => {
-    return node.type === "FunctionDeclaration";
-};
-exports.isFunctionDeclaration = isFunctionDeclaration;
-const isFunctionExpression = (node) => {
-    return node.type === "FunctionExpression";
-};
-exports.isFunctionExpression = isFunctionExpression;
-const isVariableDeclarator = (node) => {
-    return node.type === "VariableDeclarator";
-};
-exports.isVariableDeclarator = isVariableDeclarator;
-const isVariableDeclaration = (node) => {
-    return node.type === "VariableDeclaration";
-};
-exports.isVariableDeclaration = isVariableDeclaration;
-const isBinding = (node, parentNode, grandParentNode) => {
-    if (grandParentNode &&
-        node.type === "Identifier" &&
-        parentNode.type === "Property" &&
-        grandParentNode.type === "ObjectExpression") {
-        return false;
-    }
-    const keys = bindingIdentifiersKeys[parentNode.type] ?? [];
-    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"],
-    ImportAttribute: ["key", "value"],
-    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 (0, exports.isFunctionDeclaration)(parentNode) || (0, exports.isFunctionExpression)(parentNode) || isScopable(node);
-}
-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;
-}
-function isExportSpecifier(node) {
-    return node.type === "ExportSpecifier";
-}

package/lib/esm/parseQuery.js

@@ -1,296 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokenize = tokenize;
-exports.parse = parse;
-const _1 = require(".");
-const nodeutils_1 = require("./nodeutils");
-const debugLogEnabled = false;
-const log = debugLogEnabled ? {
-    debug: (...args) => {
-        console.debug(...args);
-    }
-} : undefined;
-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;
-}
-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;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -1,21 +0,0 @@
-import { ESTree } from "meriyah";
-import { ASTNode, NodePath } from ".";
-import { PrimitiveValue } from ".";
-export declare const isNode: (candidate: unknown) => candidate is ASTNode;
-export declare const isNodePath: (candidate: unknown) => candidate is NodePath;
-export declare const isLiteral: (candidate: unknown) => candidate is ESTree.Literal;
-export declare const isPrimitive: (value: unknown) => value is PrimitiveValue;
-export declare const isUpdateExpression: (value: unknown) => value is ESTree.UpdateExpression;
-export declare const isAssignmentExpression: (node: ESTree.Node) => node is ESTree.AssignmentExpression;
-export declare const isMemberExpression: (node: ESTree.Node) => node is ESTree.MemberExpression;
-export declare const isIdentifier: (node: ESTree.Node) => node is ESTree.Identifier;
-export declare const isFunctionDeclaration: (node: ESTree.Node) => node is ESTree.FunctionDeclaration;
-export declare const isFunctionExpression: (node: ESTree.Node) => node is ESTree.FunctionExpression;
-export declare const isVariableDeclarator: (node: ESTree.Node) => node is ESTree.VariableDeclarator;
-export declare const isVariableDeclaration: (node: ESTree.Node) => node is ESTree.VariableDeclaration;
-export declare const 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;
-//# sourceMappingURL=nodeutils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"nodeutils.d.ts","sourceRoot":"","sources":["../../../src/nodeutils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,CAAC;AAEnC,eAAO,MAAM,MAAM,GAAI,WAAW,OAAO,KAAI,SAAS,IAAI,OAEzD,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,WAAW,OAAO,KAAI,SAAS,IAAI,QAE7D,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,WAAW,OAAO,KAAI,SAAS,IAAI,MAAM,CAAC,OAEnE,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAI,KAAK,IAAI,cAEtD,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAI,KAAK,IAAI,MAAM,CAAC,gBAEpE,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,oBAEzE,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,gBAErE,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,UAE/D,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,mBAExE,CAAA;AACD,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,kBAEvE,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,kBAEvE,CAAA;AACD,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,CAAC,IAAI,KAAG,IAAI,IAAI,MAAM,CAAC,mBAExE,CAAA;AACD,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,CAAC,IAAI,EAAE,YAAY,MAAM,CAAC,IAAI,EAAE,iBAAiB,MAAM,CAAC,IAAI,GAAG,SAAS,KAAG,OAwBhH,CAAA;AAuDD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CA2F9D,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"}

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

@@ -1,42 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/utils.d.ts

@@ -1,3 +0,0 @@
-export declare function toArray<T>(value: T | T[]): T[];
-export declare function isDefined<T>(value: T | undefined | null): value is T;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,GAAI,CAAC,EAAE,CAE/C;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,GAAI,KAAK,IAAI,CAAC,CAErE"}

package/lib/esm/utils.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toArray = toArray;
-exports.isDefined = isDefined;
-function toArray(value) {
-    return Array.isArray(value) ? value : [value];
-}
-function isDefined(value) {
-    return value != undefined && value != null;
-}