babel-plugin-vasille 0.99.0

package/lib-node/mesh.js

@@ -0,0 +1,971 @@
+"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.meshOrIgnoreAllExpressions = meshOrIgnoreAllExpressions;
+exports.meshAllExpressions = meshAllExpressions;
+exports.meshComposeCall = meshComposeCall;
+exports.meshAllUnknown = meshAllUnknown;
+exports.meshLValue = meshLValue;
+exports.meshOrIgnoreExpression = meshOrIgnoreExpression;
+exports.meshExpression = meshExpression;
+exports.meshBody = meshBody;
+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 call_js_1 = require("./call.js");
+const internal_js_1 = require("./internal.js");
+const jsx_detect_js_1 = require("./jsx-detect.js");
+const lib_js_1 = require("./lib.js");
+const jsx_js_1 = require("./jsx.js");
+function meshOrIgnoreAllExpressions(nodePaths, internal) {
+    for (const path of nodePaths) {
+        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, 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];
+    compose(fnPath, internal, false);
+    arg.params.unshift(internal_js_1.ctx);
+    if (t.isArrowFunctionExpression(arg) && internal.devMode) {
+        fnPath.replaceWith(t.functionExpression(t.identifier(internal.prefix + (name ? name.name : "Default")), arg.params, t.isBlockStatement(arg.body) ? arg.body : t.blockStatement([t.returnStatement(arg.body)]), false, arg.async));
+    }
+    else if (t.isFunctionExpression(arg) && name && internal.devMode) {
+        arg.id = t.identifier(internal.prefix + name.name);
+    }
+}
+function meshAllUnknown(paths, internal) {
+    for (const path of paths) {
+        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;
+    if (t.isArrayPattern(node) ||
+        t.isObjectPattern(node) ||
+        t.isTSParameterProperty(node) ||
+        t.isAssignmentPattern(node) ||
+        t.isRestElement(node)) {
+        return;
+    }
+    meshExpression(path, internal);
+}
+function meshOrIgnoreExpression(path, internal) {
+    if (t.isExpression(path.node)) {
+        meshExpression(path, internal);
+    }
+}
+function meshExpression(nodePath, internal) {
+    const expr = nodePath.node;
+    if (!expr) {
+        return;
+    }
+    if ((0, call_js_1.calls)(expr, ["compose", "extend"], internal)) {
+        meshComposeCall(expr, null, nodePath, 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 (state === 2 /* VariableState.Reactive */) {
+                nodePath.replaceWith(t.memberExpression(expr, t.identifier("$")));
+            }
+            else if (state === 4 /* VariableState.ReactivePointer */) {
+                nodePath.replaceWith(t.memberExpression(expr, t.identifier("$$")));
+            }
+            break;
+        }
+        case "ArrayExpression": {
+            const path = nodePath;
+            meshAllUnknown(path.get("elements"), internal);
+            break;
+        }
+        case "TupleExpression": {
+            const path = nodePath;
+            meshAllUnknown(path.get("elements"), internal);
+            break;
+        }
+        case "CallExpression": {
+            const path = nodePath;
+            const callsFn = (0, call_js_1.calls)(path.node, call_js_1.composeOnly, internal);
+            if (callsFn) {
+                throw path.buildCodeFrameError(`Vasille: Usage of function "${callsFn}" is restricted here`);
+            }
+            meshOrIgnoreExpression(path.get("callee"), internal);
+            meshAllUnknown(path.get("arguments"), internal);
+            if ((0, call_js_1.calls)(path.node, ["calculate"], internal)) {
+                if (path.node.arguments.length !== 1 && !t.isExpression(path.node.arguments[0])) {
+                    throw path.buildCodeFrameError("Vasille: Incorrect calculate argument");
+                }
+                path.replaceWith(t.callExpression(path.node.arguments[0], []));
+            }
+            break;
+        }
+        case "OptionalCallExpression": {
+            const path = nodePath;
+            meshExpression(path.get("callee"), internal);
+            meshAllUnknown(path.get("arguments"), internal);
+            break;
+        }
+        case "AssignmentExpression": {
+            const path = nodePath;
+            const left = path.node.left;
+            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);
+                }
+                else {
+                    meshExpression(path.get("right"), internal);
+                }
+            }
+            else {
+                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 (t.isIdentifier(node.object) && internal.stack.get(node.object.name) === 3 /* VariableState.ReactiveObject */) {
+                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 "ParenthesizedExpression": {
+            const path = nodePath;
+            meshExpression(path.get("expression"), 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 "TypeCastExpression": {
+            const path = nodePath;
+            meshExpression(path.get("expression"), internal);
+            break;
+        }
+        case "BindExpression": {
+            const path = nodePath;
+            meshExpression(path.get("callee"), internal);
+            meshExpression(path.get("object"), internal);
+            break;
+        }
+        case "PipelineTopicExpression": {
+            const path = nodePath;
+            meshExpression(path.get("expression"), internal);
+            break;
+        }
+        case "PipelineBareFunction": {
+            const path = nodePath;
+            meshExpression(path.get("callee"), 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");
+                    if (valuePath instanceof Array) {
+                        meshAllExpressions(valuePath, internal);
+                    }
+                    else {
+                        meshOrIgnoreExpression(valuePath, internal);
+                    }
+                }
+                else if (t.isObjectMethod(prop)) {
+                    meshFunction(propPath, internal);
+                }
+                else {
+                    meshAllUnknown([propPath], internal);
+                }
+            }
+            break;
+        }
+        case "FunctionExpression": {
+            meshFunction(nodePath, internal);
+            break;
+        }
+        case "ArrowFunctionExpression": {
+            meshFunction(nodePath, 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");
+        }
+        case "BigIntLiteral":
+        case "BooleanLiteral":
+        case "ClassExpression":
+        case "DecimalLiteral":
+        case "DoExpression":
+        case "Import":
+        case "ImportExpression":
+        case "MetaProperty":
+        case "ModuleExpression":
+        case "NullLiteral":
+        case "NumericLiteral":
+        case "PipelinePrimaryTopicReference":
+        case "RecordExpression":
+        case "RegExpLiteral":
+        case "StringLiteral":
+        case "Super":
+        case "TSNonNullExpression":
+        case "ThisExpression":
+        case "TopicReference":
+    }
+}
+function meshBody(path, internal) {
+    if (t.isExpression(path.node)) {
+        meshExpression(path, internal);
+    }
+    else {
+        for (const statementPath of path.get("body")) {
+            meshStatement(statementPath, internal);
+        }
+    }
+}
+function meshStatements(paths, internal) {
+    for (const path of paths) {
+        meshStatement(path, internal);
+    }
+}
+function ignoreParams(val, internal) {
+    if (t.isAssignmentPattern(val)) {
+        val = val.left;
+    }
+    if (t.isIdentifier(val)) {
+        internal.stack.set(val.name, 1 /* VariableState.Ignored */);
+    }
+    else if (t.isObjectPattern(val)) {
+        for (const prop of val.properties) {
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+                internal.stack.set(prop.value.name, 1 /* VariableState.Ignored */);
+            }
+            else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                internal.stack.set(prop.argument.name, 1 /* VariableState.Ignored */);
+            }
+        }
+    }
+    else if (t.isArrayPattern(val)) {
+        for (const element of val.elements) {
+            if (element) {
+                ignoreParams(element, internal);
+            }
+        }
+    }
+}
+function reactiveArrayPattern(expr, internal) {
+    if (t.isArrayPattern(expr)) {
+        for (const element of expr.elements) {
+            if (t.isIdentifier(element)) {
+                internal.stack.set(element.name, 2 /* VariableState.Reactive */);
+            }
+        }
+    }
+    else if (t.isIdentifier(expr)) {
+        internal.stack.set(expr.name, 3 /* VariableState.ReactiveObject */);
+    }
+    else {
+        return false;
+    }
+    return true;
+}
+function meshStatement(path, internal) {
+    const statement = path.node;
+    if (!statement) {
+        return;
+    }
+    switch (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;
+            const left = _path.node.left;
+            internal.stack.push();
+            meshExpression(_path.get("right"), internal);
+            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
+                ignoreParams(left.declarations[0].id, internal);
+            }
+            meshStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        case "ForOfStatement": {
+            const _path = path;
+            const left = _path.node.left;
+            internal.stack.push();
+            meshExpression(_path.get("right"), internal);
+            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
+                ignoreParams(left.declarations[0].id, internal);
+            }
+            meshStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        case "ForStatement": {
+            const _path = path;
+            const node = _path.node;
+            internal.stack.push();
+            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);
+            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);
+            break;
+        case "VariableDeclaration": {
+            const _path = path;
+            for (const declaration of _path.get("declarations")) {
+                const expr = declaration.node.init;
+                let ignore = true;
+                if (expr && t.isIdentifier(declaration.node.id) && (0, call_js_1.calls)(expr, ["compose", "extend"], internal)) {
+                    meshComposeCall(expr, declaration.node.id, declaration.get("init"), internal);
+                }
+                else {
+                    meshExpression(declaration.get("init"), internal);
+                    if (ignore) {
+                        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 "WithStatement": {
+            const _path = path;
+            meshExpression(_path.get("object"), internal);
+            internal.stack.push();
+            meshStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        case "ExportNamedDeclaration": {
+            meshStatement(path.get("declaration"), internal);
+            break;
+        }
+        // Ignored
+        case "ExportDefaultDeclaration":
+        case "ExportAllDeclaration":
+        case "BreakStatement":
+        case "ContinueStatement":
+        case "DebuggerStatement":
+        case "EmptyStatement":
+        case "ClassDeclaration":
+        case "ImportDeclaration":
+        case "DeclareClass":
+        case "DeclareFunction":
+        case "DeclareInterface":
+        case "DeclareModule":
+        case "DeclareModuleExports":
+        case "DeclareTypeAlias":
+        case "DeclareOpaqueType":
+        case "DeclareVariable":
+        case "DeclareExportDeclaration":
+        case "DeclareExportAllDeclaration":
+        case "InterfaceDeclaration":
+        case "OpaqueType":
+        case "TypeAlias":
+        case "EnumDeclaration":
+        case "TSDeclareFunction":
+        case "TSInterfaceDeclaration":
+        case "TSTypeAliasDeclaration":
+        case "TSEnumDeclaration":
+        case "TSModuleDeclaration":
+        case "TSImportEqualsDeclaration":
+        case "TSExportAssignment":
+        case "TSNamespaceExportDeclaration":
+    }
+}
+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) {
+    const expr = path.node;
+    if (!expr) {
+        return;
+    }
+    switch (expr.type) {
+        case "AssignmentExpression": {
+            const assign = expr;
+            if ((0, call_js_1.calls)(assign.right, ["awaited"], internal)) {
+                reactiveArrayPattern(assign.left, internal);
+            }
+            else {
+                meshExpression(path, internal);
+            }
+            break;
+        }
+        case "CallExpression":
+        case "OptionalCallExpression": {
+            const call = expr;
+            let replaced = false;
+            if ((0, call_js_1.calls)(call, ["watch"], internal)) {
+                const args = (0, lib_js_1.parseCalculateCall)(path, internal);
+                if (args) {
+                    path.replaceWith(t.callExpression(t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
+                    replaced = true;
+                }
+            }
+            else if ((0, call_js_1.calls)(call, ["arrayModel"], internal)) {
+                const value = call.arguments[0];
+                if (t.isArrayExpression(value)) {
+                    path.replaceWith((0, lib_js_1.arrayModel)(value, internal));
+                    replaced = true;
+                }
+                else {
+                    path.buildCodeFrameError(`Vasille: arrayModel requires array expression as argument`);
+                }
+            }
+            else if ((0, call_js_1.calls)(call, ["mapModel", "setModel"], internal)) {
+                const args = call.arguments;
+                const name = (0, call_js_1.calls)(call, ["mapModel", "setModel"], internal);
+                path.replaceWith(name === "mapModel" ? (0, lib_js_1.mapModel)(args, internal) : (0, lib_js_1.setModel)(args, internal));
+                replaced = true;
+            }
+            if (!replaced) {
+                meshExpression(path, internal);
+            }
+            break;
+        }
+        case "JSXElement":
+        case "JSXFragment":
+            path.replaceWithMultiple((0, jsx_js_1.transformJsx)(path, internal));
+            break;
+        default:
+            meshExpression(path, internal);
+    }
+}
+function composeStatements(paths, internal) {
+    for (const path of paths) {
+        composeStatement(path, internal);
+    }
+}
+function composeStatement(path, internal) {
+    const statement = path.node;
+    if (!statement) {
+        return;
+    }
+    switch (statement.type) {
+        case "FunctionDeclaration": {
+            const _path = path;
+            const fn = _path.node;
+            if ((0, jsx_detect_js_1.bodyHasJsx)(fn.body)) {
+                compose(_path, internal, false);
+            }
+            else {
+                meshFunction(_path, internal);
+            }
+            break;
+        }
+        case "BlockStatement": {
+            internal.stack.push();
+            composeStatements(path.get("body"), internal);
+            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;
+            const left = _path.node.left;
+            internal.stack.push();
+            meshExpression(_path.get("right"), internal);
+            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
+                ignoreParams(left.declarations[0].id, internal);
+            }
+            composeStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        case "ForStatement": {
+            const _path = path;
+            const node = _path.node;
+            internal.stack.push();
+            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);
+            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);
+            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":
+            composeStatement(path.get("block"), internal);
+            break;
+        case "VariableDeclaration": {
+            const _path = path;
+            const kind = _path.node.kind;
+            const declares = kind === "const" ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */;
+            if (kind === "let" || kind === "var") {
+                _path.node.kind = "const";
+            }
+            for (const declaration of _path.get("declarations")) {
+                const id = declaration.node.id;
+                let meshInit = true;
+                ignoreParams(declaration.node.id, internal);
+                if ((0, call_js_1.calls)(declaration.node.init, ["awaited"], internal)) {
+                    reactiveArrayPattern(declaration.node.id, internal);
+                    meshAllUnknown(declaration.get("init").get("arguments"), internal);
+                    meshInit = false;
+                }
+                else if (t.isIdentifier(id)) {
+                    internal.stack.set(id.name, declares);
+                    const init = declaration.node.init;
+                    if ((0, call_js_1.calls)(init, ["value"], internal)) {
+                        internal.stack.set(id.name, 1 /* VariableState.Ignored */);
+                        declaration.get("init").replaceWith(init.arguments[0]);
+                        _path.node.kind = kind;
+                    }
+                    else if ((0, call_js_1.calls)(init, ["bind"], internal)) {
+                        const argument = init.arguments[0];
+                        const replaceWith = declares === 2 /* VariableState.Reactive */
+                            ? (0, lib_js_1.forwardOnlyExpr)(declaration.get("init"), argument, internal)
+                            : (0, lib_js_1.exprCall)(declaration.get("init"), argument, internal);
+                        let insertNode = replaceWith !== null && replaceWith !== void 0 ? replaceWith : (0, lib_js_1.ref)(t.isExpression(argument) ? argument : null);
+                        if (declares === 2 /* VariableState.Reactive */) {
+                            internal.stack.set(id.name, 4 /* VariableState.ReactivePointer */);
+                            insertNode = (0, lib_js_1.own)(insertNode);
+                        }
+                        else {
+                            internal.stack.set(id.name, 2 /* VariableState.Reactive */);
+                        }
+                        declaration.get("init").replaceWith(insertNode);
+                        meshInit = !replaceWith;
+                    }
+                    else if ((0, call_js_1.calls)(init, ["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));
+                    }
+                    else if ((0, call_js_1.calls)(init, ["reactiveObject"], internal)) {
+                        const value = init.arguments[0];
+                        if (kind !== "const") {
+                            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));
+                            internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
+                        }
+                        else {
+                            declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
+                        }
+                    }
+                    else if ((0, call_js_1.calls)(init, ["arrayModel"], internal)) {
+                        const value = init.arguments[0];
+                        if (kind !== "const") {
+                            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));
+                        }
+                        else {
+                            declaration.buildCodeFrameError(`Vasille: arrayModel requires array expression as argument`);
+                        }
+                    }
+                    else if ((0, call_js_1.calls)(init, ["mapModel", "setModel"], internal)) {
+                        const args = init.arguments;
+                        const name = (0, call_js_1.calls)(init, ["mapModel", "setModel"], internal);
+                        if (kind !== "const") {
+                            declaration.buildCodeFrameError(`Vasille: ${name === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
+                        }
+                        declaration
+                            .get("init")
+                            .replaceWith(name === "mapModel" ? (0, lib_js_1.mapModel)(args, internal) : (0, lib_js_1.setModel)(args, internal));
+                    }
+                    else if (t.isObjectExpression(init)) {
+                        if (kind !== "const") {
+                            declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
+                        }
+                        declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(init, internal));
+                        internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
+                    }
+                    else if (t.isArrayExpression(init)) {
+                        if (kind !== "const") {
+                            declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
+                        }
+                        declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(init, internal));
+                    }
+                    else if (t.isNewExpression(init) && t.isIdentifier(init.callee)) {
+                        if (init.callee.name === "Map" || init.callee.name === "Set") {
+                            if (kind !== "const") {
+                                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) : (0, lib_js_1.setModel)(init.arguments, internal));
+                        }
+                    }
+                    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) : (0, lib_js_1.ref)(declaration.node.init));
+                    }
+                    else {
+                        const replaceWith = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal);
+                        if (replaceWith) {
+                            declaration.get("init").replaceWith(replaceWith);
+                        }
+                        internal.stack.set(id.name, replaceWith ? 2 /* VariableState.Reactive */ : 1 /* VariableState.Ignored */);
+                        meshInit = !replaceWith;
+                    }
+                }
+                if (meshInit) {
+                    meshExpression(declaration.get("init"), internal);
+                }
+            }
+            break;
+        }
+        case "WhileStatement": {
+            const _path = path;
+            meshExpression(_path.get("test"), internal);
+            internal.stack.push();
+            composeStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        case "WithStatement": {
+            throw path.buildCodeFrameError("Vasille: Usage of 'with' in components is restricted");
+        }
+        case "ForOfStatement": {
+            const _path = path;
+            const left = _path.node.left;
+            internal.stack.push();
+            meshExpression(_path.get("right"), internal);
+            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
+                ignoreParams(left.declarations[0].id, internal);
+            }
+            composeStatement(_path.get("body"), internal);
+            internal.stack.pop();
+            break;
+        }
+        default:
+            meshStatement(path, internal);
+    }
+}
+function compose(path, internal, isInternalSlot) {
+    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;
+    const params = node.params;
+    const body = node.body;
+    if (t.isFunctionExpression(node) && node.id) {
+        internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
+    }
+    if (params.length > 1) {
+        throw path.get("params")[1].buildCodeFrameError("Vasille: JSX compoent must have no more then 1 parameter");
+    }
+    for (const param of params) {
+        const target = t.isAssignmentPattern(param) ? param.left : param;
+        if (t.isIdentifier(target)) {
+            internal.stack.set(target.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+        }
+        else if (t.isObjectPattern(target)) {
+            for (const prop of target.properties) {
+                if (t.isObjectProperty(prop)) {
+                    if (t.isIdentifier(prop.value)) {
+                        internal.stack.set(prop.value.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */);
+                    }
+                    else if (t.isIdentifier(prop.key)) {
+                        internal.stack.set(prop.key.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */);
+                    }
+                }
+                else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                    internal.stack.set(prop.argument.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+                }
+            }
+        }
+        else {
+            throw path.get("params")[0].buildCodeFrameError("Vasille: Parameter must be an identifier of object pattern");
+        }
+    }
+    for (const param of path.get("params")) {
+        if (t.isObjectPattern(param.node)) {
+            for (const prop of param.get("properties")) {
+                if (t.isObjectProperty(prop.node) && t.isAssignmentPattern(prop.node.value)) {
+                    const assignPath = prop.get("value");
+                    assignPath
+                        .get("right")
+                        .replaceWith(t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [assignPath.node.right]));
+                }
+            }
+        }
+    }
+    if (t.isExpression(body)) {
+        composeExpression(path.get("body"), internal);
+    }
+    else if (t.isBlockStatement(body)) {
+        composeStatement(path.get("body"), internal);
+    }
+    internal.stack.pop();
+}