babel-plugin-vasille 5.1.1 → 5.1.3

package/lib/communication.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/expression.js

@@ -54,6 +54,7 @@ const lib_1 = require("./lib");
 const mesh_1 = require("./mesh");
 const router_1 = require("./router");
 const utils_1 = require("./utils");
+const operators_1 = require("./operators");
 function insertName(name, search) {
     const id = t.identifier(name);
     search?.inserted.add(id);
@@ -69,7 +70,8 @@ function addExpression(path, search) {
         let it = path.node;
         while (t.isMemberExpression(it) || t.isIdentifier(it)) {
             const name = (0, utils_1.stringify)(t.isMemberExpression(it) ? it.property : it);
-            if (it !== path.node && name.startsWith("$")) {
+            const computed = t.isMemberExpression(it) ? it.computed : false;
+            if (it !== path.node && name.startsWith("$") && !computed) {
                 (0, lib_1.err)(lib_1.Errors.RulesOfVasille, path, "The reactive/observable value is nested", search.external, null);
             }
             it = t.isMemberExpression(it) ? it.object : null;
@@ -95,10 +97,11 @@ function meshIdentifier(path) {
 }
 function idIsIValue(path) {
     const node = path.node;
-    return node.name.startsWith("$") && (!t.isMemberExpression(path.parent) || path.parent.object === node);
+    return (node.name.startsWith("$") &&
+        (!(t.isMemberExpression(path.parent) && !path.parent.computed) || path.parent.object === node));
 }
 function memberIsIValue(node) {
-    return ((t.isIdentifier(node.property) && node.property.name.startsWith("$")) ||
+    return ((t.isIdentifier(node.property) && node.property.name.startsWith("$") && !node.computed) ||
         (t.isStringLiteral(node.property) && node.property.value.startsWith("$")));
 }
 function memberIsIValueInExpr(path, search) {
@@ -191,6 +194,9 @@ function checkNode(path, internal, area, name) {
         path.replaceWith((0, lib_1.ref)(refValue, internal, area, name));
         search.self = path.node;
     }
+    if (path.isTSAsExpression() || path.isTSSatisfiesExpression()) {
+        return checkNode(path.get("expression"), internal, area, name);
+    }
     if (search.self) {
         return search;
     }
@@ -302,13 +308,7 @@ function checkExpression(nodePath, search) {
             const left = path.get("left");
             const right = path.get("right");
             if (left.isMemberExpression() && !exprIsSure(left, search.external)) {
-                const property = left.node.property;
-                (0, mesh_1.meshExpression)(left.get("object"), search.external);
-                checkExpression(right, search);
-                /* istanbul ignore else */
-                if (!t.isPrivateName(property)) {
-                    path.replaceWith(search.external.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, right.node, path.node));
-                }
+                (0, operators_1.meshAssigment)(path, left, right, left.node.property, search.external);
             }
             else {
                 meshLValue(left, search.external);

package/lib/index.js

@@ -14,6 +14,8 @@ function default_1() {
                     headTag: !!params.opts.headTag,
                     bodyTag: !!params.opts.bodyTag,
                     shadow: !!params.opts.shadow,
+                    throwAtFirstError: !!params.opts.throwAtFirstError,
+                    reporter: typeof params.opts.reporter === "function" ? params.opts.reporter : undefined,
                 });
             },
         },

package/lib/jsx.js

@@ -48,18 +48,21 @@ function transformJsx(path, conditions, internal) {
     }
     return transformJsxArray(path.get("children"), internal);
 }
+function textIsSpacesOnly(node) {
+    return t.isJSXText(node) && /^\s+$/.test(node.value) && node.value !== " ";
+}
 function transformJsxArray(paths, internal) {
     const result = [];
     const conditions = { cases: null };
     paths.forEach(path => {
-        if (!path.isJSXElement() && !(path.isJSXText() && /^\s+$/.test(path.node.value))) {
+        if (!path.isJSXElement() && !textIsSpacesOnly(path.node)) {
             result.push(...processConditions(conditions, internal));
         }
         if (path.isJSXElement() || path.isJSXFragment()) {
             result.push(...transformJsx(path, conditions, internal));
         }
         else if (path.isJSXText()) {
-            if (!/^\s+$/.test(path.node.value)) {
+            if (!textIsSpacesOnly(path.node)) {
                 const fixed = path.node.value
                     .replace(/\n\s+$/m, "")
                     .replace(/^\s*\n\s+/m, "")
@@ -284,7 +287,7 @@ function transformJsxElement(path, conditions, internal) {
                             }
                         }
                         else {
-                            (0, lib_js_1.err)(lib_js_1.Errors.TokenNotSupported, valuePath, "Expected event handler", internal);
+                            (0, lib_js_1.err)(lib_js_1.Errors.TokenNotSupported, attrPath, "Expected event handler", internal);
                         }
                     }
                     else if (name.name === "class") {
@@ -349,7 +352,7 @@ function transformJsxElement(path, conditions, internal) {
                         // class={`a ${b}`}
                         else if (expressionPath && expressionPath.isExpression()) {
                             if ((0, lib_js_1.exprCall)(expressionPath, expressionPath.node, internal, { strong: true }, expressionPath.node)) {
-                                console.warn(attrPath.buildCodeFrameError("Vasille: This will slow down your application"));
+                                internal.reportError("This will slow down your application", attrPath.node);
                             }
                             attrs.push(t.objectProperty(t.identifier("class"), expressionPath.node));
                         }
@@ -427,7 +430,7 @@ function transformJsxElement(path, conditions, internal) {
                             /* istanbul ignore else */
                             if (expressionPath && expressionPath.isExpression()) {
                                 if ((0, lib_js_1.exprCall)(expressionPath, expressionPath.node, internal, { strong: true }, expressionPath.node)) {
-                                    console.warn(attrPath.buildCodeFrameError("Vasille: This will slow down your application"));
+                                    internal.reportError("This will slow down your application", attrPath.node);
                                 }
                                 attrs.push(t.objectProperty(t.identifier("style"), expressionPath.node));
                             }
@@ -561,26 +564,16 @@ function transformJsxElement(path, conditions, internal) {
             if (!t.isJSXText(item)) {
                 return true;
             }
-            return !!item.value.trim();
+            return !textIsSpacesOnly(item);
         });
         const isInternal = internal.mapping.has(name.name);
-        // The child is a slot value
-        if (filteredChildren.length === 1 &&
-            t.isJSXExpressionContainer(filteredChildren[0]) &&
-            (t.isFunctionExpression(filteredChildren[0].expression) ||
-                t.isArrowFunctionExpression(filteredChildren[0].expression))) {
-            transformJsxExpressionContainer(path.get("children")[element.children.indexOf(filteredChildren[0])], internal, true, isInternal, false, true);
-            run = filteredChildren[0].expression;
-        }
-        else {
-            const statements = transformJsxArray(path.get("children"), internal);
-            if (statements.length > 0) {
-                const params = [internal_js_1.ctx];
-                if (!isInternal) {
-                    params.unshift(t.identifier(`_${internal.prefix}`));
-                }
-                run = t.arrowFunctionExpression(params, t.blockStatement(statements));
+        const statements = transformJsxArray(path.get("children"), internal);
+        if (statements.length > 0) {
+            const params = [internal_js_1.ctx];
+            if (!isInternal) {
+                params.unshift(t.identifier(`_${internal.prefix}`));
             }
+            run = t.arrowFunctionExpression(params, t.blockStatement(statements));
         }
         const ret = [];
         const filter = (v) => {
@@ -601,6 +594,7 @@ function transformJsxElement(path, conditions, internal) {
                 (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, path, "Malformed JSX If tag is missing", internal);
             }
             if (mapped === "If" || mapped === "ElseIf") {
+                /* istanbul ignore else */
                 if (t.isExpression(condition) && (t.isFunctionExpression(slot) || t.isArrowFunctionExpression(slot))) {
                     if (!conditions.cases) {
                         conditions.cases = [{ condition, slot }];

package/lib/lib.js

@@ -68,10 +68,7 @@ function err(e, node, content, internal, ret) {
     Error.stackTraceLimit = 0;
     const error = node.buildCodeFrameError(`Vasille[${e}]{${Errors[e]}}: ${content}`, Error);
     Error.stackTraceLimit = limit;
-    if (!internal.firstError) {
-        internal.firstError = error;
-    }
-    console.log(error);
+    internal.reportError(`${Errors[e]}: ${content}`, node.node, error);
     return ret;
 }
 function processCalculateCall(path, internal, area, name) {
@@ -115,6 +112,9 @@ function bindCall(path, expr, data, internal, name) {
     return false;
 }
 function exprCall(path, expr, internal, opts, area) {
+    if (path.isTSAsExpression() || path.isTSSatisfiesExpression()) {
+        return exprCall(path.get("expression"), path.node.expression, internal, opts, area);
+    }
     if (parseCalculateCall(path, internal, area, opts.name)) {
         return true;
     }

package/lib/mesh.js

@@ -61,6 +61,7 @@ const router_1 = require("./router");
 const utils_1 = require("./utils");
 const transformer_1 = require("./transformer");
 const process_types_1 = require("./process-types");
+const operators_1 = require("./operators");
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
         /* istanbul ignore else */
@@ -285,12 +286,7 @@ function meshExpression(nodePath, internal) {
                     property.name[0] === "$" &&
                     t.isThisExpression(left.node.object) &&
                     ((right.isIdentifier() && (0, expression_js_1.idIsIValue)(right)) || (right.isMemberExpression() && (0, expression_js_1.memberIsIValue)(right.node))))) {
-                    meshExpression(left.get("object"), internal);
-                    meshExpression(right, internal);
-                    /* istanbul ignore else */
-                    if (!t.isPrivateName(property)) {
-                        path.replaceWith(internal.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, right.node, path.node));
-                    }
+                    (0, operators_1.meshAssigment)(path, left, right, property, internal);
                 }
             }
             else if (internal.devLayer &&
@@ -309,9 +305,10 @@ function meshExpression(nodePath, internal) {
             const path = nodePath;
             const node = path.node;
             const property = path.node.property;
+            const propertyPath = path.get("property");
             meshExpression(path.get("object"), internal);
-            if (t.isExpression(property) && !t.isIdentifier(property)) {
-                meshOrIgnoreExpression(path.get("property"), internal);
+            if (t.isExpression(property) && (!propertyPath.isIdentifier() || (node.computed && (0, expression_js_1.idIsIValue)(propertyPath)))) {
+                meshOrIgnoreExpression(propertyPath, internal);
             }
             if ((0, expression_js_1.memberIsIValue)(node)) {
                 if (!(0, expression_js_1.nodeIsMeshed)(path)) {
@@ -1113,6 +1110,15 @@ function composeStatement(path, internal) {
                     }
                     meshInit = false;
                 }
+                else if ((0, call_js_1.calls)(declaration.get("init"), call_js_1.dependencyInjections, internal)) {
+                    const callPath = declaration.get("init");
+                    callPath.node.arguments.unshift(internal_js_1.ctx);
+                    meshAllUnknown(callPath.get("arguments"), internal);
+                    meshInit = false;
+                    if (t.isIdentifier(id)) {
+                        (0, lib_js_1.checkNonReactiveName)(declaration.get("id"), internal);
+                    }
+                }
                 else if (t.isIdentifier(id)) {
                     const idPath = declaration.get("id");
                     internal.stack.set(id.name, {});
@@ -1130,9 +1136,6 @@ function composeStatement(path, internal) {
                         const argument = init.arguments[0];
                         const isReactive = (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { name: idName(), strong: true }, declaration.node);
                         meshInit = !isReactive;
-                        if (!isReactive) {
-                            declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, declaration.node, idName()));
-                        }
                         (0, lib_js_1.checkReactiveName)(idPath, internal);
                     }
                     // let y = ref(2)
@@ -1190,7 +1193,8 @@ function composeStatement(path, internal) {
                     else if (kind === "const" &&
                         (initPath.isOptionalMemberExpression() || initPath.isMemberExpression()) &&
                         initPath.node.computed &&
-                        t.isIdentifier(initPath.node.property)) {
+                        t.isIdentifier(initPath.node.property) &&
+                        !(0, expression_js_1.idIsIValue)(initPath.get("property"))) {
                         const path = initPath;
                         const property = path.get("property");
                         meshExpression(path.get("object"), internal);

package/lib/operators.js

@@ -0,0 +1,90 @@
+"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.assignmentToBinaryOperator = assignmentToBinaryOperator;
+exports.assignmentToLogicalOperator = assignmentToLogicalOperator;
+exports.meshAssigment = meshAssigment;
+const internal_1 = require("./internal");
+const mesh_1 = require("./mesh");
+const t = __importStar(require("@babel/types"));
+const assigmentToBinaryMap = {
+    "+=": "+",
+    "-=": "-",
+    "/=": "/",
+    "%=": "%",
+    "*=": "*",
+    "**=": "**",
+    "&=": "&",
+    "|=": "|",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "<<=": "<<",
+    "^=": "^",
+};
+const assigmentToLogicalMap = {
+    "&&=": "&&",
+    "||=": "||",
+    "??=": "??",
+};
+function assignmentToBinaryOperator(operator) {
+    if (operator in assigmentToBinaryMap) {
+        return assigmentToBinaryMap[operator];
+    }
+}
+function assignmentToLogicalOperator(operator) {
+    if (operator in assigmentToLogicalMap) {
+        return assigmentToLogicalMap[operator];
+    }
+}
+function meshAssigment(path, left, right, property, internal) {
+    const binary = assignmentToBinaryOperator(path.node.operator);
+    const logical = assignmentToLogicalOperator(path.node.operator);
+    (0, mesh_1.meshExpression)(left.get("object"), internal);
+    (0, mesh_1.meshExpression)(right, internal);
+    /* istanbul ignore else */
+    if (!t.isPrivateName(property)) {
+        let replaceWith = right.node;
+        if (logical || binary) {
+            const meshedLeft = t.optionalMemberExpression(left.node, internal_1.V, false, true);
+            if (binary) {
+                replaceWith = t.binaryExpression(binary, meshedLeft, right.node);
+            }
+            if (logical) {
+                replaceWith = t.logicalExpression(logical, meshedLeft, right.node);
+            }
+        }
+        path.replaceWith(internal.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, replaceWith, path.node));
+    }
+}

package/lib/transformer.js

@@ -207,6 +207,7 @@ function transformProgram(path, filename, opts) {
         }
         return t.callExpression(t.identifier(ids[key]), args);
     }
+    const reports = [];
     const internal = {
         stack: new internal_js_1.StackedStates(),
         mapping: new Map(),
@@ -330,6 +331,27 @@ function transformProgram(path, filename, opts) {
             used.add("earlyInspector");
             return t.identifier(ids["earlyInspector"]);
         },
+        reportError(message, node, e) {
+            const pos = node.loc;
+            /* istanbul ignore else */
+            if (pos) {
+                reports.push({
+                    message: message,
+                    from: [pos.start.line, pos.start.column],
+                    to: [pos.end.line, pos.end.column],
+                    class: e ? "error" : "warning",
+                });
+            }
+            if (e) {
+                if (opts.throwAtFirstError) {
+                    throw e;
+                }
+                console.error(e);
+            }
+            else {
+                console.warn(message);
+            }
+        },
     };
     function getCtx() {
         if (internal.isComposing)
@@ -369,8 +391,13 @@ function transformProgram(path, filename, opts) {
         }
     }
     updateImports(path, internal, ids, used);
-    if (internal.firstError)
-        throw internal.firstError;
+    opts.reporter?.({
+        filePath: filename,
+        reports: reports,
+    });
+    if (reports.some(item => item.class === "error")) {
+        throw new Error("Compilation failed");
+    }
     if (opts.devLayer) {
         path.node.body.unshift(t.variableDeclaration("const", [t.variableDeclarator(filePathId, t.stringLiteral(internal.steelFilePath))]));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vasille",
-  "version": "5.1.1",
+  "version": "5.1.3",
   "description": "Convert Vasille Meta Language code to pure JavaScript",
   "main": "lib/index.js",
   "type": "commonjs",
@@ -8,11 +8,13 @@
     "import": "./lib/index.js",
     "browser": "./lib/index.js",
     "node": "./lib/index.js",
-    "require": "./lib/index.js"
+    "require": "./lib/index.js",
+    "types": "./types/index.d.ts"
   },
   "scripts": {
     "prepack": "cp -f ../README.md ./README.md",
     "prettier": "prettier src test/**/*.ts* test/*.ts --write",
+    "prebuild": "rm -rf lib types",
     "build": "tsc --build tsconfig-build.json",
     "tsc-tests": "tsc --build test/tsconfig.json",
     "test": "jest",
@@ -26,7 +28,7 @@
     "babel"
   ],
   "author": "lixcode",
-  "license": "MIT",
+  "license": "LGPL-2.1-only",
   "bugs": {
     "url": "https://github.com/vasille-js/vasille-js/issues"
   },
@@ -39,7 +41,7 @@
     "@types/babel__core": "^7.20.5",
     "@types/jest": "^30.0.0",
     "@types/jsdom": "^21.1.7",
-    "@types/node": "^24.2.1",
+    "@types/node": "^25.6.0",
     "cross-env": "^10.0.0",
     "jest": "^30.0.5",
     "jsdom": "^26.1.0",

package/types/call.d.ts

@@ -0,0 +1,14 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export type FnNames = "compose" | "view" | "component" | "store" | "model" | "screen" | "page" | "modal" | "prompt" | "awaited" | "calculate" | "forward" | "watch" | "ref" | "bind" | "raw" | "arrayModel" | "setModel" | "mapModel" | "beforeMount" | "afterMount" | "beforeDestroy" | "router" | "theme" | "dark" | "mobile" | "tablet" | "laptop" | "prefersDark" | "prefersLight" | "styleSheet" | "share" | "receive" | "impute";
+export declare const composeFunctions: ["compose", "store", "model", "view", "component", "page", "modal", "prompt", "screen"];
+export declare const refFunctions: ["ref"];
+export declare const asyncFunctions: ["awaited"];
+export declare const bindFunctions: ["watch", "calculate", "bind"];
+export declare const modelFunctions: ["arrayModel", "mapModel", "setModel"];
+export declare const composeOnly: ["router", "beforeMount", "afterMount", "beforeDestroy"];
+export declare const styleOnly: ["theme", "dark", "mobile", "tablet", "laptop", "prefersDark", "prefersLight", "styleSheet"];
+export declare const dependencyInjections: ["share", "receive", "impute"];
+export declare const hintFunctions: FnNames[];
+export declare function calls(path: NodePath<types.CallExpression>, names: FnNames[], internal: Internal): boolean;
+export declare function calls(path: NodePath<types.Expression | null | undefined>, names: FnNames[], internal: Internal): path is NodePath<types.CallExpression>;

package/types/communication.d.ts

@@ -0,0 +1,11 @@
+export interface CompilationErrorReport {
+    from: [number, number];
+    to: [number, number];
+    message: string;
+    class: "error" | "warning";
+}
+export interface CompilationErrorReports {
+    filePath: string;
+    reports: CompilationErrorReport[];
+}
+export type CompilationErrorReporter = (reports: CompilationErrorReports) => void;

package/types/css-transformer.d.ts

@@ -0,0 +1,3 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export declare function findStyleInNode(path: NodePath<types.Node | null | undefined>, internal: Internal): boolean;

package/types/expression.d.ts

@@ -0,0 +1,27 @@
+import { NodePath, types } from "@babel/core";
+import { Internal, StackedStates } from "./internal.js";
+export interface Dependency {
+    node: types.Expression;
+    paramName: types.Identifier;
+}
+export interface Search {
+    found: Map<string, Dependency>;
+    external: Internal;
+    self: types.Expression | null;
+    inserted: Set<types.Expression>;
+    stack: StackedStates;
+}
+export declare function nodeIsMeshed(path: NodePath<types.Node | null | undefined>): boolean;
+export declare function idIsIValue(path: NodePath<types.Identifier>): boolean;
+export declare function memberIsIValue(node: types.MemberExpression | types.OptionalMemberExpression): boolean;
+export declare function memberIsIValueInExpr(path: NodePath<types.MemberExpression | types.OptionalMemberExpression>, search: Search): boolean;
+export declare function exprIsSure(path: NodePath<types.Expression | null | undefined>, internal: Internal): boolean | 1;
+export declare function checkNode(path: NodePath<types.Node | null | undefined>, internal: Internal, area: types.Node, name?: string): Search;
+export declare function checkOrIgnoreAllExpressions<T extends types.Node>(nodePaths: NodePath<types.Expression | null | T>[], search: Search): void;
+export declare function checkAllExpressions(nodePaths: NodePath<types.Expression | null>[], search: Search): void;
+export declare function checkAllUnknown(paths: NodePath<types.SpreadElement | types.ArgumentPlaceholder | types.Expression | null>[], internal: Search): void;
+export declare function checkOrIgnoreExpression<T extends types.Node>(path: NodePath<types.Expression | null | undefined | T>, search: Search): void;
+export declare function checkExpression(nodePath: NodePath<types.Expression | null | undefined>, search: Search): void;
+export declare function checkStatements(paths: NodePath<types.Statement>[], search: Search): void;
+export declare function checkStatement(path: NodePath<types.Statement | null | undefined>, search: Search): void;
+export declare function checkFunction(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression | types.FunctionDeclaration | types.ObjectMethod>, search: Search): void;

package/types/index.d.ts

@@ -0,0 +1,19 @@
+import * as Babel from "@babel/core";
+export default function (): Babel.PluginObj<{
+    file: {
+        opts: {
+            filename: string;
+        };
+    };
+    opts: {
+        devLayer: unknown;
+        strictFolders: unknown;
+        replaceWeb: unknown;
+        headTag: unknown;
+        bodyTag: unknown;
+        shadow: unknown;
+        throwAtFirstError: unknown;
+        reporter: unknown;
+    };
+}>;
+export type { CompilationErrorReporter, CompilationErrorReport, CompilationErrorReports } from "./communication";

package/types/internal.d.ts

@@ -0,0 +1,55 @@
+import { NodePath, types } from "@babel/core";
+import { TSTypeElement } from "@babel/types";
+export type VariableState = Record<string, 1>;
+export declare class StackedStates {
+    private maps;
+    private checkingIndex;
+    constructor();
+    push(startChecking?: boolean): void;
+    pop(): void;
+    get(name: string, checkingContextOnly?: boolean): VariableState | undefined;
+    set(name: string, state: VariableState): void;
+}
+export interface Internal {
+    mapping: Map<string, string>;
+    interfaces: Map<string, TSTypeElement[]>;
+    componentsImports: Map<string, string>;
+    stack: StackedStates;
+    global: string;
+    prefix: string;
+    importStatement: NodePath<types.ImportDeclaration> | null;
+    stateOnly: boolean;
+    isComposing?: boolean;
+    isFunctionParsing?: boolean;
+    filename: string;
+    steelFilePath: string;
+    devLayer: boolean;
+    strictFolders: boolean;
+    stylesConnected: boolean;
+    replaceWeb: string;
+    headTag?: boolean;
+    bodyTag?: boolean;
+    shadow?: boolean;
+    reportError(message: string, node: types.Node, e?: Error): void;
+    ref(arg: types.Expression | null, area: types.Node, name: string | undefined): types.Expression;
+    expr(func: types.Expression, values: types.Expression[], codes: string[], area: types.Node, name: string | undefined): types.Expression;
+    setModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    mapModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    arrayModel(arg: types.Expression | types.SpreadElement | types.ArgumentPlaceholder | null, usage: types.Node, name: string | undefined): types.Expression;
+    ensure(arg: types.MemberExpression | types.OptionalMemberExpression, area: types.Node): types.Expression;
+    match(name: types.Expression, arg: types.Expression, area: types.Node): types.CallExpression;
+    set(obj: types.Expression, field: types.Expression, value: types.Expression, area: types.Node): types.CallExpression;
+    Switch(arg: types.ObjectExpression): types.CallExpression;
+    safe(arg: types.FunctionExpression | types.ArrowFunctionExpression): types.CallExpression;
+    updateIValue(assign: types.AssignmentExpression, left: types.Expression, right: types.Expression): types.Expression;
+    wrapFunctionBody(fn: types.FunctionDeclaration | types.ObjectMethod | types.ClassMethod | types.ClassPrivateMethod): void;
+    setupPosition(target: types.Expression, area: types.Node): types.Expression;
+    wrapFunction(fn: types.FunctionExpression | types.ArrowFunctionExpression): types.Node;
+    shareStateById(value: types.Expression, name: string): types.Expression;
+    positionedText(text: types.Expression, area: types.Node): types.Expression;
+    earlyInspector(): types.Expression;
+}
+export declare const ctx: types.Identifier;
+export declare const runner: types.MemberExpression;
+export declare const inspector: types.MemberExpression;
+export declare const V: types.Identifier;

package/types/jsx-detect.d.ts

@@ -0,0 +1,3 @@
+import { types } from "@babel/core";
+export declare function exprHasJsx(node: types.Expression): boolean;
+export declare function bodyHasJsx(node: types.BlockStatement | types.Expression): boolean;

package/types/jsx.d.ts

@@ -0,0 +1,11 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+export interface ConditionCollection {
+    cases: {
+        condition: types.Expression;
+        slot: types.FunctionExpression | types.ArrowFunctionExpression;
+    }[] | null;
+}
+export declare function transformJsx(path: NodePath<types.JSXElement | types.JSXFragment>, conditions: ConditionCollection, internal: Internal): types.Statement[];
+export declare function transformJsxArray(paths: NodePath<types.JSXText | types.JSXExpressionContainer | types.JSXSpreadChild | types.JSXElement | types.JSXFragment>[], internal: Internal): types.Statement[];
+export declare function processConditions(conditions: ConditionCollection, internal: Internal, _default?: types.FunctionExpression | types.ArrowFunctionExpression): types.Statement[];

package/types/lib.d.ts

@@ -0,0 +1,30 @@
+import { NodePath, types } from "@babel/core";
+import { Identifier } from "@babel/types";
+import { Dependency } from "./expression.js";
+import { Internal } from "./internal.js";
+export declare enum Errors {
+    IncorrectArguments = 1,
+    IncompatibleContext = 2,
+    TokenNotSupported = 3,
+    Dilemma = 4,
+    ParserError = 5,
+    RulesOfVasille = 6
+}
+export declare function err(e: Errors, node: NodePath<unknown>, content: string, internal: Internal, ret?: undefined): void;
+export declare function err<T>(e: Errors, node: NodePath<unknown>, content: string, internal: Internal, ret: T): T;
+export declare function processCalculateCall(path: NodePath<types.CallExpression>, internal: Internal, area: types.Node, name: string | undefined): boolean;
+export declare function parseCalculateCall(path: NodePath<types.Expression | null | undefined>, internal: Internal, area: types.Node, name: string | undefined): boolean;
+export declare function bindCall(path: NodePath<types.Expression | null | undefined>, expr: types.Expression | null | undefined, data: Map<string, Dependency>, internal: Internal, name?: string): boolean;
+export declare function exprCall(path: NodePath<types.Expression | null | undefined>, expr: types.Expression | null | undefined, internal: Internal, opts: {
+    name?: string;
+    strong?: boolean;
+}, area: types.Node): boolean;
+export declare function ref(expr: types.Node | null | undefined, internal: Internal, area: types.Node, name?: string): types.Expression;
+export declare function arrayModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function setModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function mapModel(args: types.CallExpression["arguments"], usage: types.Node, internal: Internal, name?: string): types.Expression;
+export declare function processModelCall(path: NodePath<types.CallExpression | types.NewExpression>, usage: types.Node, type: "Map" | "Set" | "Array", isConst: boolean, internal: Internal, name?: string): void;
+export declare function checkReactiveName(idPath: NodePath<unknown>, internal: Internal): void;
+export declare function checkNonReactiveName(idPath: NodePath<Identifier>, internal: Internal): void;
+export declare function toKebabCase(name: string): string;
+export declare function nameIsRestricted(name: string): boolean;

package/types/mesh.d.ts

@@ -0,0 +1,19 @@
+import { NodePath, types } from "@babel/core";
+import { Internal, VariableState } from "./internal.js";
+export declare function meshOrIgnoreAllExpressions<T extends types.Node>(nodePaths: NodePath<types.Expression | null | T>[], internal: Internal): void;
+export declare function meshAllExpressions(nodePaths: NodePath<types.Expression | null>[], internal: Internal): void;
+export declare function meshComposeCall(name: string | null | undefined, path: NodePath<types.Node | null | undefined>, internal: Internal, isExported?: boolean): void;
+export declare function meshAllUnknown(paths: NodePath<types.SpreadElement | types.ArgumentPlaceholder | types.Expression | null>[], internal: Internal): void;
+export declare function meshLValue(path: NodePath<types.LVal | types.Expression | types.VoidPattern | null | undefined>, internal: Internal): void;
+export declare function meshOrIgnoreExpression<T extends types.Node>(path: NodePath<types.Expression | types.VoidPattern | null | undefined | T>, internal: Internal): void;
+export declare function meshExpression(nodePath: NodePath<types.Expression | null | undefined>, internal: Internal): void;
+export declare function meshStatements(paths: NodePath<types.Statement>[], internal: Internal): void;
+export declare function ignoreParams(path: NodePath<types.LVal | types.VoidPattern | null | undefined>, internal: Internal, allowReactiveId: false | ("id" | "array")[]): void;
+export declare function reactiveArrayPattern(path: NodePath<types.LVal | types.OptionalMemberExpression | types.VoidPattern>, internal: Internal): void;
+export declare function processObjectExpression(path: NodePath<types.ObjectExpression>, internal: Internal): VariableState;
+export declare function meshStatement(path: NodePath<types.Statement | null | undefined>, internal: Internal): void;
+export declare function meshFunction(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression | types.FunctionDeclaration | types.ObjectMethod | types.ClassMethod | types.ClassPrivateMethod>, internal: Internal): void;
+export declare function composeExpression(path: NodePath<types.Expression | null | undefined>, internal: Internal): void;
+export declare function composeStatements(paths: NodePath<types.Statement | null | undefined>[], internal: Internal): void;
+export declare function composeStatement(path: NodePath<types.Statement | null | undefined>, internal: Internal): void;
+export declare function compose(path: NodePath<types.ArrowFunctionExpression | types.FunctionExpression>, internal: Internal, isInternalSlot: boolean, isSlot: boolean): void;

package/types/operators.d.ts

@@ -0,0 +1,25 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal";
+declare const assigmentToBinaryMap: {
+    readonly "+=": "+";
+    readonly "-=": "-";
+    readonly "/=": "/";
+    readonly "%=": "%";
+    readonly "*=": "*";
+    readonly "**=": "**";
+    readonly "&=": "&";
+    readonly "|=": "|";
+    readonly ">>=": ">>";
+    readonly ">>>=": ">>>";
+    readonly "<<=": "<<";
+    readonly "^=": "^";
+};
+declare const assigmentToLogicalMap: {
+    readonly "&&=": "&&";
+    readonly "||=": "||";
+    readonly "??=": "??";
+};
+export declare function assignmentToBinaryOperator(operator: string): (typeof assigmentToBinaryMap)[keyof typeof assigmentToBinaryMap] | undefined;
+export declare function assignmentToLogicalOperator(operator: string): (typeof assigmentToLogicalMap)[keyof typeof assigmentToLogicalMap] | undefined;
+export declare function meshAssigment(path: NodePath<types.AssignmentExpression>, left: NodePath<types.MemberExpression>, right: NodePath<types.Expression>, property: types.PrivateName | types.Expression, internal: Internal): void;
+export {};

package/types/order-check.d.ts

@@ -0,0 +1,3 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal";
+export declare function checkOrder(paths: NodePath<types.Statement | null | undefined>[], internal: Internal): void;

package/types/process-types.d.ts

@@ -0,0 +1,15 @@
+import { types } from "@babel/core";
+import { TSTypeElement } from "@babel/types";
+import { Internal } from "./internal";
+declare const any = 0;
+declare const string = 1;
+declare const number = 2;
+declare const boolean = 3;
+type PropType = typeof string | typeof number | typeof boolean | typeof any;
+export declare function registerInterface(name: string, members: TSTypeElement[], internal: Internal): void;
+export declare function processUnion(type: types.TSUnionType): PropType;
+export declare function processType(type: types.TSType): PropType;
+export declare function processSignatures(members: TSTypeElement[]): types.ObjectExpression;
+export declare function processTypeLiteral(literal: types.TSTypeLiteral): types.ObjectExpression;
+export declare function processReference(id: types.TSTypeReference, internal: Internal): types.ObjectExpression | undefined;
+export {};

package/types/router.d.ts

@@ -0,0 +1,2 @@
+import { NodePath } from "@babel/core";
+export declare function routerReplace(path: NodePath<unknown>): void;

package/types/transformer.d.ts

@@ -0,0 +1,16 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal.js";
+import { CompilationErrorReporter } from "./communication";
+export interface TransformerOptions {
+    devLayer: boolean;
+    strictFolders: boolean;
+    replaceWeb: string | undefined;
+    headTag: boolean;
+    bodyTag: boolean;
+    shadow: boolean;
+    reporter: CompilationErrorReporter | undefined;
+    throwAtFirstError: boolean;
+}
+export declare function nodeToStaticPosition(node: types.Node): types.ArrayExpression;
+export declare function transformProgram(path: NodePath<types.Program>, filename: string, opts: TransformerOptions): void;
+export declare function inspectorOf(internal: Internal): types.Expression;

package/types/utils.d.ts

@@ -0,0 +1,2 @@
+import { types } from "@babel/core";
+export declare function stringify(node: types.Expression | types.PrivateName): string;