babel-plugin-vasille 3.2.1 → 4.0.0

package/lib-node/mesh.js

@@ -1,1051 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.meshOrIgnoreAllExpressions = meshOrIgnoreAllExpressions;
-exports.meshAllExpressions = meshAllExpressions;
-exports.meshComposeCall = meshComposeCall;
-exports.meshAllUnknown = meshAllUnknown;
-exports.meshLValue = meshLValue;
-exports.meshOrIgnoreExpression = meshOrIgnoreExpression;
-exports.meshExpression = meshExpression;
-exports.meshStatements = meshStatements;
-exports.ignoreParams = ignoreParams;
-exports.reactiveArrayPattern = reactiveArrayPattern;
-exports.meshStatement = meshStatement;
-exports.meshFunction = meshFunction;
-exports.composeExpression = composeExpression;
-exports.composeStatements = composeStatements;
-exports.composeStatement = composeStatement;
-exports.compose = compose;
-const t = __importStar(require("@babel/types"));
-const bridge_1 = require("./bridge");
-const call_js_1 = require("./call.js");
-const expression_js_1 = require("./expression.js");
-const internal_js_1 = require("./internal.js");
-const jsx_js_1 = require("./jsx.js");
-const lib_js_1 = require("./lib.js");
-const router_1 = require("./router");
-const utils_1 = require("./utils");
-const composePropsIndex = {
-    slot: 0,
-    compose: 0,
-    view: 0,
-    mvvmView: 0,
-    mvcView: -1,
-    hybridView: 1,
-    store: 0,
-    screen: -1,
-};
-const composeArgsNumber = {
-    slot: 1,
-    compose: 1,
-    view: 1,
-    mvvmView: 1,
-    mvcView: 1,
-    hybridView: 2,
-    store: 1,
-    screen: 1,
-};
-function meshOrIgnoreAllExpressions(nodePaths, internal) {
-    for (const path of nodePaths) {
-        /* istanbul ignore else */
-        if (t.isExpression(path.node)) {
-            meshExpression(path, internal);
-        }
-    }
-}
-function meshAllExpressions(nodePaths, internal) {
-    for (const path of nodePaths) {
-        meshExpression(path, internal);
-    }
-}
-function meshComposeCall(call, name, nodePath, method, internal) {
-    const arg = call.arguments[0];
-    if (call.arguments.length !== 1 || !(t.isFunctionExpression(arg) || t.isArrowFunctionExpression(arg))) {
-        throw nodePath.buildCodeFrameError("Vasille: Invalid arguments");
-    }
-    const fnPath = nodePath.get("arguments")[0];
-    const nonePropsFields = compose(fnPath, internal, false, method);
-    if (composeArgsNumber[method] > 1) {
-        call.arguments.push(t.arrayExpression(nonePropsFields.map(item => t.stringLiteral(item))));
-    }
-    if (!internal.stateOnly) {
-        arg.params.unshift(internal_js_1.ctx);
-    }
-    if (internal.devMode) {
-        call.arguments.push(t.stringLiteral(`${internal.prefix}:${name ? name.name : "#anonymouse"}`));
-    }
-}
-function meshAllUnknown(paths, internal) {
-    for (const path of paths) {
-        /* istanbul ignore else */
-        if (t.isSpreadElement(path.node)) {
-            meshExpression(path.get("argument"), internal);
-        }
-        else if (t.isExpression(path.node)) {
-            meshExpression(path, internal);
-        }
-    }
-}
-function meshLValue(path, internal) {
-    const node = path.node;
-    /* istanbul ignore else */
-    if (t.isExpression(node)) {
-        meshExpression(path, internal);
-    }
-}
-function meshOrIgnoreExpression(path, internal) {
-    /* istanbul ignore else */
-    if (t.isExpression(path.node)) {
-        meshExpression(path, internal);
-    }
-}
-function meshExpression(nodePath, internal, isRoot) {
-    const expr = nodePath.node;
-    if (!expr) {
-        return;
-    }
-    let composeMethod = (0, call_js_1.calls)(nodePath, ["compose", "store", "view", "mvvmView", "mvcView", "hybridView"], internal);
-    if (composeMethod) {
-        meshComposeCall(expr, null, nodePath, composeMethod, internal);
-        return;
-    }
-    switch (expr.type) {
-        case "TemplateLiteral": {
-            const path = nodePath;
-            meshOrIgnoreAllExpressions(path.get("expressions"), internal);
-            break;
-        }
-        case "TaggedTemplateExpression": {
-            const path = nodePath;
-            meshExpression(path.get("quasi"), internal);
-            break;
-        }
-        case "Identifier": {
-            const state = internal.stack.get(expr.name);
-            if ((0, expression_js_1.idIsIValue)(nodePath, internal)) {
-                nodePath.replaceWith(t.memberExpression(expr, t.identifier(state === 4 /* VariableState.ReactivePointer */ ? "$$" : "$")));
-            }
-            break;
-        }
-        case "ArrayExpression": {
-            const path = nodePath;
-            meshAllUnknown(path.get("elements"), internal);
-            break;
-        }
-        case "CallExpression":
-        case "OptionalCallExpression": {
-            const path = nodePath;
-            if (internal.isComposing && (0, call_js_1.calls)(path, ["router"], internal)) {
-                if (!internal.stateOnly) {
-                    (0, router_1.routerReplace)(path);
-                }
-                else {
-                    throw path.buildCodeFrameError("Vasille: The router is not available in stores");
-                }
-            }
-            else {
-                const callsFn = (0, call_js_1.calls)(path, call_js_1.composeOnly, internal);
-                const callsStyleHint = (0, call_js_1.calls)(path, call_js_1.styleOnly, internal);
-                if (callsFn) {
-                    throw path.buildCodeFrameError(`Vasille: Usage of hint "${callsFn}" is restricted here`);
-                }
-                if (callsStyleHint) {
-                    throw path.buildCodeFrameError(`Vasille: Usage of style hint "${callsStyleHint}" is restricted here`);
-                }
-                if (!(0, bridge_1.processBridgeCall)(path, internal)) {
-                    meshOrIgnoreExpression(path.get("callee"), internal);
-                    meshAllUnknown(path.get("arguments"), internal);
-                }
-            }
-            break;
-        }
-        case "AssignmentExpression": {
-            const path = nodePath;
-            const left = path.node.left;
-            let replaced = false;
-            meshLValue(path.get("left"), internal);
-            if (t.isIdentifier(left) && internal.stack.get(left.name) === 4 /* VariableState.ReactivePointer */) {
-                const replaceWith = (0, lib_js_1.forwardOnlyExpr)(path.get("right"), path.node.right, internal);
-                if (replaceWith) {
-                    path.get("right").replaceWith(replaceWith);
-                    replaced = true;
-                }
-            }
-            if (!replaced) {
-                meshExpression(path.get("right"), internal);
-            }
-            break;
-        }
-        case "MemberExpression":
-        case "OptionalMemberExpression": {
-            const path = nodePath;
-            const node = path.node;
-            const property = path.node.property;
-            meshExpression(path.get("object"), internal);
-            if (t.isExpression(property) && !t.isIdentifier(property)) {
-                meshOrIgnoreExpression(path.get("property"), internal);
-            }
-            if ((0, expression_js_1.memberIsIValue)(node, internal)) {
-                path.replaceWith(t.memberExpression(node, t.identifier("$")));
-            }
-            break;
-        }
-        case "BinaryExpression": {
-            const path = nodePath;
-            meshOrIgnoreExpression(path.get("left"), internal);
-            meshExpression(path.get("right"), internal);
-            break;
-        }
-        case "ConditionalExpression": {
-            const path = nodePath;
-            meshExpression(path.get("test"), internal);
-            meshExpression(path.get("consequent"), internal);
-            meshExpression(path.get("alternate"), internal);
-            break;
-        }
-        case "LogicalExpression": {
-            const path = nodePath;
-            meshExpression(path.get("left"), internal);
-            meshExpression(path.get("right"), internal);
-            break;
-        }
-        case "NewExpression": {
-            const path = nodePath;
-            meshOrIgnoreExpression(path.get("callee"), internal);
-            meshAllUnknown(path.get("arguments"), internal);
-            break;
-        }
-        case "SequenceExpression": {
-            const path = nodePath;
-            meshAllExpressions(path.get("expressions"), internal);
-            break;
-        }
-        case "UnaryExpression": {
-            const path = nodePath;
-            meshExpression(path.get("argument"), internal);
-            break;
-        }
-        case "UpdateExpression": {
-            const path = nodePath;
-            meshExpression(path.get("argument"), internal);
-            break;
-        }
-        case "YieldExpression": {
-            const path = nodePath;
-            meshExpression(path.get("argument"), internal);
-            break;
-        }
-        case "AwaitExpression": {
-            const path = nodePath;
-            meshExpression(path.get("argument"), internal);
-            break;
-        }
-        case "TSInstantiationExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "TSAsExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "TSSatisfiesExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "TSTypeAssertion": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "ObjectExpression": {
-            const path = nodePath;
-            for (const propPath of path.get("properties")) {
-                const prop = propPath.node;
-                if (t.isObjectProperty(prop)) {
-                    const path = propPath;
-                    const valuePath = path.get("value");
-                    let replaced = false;
-                    if (isRoot &&
-                        internal.stateOnly &&
-                        (!path.node.computed || t.isStringLiteral(path.node.key)) &&
-                        (t.isIdentifier(path.node.key) || t.isStringLiteral(path.node.key)) &&
-                        t.isExpression(valuePath.node)) {
-                        const call = (0, lib_js_1.exprCall)(valuePath, valuePath.node, internal);
-                        if (call) {
-                            if ((0, utils_1.stringify)(path.node.key).startsWith("$")) {
-                                valuePath.replaceWith(call);
-                            }
-                            else {
-                                throw path.buildCodeFrameError("Vasille: Reactive value property name must start with $");
-                            }
-                            replaced = true;
-                        }
-                        else if (t.isIdentifier(valuePath.node) &&
-                            internal.stack.get(valuePath.node.name) === 3 /* VariableState.ReactiveObject */) {
-                            if (!(0, utils_1.stringify)(path.node.key).startsWith("$$")) {
-                                throw path.buildCodeFrameError("Vasille: Reactive object property name must start with $$");
-                            }
-                        }
-                        else if ((0, utils_1.stringify)(path.node.key).startsWith("$")) {
-                            throw path.buildCodeFrameError("Vasille: This property is not a reactive value or object");
-                        }
-                    }
-                    if (!replaced) {
-                        meshOrIgnoreExpression(valuePath, internal);
-                    }
-                }
-                else if (t.isObjectMethod(prop)) {
-                    if ((0, utils_1.stringify)(prop.key).startsWith("$")) {
-                        throw propPath.buildCodeFrameError("Vasille: Method name stating with $ is not allowed");
-                    }
-                    meshFunction(propPath, internal);
-                }
-                else if (isRoot && internal.stateOnly && t.isSpreadElement(prop)) {
-                    throw propPath.buildCodeFrameError("Vasille: Spread element is not allowed here");
-                }
-                else {
-                    meshAllUnknown([propPath], internal);
-                }
-            }
-            break;
-        }
-        case "FunctionExpression": {
-            meshFunction(nodePath, internal);
-            break;
-        }
-        case "ArrowFunctionExpression": {
-            meshFunction(nodePath, internal);
-            break;
-        }
-        case "ClassExpression": {
-            meshClassBody(nodePath.get("body"), internal);
-            break;
-        }
-        case "JSXFragment": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX fragment is not allowed here");
-        }
-        case "JSXElement": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX element is not allowed here");
-        }
-    }
-}
-function meshStatements(paths, internal) {
-    for (const path of paths) {
-        meshStatement(path, internal);
-    }
-}
-function ignoreParams(val, internal) {
-    /* istanbul ignore else */
-    if (t.isAssignmentPattern(val)) {
-        val = val.left;
-    }
-    /* istanbul ignore else */
-    if (t.isIdentifier(val)) {
-        internal.stack.set(val.name, 1 /* VariableState.Ignored */);
-    }
-    else if (t.isObjectPattern(val)) {
-        ignoreObjectPattern(val, internal);
-    }
-    else if (t.isArrayPattern(val)) {
-        for (const element of val.elements) {
-            if (element) {
-                ignoreParams(element, internal);
-            }
-        }
-    }
-}
-function ignoreObjectPattern(pattern, internal) {
-    for (const property of pattern.properties) {
-        /* istanbul ignore else */
-        if (t.isObjectProperty(property)) {
-            /* istanbul ignore else */
-            if (t.isObjectPattern(property.value)) {
-                ignoreObjectPattern(property.value, internal);
-            }
-            else if (t.isAssignmentPattern(property.value)) {
-                ignoreParams(property.value, internal);
-            }
-            else if (t.isIdentifier(property.value)) {
-                internal.stack.set(property.value.name, 1 /* VariableState.Ignored */);
-            }
-        }
-        /* istanbul ignore else */
-        if (t.isRestElement(property)) {
-            internal.stack.set(property.argument.name, 1 /* VariableState.Ignored */);
-        }
-    }
-}
-function reactiveArrayPattern(path, internal) {
-    if (t.isArrayPattern(path.node)) {
-        path.node.elements.forEach((element, index) => {
-            /* istanbul ignore else */
-            if (t.isIdentifier(element)) {
-                internal.stack.set(element.name, index < 2 ? 2 /* VariableState.Reactive */ : 1 /* VariableState.Ignored */);
-            }
-        });
-    }
-    else {
-        throw path.buildCodeFrameError("Vasille: Expected array pattern");
-    }
-}
-function meshForEachHeader(path, internal) {
-    const left = path.node.left;
-    meshExpression(path.get("right"), internal);
-    /* istanbul ignore else */
-    if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-        ignoreParams(left.declarations[0].id, internal);
-    }
-}
-function meshForHeader(path, internal) {
-    const node = path.node;
-    /* istanbul ignore else */
-    if (node.init) {
-        if (t.isExpression(node.init)) {
-            meshExpression(path.get("init"), internal);
-        }
-        else {
-            const variablePath = path.get("init");
-            for (const declarationPath of variablePath.get("declarations")) {
-                meshExpression(declarationPath.get("init"), internal);
-                ignoreParams(declarationPath.node.id, internal);
-            }
-        }
-    }
-    meshExpression(path.get("test"), internal);
-    meshExpression(path.get("update"), internal);
-}
-function meshClassBody(path, internal) {
-    for (const item of path.get("body")) {
-        /* istanbul ignore else */
-        if (t.isClassMethod(item.node) || t.isClassPrivateMethod(item.node)) {
-            meshFunction(item, internal);
-        }
-        else if (t.isClassAccessorProperty(item.node) ||
-            t.isClassPrivateProperty(item.node) ||
-            t.isClassProperty(item.node)) {
-            meshExpression(item.get("value"), internal);
-        }
-    }
-}
-function meshStatement(path, internal) {
-    const statement = path.node;
-    switch (statement && statement.type) {
-        case "BlockStatement":
-            internal.stack.push();
-            meshStatements(path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        case "DoWhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ExpressionStatement":
-            meshExpression(path.get("expression"), internal);
-            break;
-        case "ForInStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForOfStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForHeader(_path, internal);
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "FunctionDeclaration":
-            meshFunction(path, internal);
-            break;
-        case "IfStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            meshStatement(_path.get("consequent"), internal);
-            internal.stack.pop();
-            internal.stack.push();
-            meshStatement(_path.get("alternate"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "LabeledStatement":
-            meshStatement(path.get("body"), internal);
-            break;
-        case "ReturnStatement":
-            meshExpression(path.get("argument"), internal);
-            break;
-        case "SwitchStatement": {
-            const _path = path;
-            meshExpression(_path.get("discriminant"), internal);
-            internal.stack.push();
-            for (const _case of _path.get("cases")) {
-                meshExpression(_case.get("test"), internal);
-                meshStatements(_case.get("consequent"), internal);
-            }
-            internal.stack.pop();
-            break;
-        }
-        case "ThrowStatement":
-            meshExpression(path.get("argument"), internal);
-            break;
-        case "TryStatement":
-            meshStatement(path.get("block"), internal);
-            /* istanbul ignore else */
-            if (path.node.handler) {
-                meshStatement(path.get("handler").get("body"), internal);
-            }
-            meshStatement(path.get("finalizer"), internal);
-            break;
-        case "VariableDeclaration": {
-            const _path = path;
-            for (const declaration of _path.get("declarations")) {
-                const expr = declaration.node.init;
-                const initPath = declaration.get("init");
-                const composeMethod = (0, call_js_1.calls)(initPath, ["compose", "store", "view", "mvvmView", "mvcView", "hybridView", "screen"], internal);
-                if (expr && t.isIdentifier(declaration.node.id) && composeMethod) {
-                    meshComposeCall(expr, declaration.node.id, declaration.get("init"), composeMethod, internal);
-                }
-                else {
-                    meshExpression(declaration.get("init"), internal);
-                    ignoreParams(declaration.node.id, internal);
-                }
-            }
-            break;
-        }
-        case "WhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ExportNamedDeclaration": {
-            meshStatement(path.get("declaration"), internal);
-            break;
-        }
-        case "ClassDeclaration":
-            meshClassBody(path.get("body"), internal);
-            break;
-        case "ExportDefaultDeclaration": {
-            const declarationPath = path.get("declaration");
-            /* istanbul ignore else */
-            if (t.isExpression(declarationPath.node)) {
-                meshExpression(declarationPath, internal);
-            }
-            else if (t.isFunctionDeclaration(declarationPath.node)) {
-                meshFunction(declarationPath, internal);
-            }
-            else if (t.isClassDeclaration(declarationPath.node)) {
-                meshClassBody(declarationPath.get("body"), internal);
-            }
-        }
-    }
-}
-function meshFunction(path, internal) {
-    if (t.isFunctionDeclaration(path.node) && path.node.id) {
-        internal.stack.set(path.node.id.name, 1 /* VariableState.Ignored */);
-    }
-    internal.stack.push();
-    const node = path.node;
-    if (t.isFunctionExpression(node) && node.id) {
-        internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
-    }
-    for (const param of node.params) {
-        ignoreParams(param, internal);
-    }
-    if (t.isExpression(node.body)) {
-        meshExpression(path.get("body"), internal);
-    }
-    else {
-        const bodyPath = path.get("body");
-        meshStatement(bodyPath, internal);
-    }
-    internal.stack.pop();
-}
-function composeExpression(path, internal, isRoot) {
-    const expr = path.node;
-    switch (expr && expr.type) {
-        case "AssignmentExpression": {
-            meshExpression(path, internal);
-            break;
-        }
-        case "CallExpression":
-        case "OptionalCallExpression": {
-            if ((0, call_js_1.calls)(path, ["watch"], internal)) {
-                const args = (0, lib_js_1.parseCalculateCall)(path, internal);
-                /* istanbul ignore else */
-                if (args) {
-                    if (args[1].elements.length > 0) {
-                        path.replaceWith(t.callExpression(internal.stateOnly
-                            ? t.memberExpression(internal.id, t.identifier("ex"))
-                            : t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
-                    }
-                    else {
-                        path.replaceWith(t.callExpression(args[0], []));
-                    }
-                }
-            }
-            else if ((0, call_js_1.calls)(path, ["runOnDestroy"], internal)) {
-                if (internal.stateOnly) {
-                    throw path.buildCodeFrameError("Vasille: Stores in Vasille.JS are not destroyable");
-                }
-                path.get("callee").replaceWith(t.memberExpression(internal_js_1.ctx, t.identifier("runOnDestroy")));
-            }
-            else {
-                meshExpression(path, internal);
-            }
-            break;
-        }
-        case "LogicalExpression":
-            composeExpression(path.get("left"), internal);
-            composeExpression(path.get("right"), internal);
-            break;
-        case "ConditionalExpression":
-            meshExpression(path.get("test"), internal);
-            composeExpression(path.get("consequent"), internal);
-            composeExpression(path.get("alternate"), internal);
-            break;
-        case "JSXElement":
-        case "JSXFragment":
-            if (internal.stateOnly) {
-                throw path.buildCodeFrameError("Vasille: JSX is not allowed in states");
-            }
-            path.replaceWithMultiple((0, jsx_js_1.transformJsx)(path, internal));
-            break;
-        default:
-            meshExpression(path, internal, isRoot);
-    }
-}
-function composeStatements(paths, internal, isRoot) {
-    for (const path of paths) {
-        composeStatement(path, internal, isRoot);
-    }
-}
-function composeStatement(path, internal, isRoot) {
-    const statement = path.node;
-    if (!statement) {
-        return;
-    }
-    switch (statement.type) {
-        case "FunctionDeclaration": {
-            meshFunction(path, internal);
-            break;
-        }
-        case "BlockStatement": {
-            internal.stack.push();
-            composeStatements(path.get("body"), internal, isRoot);
-            internal.stack.pop();
-            break;
-        }
-        case "DoWhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ExpressionStatement": {
-            composeExpression(path.get("expression"), internal);
-            break;
-        }
-        case "ForInStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "IfStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("consequent"), internal);
-            internal.stack.pop();
-            internal.stack.push();
-            composeStatement(_path.get("alternate"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "LabeledStatement":
-            composeStatement(path.get("body"), internal);
-            break;
-        case "ReturnStatement":
-            composeExpression(path.get("argument"), internal, isRoot);
-            break;
-        case "SwitchStatement": {
-            const _path = path;
-            meshExpression(_path.get("discriminant"), internal);
-            internal.stack.push();
-            for (const _case of _path.get("cases")) {
-                meshExpression(_case.get("test"), internal);
-                composeStatements(_case.get("consequent"), internal);
-            }
-            internal.stack.pop();
-            break;
-        }
-        case "TryStatement":
-            const tryHandler = path.get("handler");
-            composeStatement(path.get("block"), internal);
-            tryHandler.node && composeStatement(tryHandler.get("body"), internal);
-            composeStatement(path.get("finalizer"), internal);
-            break;
-        case "VariableDeclaration": {
-            const _path = path;
-            const kind = _path.node.kind;
-            const declares = kind === "const" ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */;
-            let switchToConst = true;
-            for (const declaration of _path.get("declarations")) {
-                const id = declaration.node.id;
-                const bridgeMethod = (0, bridge_1.processBridgeCall)(declaration.get("init"), internal);
-                let meshInit = true;
-                function idName(target = id) {
-                    let name = "#";
-                    /* istanbul ignore else */
-                    if (t.isIdentifier(target)) {
-                        name = target.name;
-                    }
-                    return name;
-                }
-                function idDoubleName() {
-                    const pattern = id;
-                    return [idName(pattern.elements[0]), idName(pattern.elements[1])];
-                }
-                ignoreParams(declaration.node.id, internal);
-                /* istanbul ignore else */
-                if (bridgeMethod === "value" && declares === 2 /* VariableState.Reactive */ && t.isIdentifier(declaration.node.id)) {
-                    switchToConst = true;
-                    meshInit = false;
-                    internal.stack.set(declaration.node.id.name, 2 /* VariableState.Reactive */);
-                    declaration.get("init").replaceWith((0, lib_js_1.ref)(declaration.node.init, internal, declaration.node.id.name));
-                }
-                else if (bridgeMethod) {
-                    switchToConst = false;
-                    meshInit = false;
-                }
-                else if ((0, call_js_1.calls)(declaration.get("init"), ["awaited"], internal)) {
-                    reactiveArrayPattern(declaration.get("id"), internal);
-                    meshAllUnknown(declaration.get("init").get("arguments"), internal);
-                    (0, lib_js_1.named)(declaration.node.init, idDoubleName(), internal);
-                    meshInit = false;
-                }
-                else if (t.isIdentifier(id)) {
-                    internal.stack.set(id.name, declares);
-                    const init = declaration.node.init;
-                    const initPath = declaration.get("init");
-                    let callName = false;
-                    if ((0, call_js_1.calls)(initPath, ["value"], internal)) {
-                        internal.stack.set(id.name, 1 /* VariableState.Ignored */);
-                        declaration.get("init").replaceWith(init.arguments[0]);
-                        _path.node.kind = kind;
-                        switchToConst = false;
-                    }
-                    else if ((0, call_js_1.calls)(initPath, ["bind"], internal)) {
-                        const argument = init.arguments[0];
-                        const argumentPath = declaration.get("init").get("arguments")[0];
-                        let replaceWith = declares === 2 /* VariableState.Reactive */
-                            ? (0, lib_js_1.forwardOnlyExpr)(argumentPath, argument, internal)
-                            : (0, lib_js_1.exprCall)(argumentPath, argument, internal, idName());
-                        if (!replaceWith) {
-                            replaceWith =
-                                declares === 2 /* VariableState.Reactive */
-                                    ? t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [argument])
-                                    : (0, lib_js_1.ref)(argument, internal, idName());
-                        }
-                        if (declares === 2 /* VariableState.Reactive */) {
-                            internal.stack.set(id.name, 4 /* VariableState.ReactivePointer */);
-                            replaceWith = (0, lib_js_1.own)(replaceWith, internal, idName());
-                        }
-                        else {
-                            internal.stack.set(id.name, 2 /* VariableState.Reactive */);
-                        }
-                        declaration.get("init").replaceWith(replaceWith);
-                        meshInit = !replaceWith;
-                    }
-                    else if ((0, call_js_1.calls)(initPath, ["ref"], internal)) {
-                        const argument = init.arguments[0];
-                        internal.stack.set(id.name, 2 /* VariableState.Reactive */);
-                        declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
-                    }
-                    else if ((0, call_js_1.calls)(initPath, ["reactiveObject"], internal)) {
-                        const value = init.arguments[0];
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Reactive objects must be must be declared as constants`);
-                        }
-                        if (t.isObjectExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(value, internal, idName()));
-                            internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
-                        }
-                        else {
-                            throw declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
-                        }
-                    }
-                    else if ((0, call_js_1.calls)(initPath, ["arrayModel"], internal)) {
-                        const value = init.arguments[0];
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Array models must be must be declared as constants`);
-                        }
-                        if (t.isArrayExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(value, internal, idName()));
-                        }
-                        else {
-                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(null, internal, idName()));
-                        }
-                    }
-                    else if ((callName = (0, call_js_1.calls)(initPath, ["mapModel", "setModel"], internal))) {
-                        const args = init.arguments;
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: ${callName === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
-                        }
-                        declaration
-                            .get("init")
-                            .replaceWith(callName === "mapModel" ? (0, lib_js_1.mapModel)(args, internal, idName()) : (0, lib_js_1.setModel)(args, internal, idName()));
-                    }
-                    else if (t.isObjectExpression(init)) {
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
-                        }
-                        declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(init, internal, idName()));
-                        internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
-                    }
-                    else if (t.isArrayExpression(init)) {
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
-                        }
-                        declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(init, internal, idName()));
-                    }
-                    else if (t.isNewExpression(init) && t.isIdentifier(init.callee)) {
-                        if (init.callee.name === "Map" || init.callee.name === "Set") {
-                            if (kind !== "const") {
-                                throw declaration.buildCodeFrameError(`Vasille: ${init.callee.name === "Map" ? "Maps" : "Sets"} must be declared as constants`);
-                            }
-                            declaration
-                                .get("init")
-                                .replaceWith(init.callee.name === "Map"
-                                ? (0, lib_js_1.mapModel)(init.arguments, internal, idName())
-                                : (0, lib_js_1.setModel)(init.arguments, internal, idName()));
-                        }
-                    }
-                    else if (declares === 2 /* VariableState.Reactive */) {
-                        const replaceWith = (0, lib_js_1.forwardOnlyExpr)(declaration.get("init"), declaration.node.init, internal);
-                        meshInit = !replaceWith;
-                        internal.stack.set(id.name, replaceWith ? 4 /* VariableState.ReactivePointer */ : 2 /* VariableState.Reactive */);
-                        declaration
-                            .get("init")
-                            .replaceWith(replaceWith ? (0, lib_js_1.own)(replaceWith, internal, idName()) : (0, lib_js_1.ref)(declaration.node.init, internal, idName()));
-                    }
-                    else {
-                        const replaceWith = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal, idName());
-                        if (replaceWith) {
-                            declaration.get("init").replaceWith(replaceWith);
-                        }
-                        internal.stack.set(id.name, replaceWith
-                            ? 2 /* VariableState.Reactive */
-                            : (0, expression_js_1.nodeIsReactiveObject)(declaration.get("init"), internal)
-                                ? 3 /* VariableState.ReactiveObject */
-                                : 1 /* VariableState.Ignored */);
-                        meshInit = !replaceWith;
-                    }
-                }
-                else if (t.isObjectPattern(id)) {
-                    for (const prop of id.properties) {
-                        /* istanbul ignore else */
-                        if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-                            internal.stack.set(prop.value.name, 2 /* VariableState.Reactive */);
-                        }
-                        else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-                            internal.stack.set(prop.argument.name, 3 /* VariableState.ReactiveObject */);
-                        }
-                    }
-                }
-                if (meshInit) {
-                    meshExpression(declaration.get("init"), internal);
-                }
-            }
-            if (switchToConst && (kind === "let" || kind === "var")) {
-                _path.node.kind = "const";
-            }
-            break;
-        }
-        case "WhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForOfStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        default:
-            meshStatement(path, internal);
-    }
-}
-function compose(path, internal, isInternalSlot, composeMethod) {
-    internal.stack.push();
-    const node = path.node;
-    const params = node.params;
-    const body = node.body;
-    const argsNumber = composeArgsNumber[composeMethod];
-    if (t.isFunctionExpression(node) && node.id) {
-        internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
-    }
-    if (params.length > argsNumber && !isInternalSlot) {
-        throw path.get("params")[argsNumber].buildCodeFrameError("Vasille: Extra parameters are not allowed");
-    }
-    const cumulativeFields = new Set();
-    const nonPropsFields = [];
-    let index = 0;
-    for (const param of path.get("params")) {
-        const node = param.node;
-        const isProps = index === composePropsIndex[composeMethod];
-        if (t.isAssignmentPattern(node)) {
-            throw param.buildCodeFrameError("Vasille: No default value allowed here");
-        }
-        if (argsNumber !== 1) {
-            if (t.isObjectPattern(node)) {
-                for (const prop of node.properties) {
-                    if (t.isObjectProperty(prop)) {
-                        const name = (0, utils_1.stringify)(prop.key);
-                        if (cumulativeFields.has(name)) {
-                            throw param.buildCodeFrameError(`Vasille: Field "${name}" is defined twice`);
-                        }
-                        cumulativeFields.add(name);
-                        if (!isProps) {
-                            nonPropsFields.push(name);
-                        }
-                    }
-                    else {
-                        throw param.buildCodeFrameError("Vasille: Rest element is not supported here");
-                    }
-                }
-            }
-        }
-        if (t.isIdentifier(node) && argsNumber === 1) {
-            internal.stack.set(node.name, isInternalSlot || !isProps ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
-        }
-        else if ((isInternalSlot || !isProps) && t.isObjectPattern(node)) {
-            ignoreObjectPattern(node, internal);
-        }
-        else if (t.isObjectPattern(node)) {
-            for (const prop of param.get("properties")) {
-                const node = prop.node;
-                if (t.isObjectProperty(node)) {
-                    const key = node.key;
-                    let keyName = "";
-                    /* istanbul ignore else */
-                    if (t.isIdentifier(node.value)) {
-                        keyName = node.value.name;
-                    }
-                    else if (t.isIdentifier(key) && !node.computed) {
-                        keyName = key.name;
-                    }
-                    internal.stack.set(keyName, 2 /* VariableState.Reactive */);
-                    if (t.isAssignmentPattern(node.value)) {
-                        const assignPath = prop.get("value");
-                        assignPath
-                            .get("right")
-                            .replaceWith(t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [assignPath.node.right]));
-                    }
-                    else if (!t.isIdentifier(node.value)) {
-                        throw prop.buildCodeFrameError("Vasille: Value decomposition is not allowed here");
-                    }
-                }
-                if (t.isRestElement(node)) {
-                    internal.stack.set(node.argument.name, 3 /* VariableState.ReactiveObject */);
-                }
-            }
-        }
-        else {
-            throw param.buildCodeFrameError(argsNumber === 1 ? "Vasille: Expected identifier or object pattern" : "Vasille: Expected object pattern here");
-        }
-        index++;
-    }
-    if (argsNumber !== 1) {
-        node.params = [
-            t.objectPattern([
-                ...params[0].properties,
-                ...params[1].properties,
-            ]),
-        ];
-    }
-    internal.isComposing = true;
-    /* istanbul ignore else */
-    if (t.isExpression(body)) {
-        composeExpression(path.get("body"), internal, true);
-    }
-    else if (t.isBlockStatement(body)) {
-        composeStatement(path.get("body"), internal, true);
-    }
-    internal.isComposing = false;
-    internal.stack.pop();
-    return nonPropsFields;
-}