babel-plugin-vasille 0.99.5 → 3.1.1

package/README.md

@@ -103,12 +103,11 @@ All of these are supported:
 * [x] Develop the `Vasille JSX` library.
 * [x] `100%` Test Coverage for the JSX library.
 * [x] Develop the `Vasille Babel Plugin`.
-* [ ] `100%` Test Coverage fot babel plugin.
+* [x] `100%` Test Coverage fot babel plugin.
 * [x] Add CSS support (define styles in components).
-* [ ] Add custom `input` components with 2-way value binding.
 * [ ] Add router.
-* [ ] Develop dev-tools extension for debugging.
-* [ ] Develop a lot of libraries for the framework.
+* [ ] Add SSR (server side rendering).
+* [ ] Develop tools extension for debugging.
 
 ## Questions
 

package/lib/call.js

@@ -1,11 +1,12 @@
 import * as t from "@babel/types";
-import { ctx } from "./internal";
+import { ctx } from "./internal.js";
 export const composeOnly = [
     "forward",
     "watch",
     "ref",
     "bind",
     "value",
+    "awaited",
     "arrayModel",
     "mapModel",
     "setModel",
@@ -19,9 +20,9 @@ export const styleOnly = [
     "laptop",
     "prefersDark",
     "prefersLight",
-    "webStyleSheet",
+    "styleSheet",
 ];
-export const requiresContext = ["awaited", "forward"];
+export const requiresContext = ["awaited"];
 const requiresContextSet = new Set(requiresContext);
 export function calls(node, names, internal) {
     const set = new Set(names);
@@ -33,32 +34,33 @@ export function calls(node, names, internal) {
                 if (requiresContextSet.has(callee.name) && t.isCallExpression(node)) {
                     node.arguments.unshift(ctx);
                 }
+                if (mapped === "state") {
+                    internal.stateOnly = true;
+                }
+                if (mapped === "compose" || mapped === "extend") {
+                    internal.stateOnly = false;
+                }
                 return mapped;
             }
             return false;
         }
         const global = internal.stack.get(internal.global) === undefined;
-        const cssGlobal = internal.stack.get(internal.cssGlobal) === undefined;
-        if (!global && !cssGlobal) {
-            return;
+        let propName = null;
+        if (t.isMemberExpression(callee)) {
+            if (t.isIdentifier(callee.property)) {
+                propName = callee.property.name;
+            }
+            else if (t.isStringLiteral(callee.property)) {
+                propName = callee.property.value;
+            }
         }
-        const propName = t.isMemberExpression(callee)
-            ? t.isIdentifier(callee.property)
-                ? callee.property.name
-                : t.isStringLiteral(callee.property)
-                    ? callee.property.value
-                    : null
-            : null;
         if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && propName) {
             if (global && callee.object.name === internal.global && set.has(propName)) {
-                if (requiresContextSet.has(callee.object.name) && t.isCallExpression(node)) {
+                if (requiresContextSet.has(propName) && t.isCallExpression(node)) {
                     node.arguments.unshift(ctx);
                 }
                 return callee.object.name;
             }
-            if (cssGlobal && callee.object.name === internal.cssGlobal && set.has(propName)) {
-                return callee.object.name;
-            }
         }
     }
     return false;

package/lib/css-transformer.js

@@ -1,11 +1,11 @@
 import * as t from "@babel/types";
-import { calls } from "./call";
+import { calls } from "./call.js";
 function tryProcessProp(path, pseudo, media, internal) {
     if (t.isObjectMethod(path.node)) {
-        throw path.buildCodeFrameError("Object methods not supported here");
+        throw path.buildCodeFrameError("Vasille: Object methods not supported here");
     }
     if (t.isSpreadElement(path.node)) {
-        throw path.buildCodeFrameError("Spread element not suppored here");
+        throw path.buildCodeFrameError("Vasille: Spread element not supported here");
     }
     return processProp(path, pseudo, media, internal);
 }
@@ -14,7 +14,7 @@ function processValue(name, path, pseudo, theme, media, mediaDefault, allowFallb
     if (calls(path.node, ["theme"], internal)) {
         const call = path.node;
         if (theme) {
-            throw path.buildCodeFrameError("Vasille: Theme seem the be defined twince");
+            throw path.buildCodeFrameError("Vasille: The theme seems the be defined twice");
         }
         if (t.isStringLiteral(call.arguments[0])) {
             return processValue(name, path.get("arguments")[1], pseudo, `body.${call.arguments[0].value}`, media, mediaDefault, false, internal);
@@ -27,7 +27,7 @@ function processValue(name, path, pseudo, theme, media, mediaDefault, allowFallb
     }
     if (calls(path.node, ["dark"], internal)) {
         if (theme) {
-            throw path.buildCodeFrameError("Vasille: Theme seem the be defined twince");
+            throw path.buildCodeFrameError("Vasille: The theme seem the be defined twice");
         }
         return processValue(name, path.get("arguments")[0], pseudo, `.dark`, media, mediaDefault, false, internal);
     }
@@ -79,32 +79,32 @@ function processValue(name, path, pseudo, theme, media, mediaDefault, allowFallb
                         return processValue(name, path, pseudo, theme, media, mediaDefault, false, internal);
                     }
                     else {
-                        throw path.buildCodeFrameError("Vasille: Exprected expression");
+                        throw path.buildCodeFrameError("Vasille: Expected expression");
                     }
                 })
                     .flat(1),
             ];
         }
         else {
-            throw path.buildCodeFrameError("Vasille: Only numbers arrays are suppored here");
+            throw path.buildCodeFrameError("Vasille: Only numbers arrays are supported here");
         }
     }
     throw path.buildCodeFrameError("Vasille: Failed o parse value, it is not a string, number or array");
 }
 function processProp(path, pseudo, media, internal) {
     let name;
-    if (t.isIdentifier(path.node.key)) {
+    if (t.isIdentifier(path.node.key) && !path.node.computed) {
         name = path.node.key.name;
     }
     else if (t.isStringLiteral(path.node.key)) {
         name = path.node.key.value;
     }
     else {
-        throw path.get("key").buildCodeFrameError("Vasille: Incompaible key, exprect idenifier or string literal");
+        throw path.get("key").buildCodeFrameError("Vasille: Incompatible key, expect identifier or string literal");
     }
     if (name.startsWith("@")) {
         if (media || pseudo) {
-            throw path.get("key").buildCodeFrameError("Vasille: Media queries allowed inly in the root of style");
+            throw path.get("key").buildCodeFrameError("Vasille: Media queries allowed only in the root of style");
         }
         if (t.isObjectExpression(path.node.value)) {
             return path.get("value")
@@ -115,12 +115,12 @@ function processProp(path, pseudo, media, internal) {
                 .flat(1);
         }
         else {
-            throw path.get("value").buildCodeFrameError("Vasille: Exprected object expression");
+            throw path.get("value").buildCodeFrameError("Vasille: Expected object expression");
         }
     }
     if (name.startsWith(":")) {
         if (pseudo) {
-            throw path.get("key").buildCodeFrameError("Recursive pseudo classes are restriced");
+            throw path.get("key").buildCodeFrameError("Vasille: Recursive pseudo classes are restricted");
         }
         if (t.isObjectExpression(path.node.value)) {
             return path.get("value")
@@ -131,31 +131,28 @@ function processProp(path, pseudo, media, internal) {
                 .flat(1);
         }
         else {
-            throw path.get("value").buildCodeFrameError("Vasille: Exprected object expression");
+            throw path.get("value").buildCodeFrameError("Vasille: Expected object expression");
         }
     }
     return processValue(name, path.get("value"), pseudo, "", media, [], true, internal);
 }
 export function findStyleInNode(path, internal) {
-    if (t.isExpressionStatement(path.node)) {
-        return findStyleInNode(path.get("expression"), internal);
-    }
     if (t.isExportNamedDeclaration(path.node)) {
         return findStyleInNode(path.get("declaration"), internal);
     }
     if (t.isVariableDeclaration(path.node) &&
         path.node.declarations.length === 1 &&
-        calls(path.node.declarations[0].init, ["webStyleSheet"], internal)) {
+        calls(path.node.declarations[0].init, ["styleSheet"], internal)) {
         const call = path.node.declarations[0].init;
         const callPath = path
             .get("declarations")[0]
             .get("init");
         const objPath = callPath.get("arguments")[0];
         if (call.arguments.length !== 1) {
-            throw callPath.buildCodeFrameError("Vasille: webStyleSheet function has 1 parameter");
+            throw callPath.buildCodeFrameError("Vasille: styleSheet function has 1 parameter");
         }
         if (!t.isObjectExpression(call.arguments[0])) {
-            throw objPath.buildCodeFrameError("Vasille: expected object expression");
+            throw objPath.buildCodeFrameError("Vasille: Expected object expression");
         }
         for (const path of objPath.get("properties")) {
             if (!t.isObjectProperty(path.node)) {
@@ -163,9 +160,9 @@ export function findStyleInNode(path, internal) {
             }
             const prop = path;
             if (!t.isObjectExpression(prop.node.value)) {
-                throw prop.get("value").buildCodeFrameError("Vasille: Exprected object expression");
+                throw prop.get("value").buildCodeFrameError("Vasille: Expected object expression");
             }
-            if (!(t.isIdentifier(prop.node.key) || t.isStringLiteral(prop.node.key))) {
+            if (!((t.isIdentifier(prop.node.key) && !prop.node.computed) || t.isStringLiteral(prop.node.key))) {
                 throw prop.get("key").buildCodeFrameError("Vasille: Expected identifier of string literal");
             }
             const unsorted = [];

package/lib/expression.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { StackedStates } from "./internal";
+import { calls, composeOnly } from "./call.js";
+import { VariableScope } from "./internal.js";
 export function encodeName(name) {
     return t.identifier(`Vasille_${name}`);
 }
@@ -10,16 +11,17 @@ function addIdentifier(path, search) {
     path.replaceWith(encodeName(path.node.name));
 }
 function stringify(node) {
-    if (t.isIdentifier(node)) {
-        return node.name;
-    }
+    let name = "";
     if (t.isStringLiteral(node)) {
-        return node.value;
+        name = node.value;
     }
     if (t.isPrivateName(node)) {
-        return node.id.name;
+        name = node.id.name;
+    }
+    if (t.isIdentifier(node)) {
+        name = node.name;
     }
-    return "$";
+    return name;
 }
 function extractMemberName(path, search) {
     const names = [];
@@ -30,10 +32,11 @@ function extractMemberName(path, search) {
             throw path.buildCodeFrameError("Vasille: The reactive/observable value is nested");
         }
         it = it.object;
-        names.push();
+        names.push(name);
     }
     names.push(stringify(it));
-    if (t.isIdentifier(it) && search.stack.get(it.name) === 1 /* VariableState.Ignored */) {
+    if (t.isIdentifier(it) &&
+        search.stack.get(it.name, VariableScope.Local) === 1 /* VariableState.Ignored */) {
         throw path.buildCodeFrameError("Vasille: This node cannot be processed, the root of expression is a local variable");
     }
     return names.reverse().join("_");
@@ -53,35 +56,65 @@ function addExternalIValue(path, search) {
     path.replaceWith(encodeName(name));
 }
 function meshIdentifier(path, internal) {
-    const state = internal.stack.get(path.node.name);
-    if (state === 2 /* VariableState.Reactive */ || state === 4 /* VariableState.ReactivePointer */) {
+    if (idIsIValue(path, internal)) {
         path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
     }
 }
+export function idIsIValue(path, internal, scope) {
+    const node = path.node;
+    return (REACTIVE_STATES.includes(internal.stack.get(node.name, scope)) &&
+        (!t.isMemberExpression(path.parent) || path.parent.object === node));
+}
+export function idIsLocal(path, internal) {
+    return internal.stack.get(path.node.name, VariableScope.Local) !== undefined;
+}
+export function memberIsIValue(node, internal, scope) {
+    return ((t.isIdentifier(node.object) &&
+        (internal.stack.get(node.object.name, scope) === 3 /* VariableState.ReactiveObject */ ||
+            (t.isIdentifier(node.property) &&
+                node.property.name.startsWith("$") &&
+                !node.property.name.startsWith("$$") &&
+                node.property.name !== "$") ||
+            (t.isStringLiteral(node.property) &&
+                node.property.value.startsWith("$") &&
+                !node.property.value.startsWith("$$") &&
+                node.property.value !== "$"))) ||
+        (t.isMemberExpression(node.object) &&
+            ((t.isIdentifier(node.object.property) && node.object.property.name.startsWith("$$")) ||
+                (t.isStringLiteral(node.object.property) && node.object.property.value.startsWith("$$")))));
+}
+export function nodeIsReactiveObject(path, internal) {
+    const node = path.node;
+    if (t.isIdentifier(node)) {
+        return internal.stack.get(node.name) === 3 /* VariableState.ReactiveObject */;
+    }
+    if (t.isOptionalMemberExpression(node) || t.isMemberExpression(node)) {
+        return ((t.isIdentifier(node.property) && node.property.name.startsWith("$$")) ||
+            (t.isStringLiteral(node.property) && node.property.value.startsWith("$$")));
+    }
+}
 function meshMember(path, internal) {
-    if (t.isIdentifier(path.node.object) && internal.stack.get(path.node.object.name) === 3 /* VariableState.ReactiveObject */) {
+    if (memberIsIValue(path.node, internal)) {
         path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
     }
 }
 function meshLValue(path, internal) {
-    if (t.isIdentifier(path.node)) {
+    const node = path.node;
+    if (t.isIdentifier(node)) {
         meshIdentifier(path, internal);
     }
-    else if (t.isMemberExpression(path.node) || t.isOptionalMemberExpression(path.node)) {
+    else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         meshMember(path, internal);
     }
-    else {
-        path.traverse({
-            Identifier(path) {
-                meshIdentifier(path, internal);
-            },
-            MemberExpression(path) {
-                meshMember(path, internal);
-            },
-            OptionalMemberExpression(path) {
-                meshMember(path, internal);
-            },
-        });
+    else if (t.isArrayPattern(node)) {
+        for (const item of path.get("elements")) {
+            if (t.isOptionalMemberExpression(item.node) || t.isLVal(item.node)) {
+                meshLValue(item, internal);
+            }
+        }
+    }
+    else if (t.isRestElement(node)) {
+        meshLValue(path.get("argument"), internal);
     }
 }
 export function checkNode(path, internal) {
@@ -89,29 +122,31 @@ export function checkNode(path, internal) {
         external: internal,
         found: new Map(),
         self: null,
-        stack: new StackedStates(),
+        stack: internal.stack,
     };
     if (t.isIdentifier(path.node)) {
-        const state = internal.stack.get(path.node.name);
-        if (state === 2 /* VariableState.Reactive */ || state == 4 /* VariableState.ReactivePointer */) {
+        if (idIsIValue(path, internal)) {
             search.self = path.node;
         }
     }
     if (t.isMemberExpression(path.node)) {
-        if (t.isIdentifier(path.node.object) &&
-            internal.stack.get(path.node.object.name) === 3 /* VariableState.ReactiveObject */) {
+        if (memberIsIValue(path.node, internal)) {
             search.self = path.node;
         }
-        if (t.isIdentifier(path.node.property) && path.node.property.name === "$") {
+        else if (t.isIdentifier(path.node.property) && path.node.property.name === "$") {
             search.self = path.node.object;
         }
     }
     if (search.self) {
         return search;
     }
+    internal.stack.fixLocalIndex();
+    internal.stack.push();
     if (t.isExpression(path.node)) {
         checkExpression(path, search);
     }
+    internal.stack.pop();
+    internal.stack.resetLocalIndex();
     return search;
 }
 export function checkOrIgnoreAllExpressions(nodePaths, search) {
@@ -136,17 +171,15 @@ export function checkAllUnknown(paths, internal) {
         }
     }
 }
-export function chekOrIgnoreExpression(path, search) {
+export function checkOrIgnoreExpression(path, search) {
     if (t.isExpression(path.node)) {
         checkExpression(path, search);
     }
 }
+const REACTIVE_STATES = [2 /* VariableState.Reactive */, 4 /* VariableState.ReactivePointer */];
 export function checkExpression(nodePath, search) {
     const expr = nodePath.node;
-    if (!expr) {
-        return;
-    }
-    switch (expr.type) {
+    switch (expr && expr.type) {
         case "TemplateLiteral": {
             const path = nodePath;
             checkOrIgnoreAllExpressions(path.get("expressions"), search);
@@ -155,11 +188,13 @@ export function checkExpression(nodePath, search) {
         case "TaggedTemplateExpression": {
             const path = nodePath;
             checkExpression(path.get("quasi"), search);
+            path.get("");
             break;
         }
         case "Identifier": {
-            if (search.stack.get(expr.name) !== 1 /* VariableState.Ignored */) {
-                if (search.external.stack.get(expr.name) === 2 /* VariableState.Reactive */) {
+            if (expr && t.isIdentifier(expr)) {
+                if (idIsIValue(nodePath, search.external, VariableScope.Global) &&
+                    !idIsLocal(nodePath, search.external)) {
                     addIdentifier(nodePath, search);
                 }
             }
@@ -170,14 +205,12 @@ export function checkExpression(nodePath, search) {
             checkAllUnknown(path.get("elements"), search);
             break;
         }
-        case "TupleExpression": {
-            const path = nodePath;
-            checkAllUnknown(path.get("elements"), search);
-            break;
-        }
         case "CallExpression": {
             const path = nodePath;
-            chekOrIgnoreExpression(path.get("callee"), search);
+            if (calls(path.node, composeOnly, search.external)) {
+                throw path.buildCodeFrameError("Vasille: Usage of hints is restricted here");
+            }
+            checkOrIgnoreExpression(path.get("callee"), search);
             checkAllUnknown(path.get("arguments"), search);
             break;
         }
@@ -197,19 +230,21 @@ export function checkExpression(nodePath, search) {
         case "OptionalMemberExpression": {
             const path = nodePath;
             const node = path.node;
-            checkExpression(path.get("object"), search);
-            chekOrIgnoreExpression(path.get("property"), search);
-            if (t.isIdentifier(node.object) && search.external.stack.get(node.object.name) === 3 /* VariableState.ReactiveObject */) {
+            if (memberIsIValue(node, search.external, VariableScope.Global)) {
                 addMemberExpr(path, search);
             }
             else if (t.isIdentifier(node.property) && node.property.name === "$") {
                 addExternalIValue(path, search);
             }
+            else {
+                checkExpression(path.get("object"), search);
+                checkOrIgnoreExpression(path.get("property"), search);
+            }
             break;
         }
         case "BinaryExpression": {
             const path = nodePath;
-            chekOrIgnoreExpression(path.get("left"), search);
+            checkOrIgnoreExpression(path.get("left"), search);
             checkExpression(path.get("right"), search);
             break;
         }
@@ -228,7 +263,7 @@ export function checkExpression(nodePath, search) {
         }
         case "NewExpression": {
             const path = nodePath;
-            chekOrIgnoreExpression(path.get("callee"), search);
+            checkOrIgnoreExpression(path.get("callee"), search);
             checkAllUnknown(path.get("arguments"), search);
             break;
         }
@@ -237,11 +272,6 @@ export function checkExpression(nodePath, search) {
             checkAllExpressions(path.get("expressions"), search);
             break;
         }
-        case "ParenthesizedExpression": {
-            const path = nodePath;
-            checkExpression(path.get("expression"), search);
-            break;
-        }
         case "UnaryExpression": {
             const path = nodePath;
             checkExpression(path.get("argument"), search);
@@ -249,7 +279,10 @@ export function checkExpression(nodePath, search) {
         }
         case "UpdateExpression": {
             const path = nodePath;
-            checkExpression(path.get("argument"), search);
+            const arg = path.node.argument;
+            if (t.isLVal(arg)) {
+                meshLValue(path.get("argument"), search.external);
+            }
             break;
         }
         case "YieldExpression": {
@@ -262,27 +295,6 @@ export function checkExpression(nodePath, search) {
             checkExpression(path.get("argument"), search);
             break;
         }
-        case "TypeCastExpression": {
-            const path = nodePath;
-            checkExpression(path.get("expression"), search);
-            break;
-        }
-        case "BindExpression": {
-            const path = nodePath;
-            checkExpression(path.get("callee"), search);
-            checkExpression(path.get("object"), search);
-            break;
-        }
-        case "PipelineTopicExpression": {
-            const path = nodePath;
-            checkExpression(path.get("expression"), search);
-            break;
-        }
-        case "PipelineBareFunction": {
-            const path = nodePath;
-            checkExpression(path.get("callee"), search);
-            break;
-        }
         case "TSInstantiationExpression": {
             const path = nodePath;
             checkExpression(path.get("expression"), search);
@@ -310,12 +322,10 @@ export function checkExpression(nodePath, search) {
                 if (t.isObjectProperty(prop)) {
                     const path = propPath;
                     const valuePath = path.get("value");
-                    if (valuePath instanceof Array) {
-                        checkAllExpressions(valuePath, search);
-                    }
-                    else {
-                        chekOrIgnoreExpression(valuePath, search);
+                    if (path.node.computed) {
+                        checkOrIgnoreExpression(path.get("key"), search);
                     }
+                    checkOrIgnoreExpression(valuePath, search);
                 }
                 else if (t.isObjectMethod(prop)) {
                     checkFunction(propPath, search);
@@ -348,9 +358,6 @@ export function checkStatements(paths, search) {
     }
 }
 function ignoreLocals(val, search) {
-    if (t.isAssignmentPattern(val)) {
-        val = val.left;
-    }
     if (t.isIdentifier(val)) {
         search.stack.set(val.name, 1 /* VariableState.Ignored */);
     }
@@ -362,18 +369,23 @@ function ignoreLocals(val, search) {
             else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
                 search.stack.set(prop.argument.name, 1 /* VariableState.Ignored */);
             }
+            else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value)) {
+                ignoreLocals(prop.value.left, search);
+            }
         }
     }
     else if (t.isArrayPattern(val)) {
         for (const element of val.elements) {
-            if (element) {
+            if (element && !t.isVoidPattern(element)) {
                 ignoreLocals(element, search);
             }
         }
     }
     else if (t.isVariableDeclaration(val)) {
         for (const declarator of val.declarations) {
-            ignoreLocals(declarator.id, search);
+            if (!t.isVoidPattern(declarator.id)) {
+                ignoreLocals(declarator.id, search);
+            }
         }
     }
 }
@@ -472,12 +484,16 @@ export function checkStatement(path, search) {
             checkExpression(path.get("argument"), search);
             break;
         case "TryStatement":
+            const handlerPath = path.get("handler");
             checkStatement(path.get("block"), search);
+            if (handlerPath.node) {
+                checkStatement(handlerPath.get("body"), search);
+            }
+            checkStatement(path.get("finalizer"), search);
             break;
         case "VariableDeclaration": {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
-                const expr = declaration.node.init;
                 ignoreLocals(declaration.node.id, search);
                 checkExpression(declaration.get("init"), search);
             }
@@ -491,22 +507,13 @@ export function checkStatement(path, search) {
             search.stack.pop();
             break;
         }
-        case "WithStatement": {
-            const _path = path;
-            checkExpression(_path.get("object"), search);
-            search.stack.push();
-            checkStatement(_path.get("body"), search);
-            search.stack.pop();
-            break;
-        }
-        case "ExportNamedDeclaration": {
-            checkStatement(path.get("declaration"), search);
-            break;
-        }
     }
 }
 export function checkFunction(path, search) {
     const node = path.node;
+    for (const param of node.params) {
+        ignoreLocals(param, search);
+    }
     if (t.isExpression(node.body)) {
         checkExpression(path.get("body"), search);
     }

package/lib/index.js

@@ -1,4 +1,4 @@
-import { trProgram } from "./transformer";
+import { trProgram } from "./transformer.js";
 export default function () {
     return {
         name: "Vasille",

package/lib/internal.js

@@ -1,17 +1,32 @@
 import * as t from "@babel/types";
+export var VariableScope;
+(function (VariableScope) {
+    VariableScope[VariableScope["Any"] = 0] = "Any";
+    VariableScope[VariableScope["Local"] = 1] = "Local";
+    VariableScope[VariableScope["Global"] = 2] = "Global";
+})(VariableScope || (VariableScope = {}));
 export class StackedStates {
     constructor() {
         this.maps = [];
+        this.localIndex = -1;
         this.push();
     }
+    fixLocalIndex() {
+        this.localIndex = this.maps.length;
+    }
+    resetLocalIndex() {
+        this.localIndex = -1;
+    }
     push() {
         this.maps.push(new Map());
     }
     pop() {
         this.maps.pop();
     }
-    get(name) {
-        for (let i = this.maps.length - 1; i >= 0; i--) {
+    get(name, scope) {
+        for (let i = (this.localIndex === -1 || scope !== VariableScope.Global
+            ? this.maps.length
+            : Math.min(this.maps.length, this.localIndex)) - 1; i >= (this.localIndex === -1 || scope !== VariableScope.Local ? 0 : this.localIndex); i--) {
             if (this.maps[i].has(name)) {
                 return this.maps[i].get(name);
             }