@ibyar/expressions 0.8.2-dev.20221008 → 0.8.4

package/api/class/class.js

@@ -1,42 +1,103 @@
 var Super_1, MetaProperty_1, PrivateIdentifier_1, StaticBlock_1, MethodDefinition_1, PropertyDefinition_1, AccessorProperty_1, ClassBody_1, ClassDeclaration_1, ClassExpression_1;
-import { __decorate as __decorate_1, __metadata } from "tslib";
-import { ClassScope } from '../../scope/scope.js';
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from "tslib";
 import { AbstractExpressionNode } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
 import { Identifier } from '../definition/values.js';
-import { MemberExpression } from '../definition/member.js';
 import { FunctionExpression } from '../definition/function.js';
 import { BlockStatement } from '../statement/control/block.js';
 import { CallExpression } from '../computing/call.js';
 const TEMP_CLASS_NAME = Symbol('TempClassName');
-const SUPER = Symbol('Super');
-const NEW_TARGET = Symbol('NewTarget');
-const IMPORT_META = Symbol('ImportMeta');
-const STACK = Symbol('Stack');
-const GET_PARAMETERS = Symbol('GetParameters');
-const GET_SUPER_PROPERTY = Symbol('GetSuperProperty');
-const CALL_SUPER_Method = Symbol('CallSuperMethod');
-const CONSTRUCTOR = Symbol('Constructor');
-const PRIVATE_SYMBOL = Symbol('Private');
-const INSTANCE_PRIVATE_SYMBOL = Symbol('InstancePrivate');
-const STATIC_INITIALIZATION_BLOCK = Symbol('StaticBlock');
+const PRIVATE_SYMBOL = Symbol('#');
+;
+class ClassInitializer {
+    constructor() {
+        /**
+         * register class public static properties and methods
+         */
+        this.staticInitializer = {};
+        /**
+         * register class private static properties and methods
+         */
+        this.staticPrivateInitializer = {};
+        /**
+         * register static initialization block
+         */
+        this.staticInitializerBlock = [];
+        /**
+         * register super parameter resolver
+         */
+        this.superParameterResolver = (params) => params;
+        /**
+         * register in class property
+         */
+        this.instanceMethod = {};
+        /**
+         * register method in instance private space
+         */
+        this.privateInstanceMethod = {};
+        /**
+         * register property in instance itself
+         */
+        this.instanceInitializer = [];
+    }
+    addStaticInitializer(key, attributes) {
+        Reflect.set(this.staticInitializer, key, attributes);
+    }
+    addStaticPrivateInitializer(key, attributes) {
+        Reflect.set(this.staticPrivateInitializer, key, attributes);
+    }
+    addStaticInitializerBlock(block) {
+        this.staticInitializerBlock.push(block);
+    }
+    setConstructor(cstr) {
+        this.instanceConstructor = cstr;
+    }
+    setParameterResolver(resolver) {
+        this.superParameterResolver = resolver;
+    }
+    addInstanceMethod(key, attributes) {
+        Reflect.set(this.instanceMethod, key, attributes);
+    }
+    addPrivateInstanceMethod(key, attributes) {
+        Reflect.set(this.privateInstanceMethod, key, attributes);
+    }
+    addInstanceInitializer(initializer) {
+        this.instanceInitializer.push(initializer);
+    }
+    initClass(classConstructor) {
+        Object.defineProperties(classConstructor, this.staticInitializer);
+        Object.defineProperties(classConstructor[PRIVATE_SYMBOL], this.staticPrivateInitializer);
+        Object.defineProperties(classConstructor.prototype, this.instanceMethod);
+        this.staticInitializerBlock.forEach(block => block());
+    }
+    getSuperArguments(args) {
+        return this.superParameterResolver(args);
+    }
+    initInstance(instance) {
+        Object.defineProperties(instance[PRIVATE_SYMBOL], this.privateInstanceMethod);
+        this.instanceInitializer.forEach(initializer => {
+            const definition = initializer();
+            const target = definition.isPrivate ? instance[PRIVATE_SYMBOL] : instance;
+            target[definition.key] = definition.value;
+        });
+        this.instanceConstructor?.apply(instance);
+    }
+}
 /**
  * A `super` pseudo-expression.
  */
 let Super = Super_1 = class Super extends AbstractExpressionNode {
-    constructor() {
-        super();
-    }
     static fromJSON(node) {
-        return Super_1.INSTANCE;
+        return new Super_1(node.range, node.loc);
+    }
+    constructor(range, loc) {
+        super(range, loc);
     }
-    shareVariables(scopeList) { }
     set(stack, value) {
         throw new Error('Super.#set() Method not implemented.');
     }
     get(stack, thisContext) {
-        throw new Error('Super.#get() Method not implemented.');
+        return stack.get('super');
     }
     dependency(computed) {
         throw new Error('Super.#dependency() Method not implemented.');
@@ -51,10 +112,9 @@ let Super = Super_1 = class Super extends AbstractExpressionNode {
         return {};
     }
 };
-Super.INSTANCE = new Super_1();
-Super = Super_1 = __decorate_1([
+Super = Super_1 = __decorate([
     Deserializer('Super'),
-    __metadata("design:paramtypes", [])
+    __metadata("design:paramtypes", [Array, Object])
 ], Super);
 export { Super };
 /**
@@ -64,40 +124,40 @@ export { Super };
  *
  * In the future, it will represent other meta properties as well.
  */
-let MetaProperty = MetaProperty_1 = class MetaProperty extends MemberExpression {
-    constructor(meta, property) {
-        super(meta, property, false);
-        this.meta = meta;
-    }
-    static getJsonName(identifier) {
-        return Reflect.get(identifier, 'name');
-    }
+let MetaProperty = MetaProperty_1 = class MetaProperty extends AbstractExpressionNode {
     static fromJSON(node, deserializer) {
-        if (MetaProperty_1.getJsonName(node.meta) === 'new' && MetaProperty_1.getJsonName(node.property) === 'target') {
-            return MetaProperty_1.NewTarget;
-        }
-        else if (MetaProperty_1.getJsonName(node.meta) === 'import' && MetaProperty_1.getJsonName(node.property) === 'meta') {
-            return MetaProperty_1.ImportMeta;
-        }
-        return new MetaProperty_1(deserializer(node.meta), deserializer(node.property));
+        return new MetaProperty_1(deserializer(node.meta), deserializer(node.property), node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.meta);
         visitNode(node.property);
     }
+    constructor(meta, property, range, loc) {
+        super(range, loc);
+        this.meta = meta;
+        this.property = property;
+    }
     getMeta() {
         return this.meta;
     }
-    shareVariables(scopeList) { }
-    get(stack, thisContext) {
-        if (MetaProperty_1.getJsonName(this.meta) === 'new' && MetaProperty_1.getJsonName(this.property) === 'target') {
-            return stack.get(NEW_TARGET);
-        }
-        else if (MetaProperty_1.getJsonName(this.meta) === 'import' && MetaProperty_1.getJsonName(this.property) === 'meta') {
-            const importObject = stack.getModule()?.get('import');
-            return importObject['meta'];
+    getProperty() {
+        return this.property;
+    }
+    get(stack) {
+        const metaRef = this.meta.get(stack);
+        if (metaRef === undefined || metaRef === null) {
+            throw new TypeError(`Cannot read meta property '${this.property.toString()}' of ${metaRef}, reading [${this.toString()}]`);
         }
-        return super.get(stack, thisContext);
+        return this.property.get(stack, metaRef);
+    }
+    set(stack, value) {
+        throw new Error(`MetaProperty#set() has no implementation.`);
+    }
+    dependency(computed) {
+        return [];
+    }
+    dependencyPath(computed) {
+        return [];
     }
     toString() {
         return `${this.meta.toString()}.${this.property.toString()}`;
@@ -109,11 +169,9 @@ let MetaProperty = MetaProperty_1 = class MetaProperty extends MemberExpression
         };
     }
 };
-MetaProperty.NewTarget = new MetaProperty_1(new Identifier('new'), new Identifier('target'));
-MetaProperty.ImportMeta = new MetaProperty_1(new Identifier('import'), new Identifier('meta'));
-MetaProperty = MetaProperty_1 = __decorate_1([
+MetaProperty = MetaProperty_1 = __decorate([
     Deserializer('MetaProperty'),
-    __metadata("design:paramtypes", [Identifier, Identifier])
+    __metadata("design:paramtypes", [Identifier, Identifier, Array, Object])
 ], MetaProperty);
 export { MetaProperty };
 /**
@@ -121,16 +179,20 @@ export { MetaProperty };
  */
 let PrivateIdentifier = PrivateIdentifier_1 = class PrivateIdentifier extends Identifier {
     static fromJSON(node) {
-        return new PrivateIdentifier_1(node.name);
+        return new PrivateIdentifier_1(node.name, node.range, node.loc);
     }
-    get(stack) {
-        return stack.get(this.toString());
+    get(stack, thisContext) {
+        return thisContext[PRIVATE_SYMBOL][this.name];
+    }
+    set(stack, value) {
+        const thisContext = stack.lastScope().getContext();
+        return thisContext[PRIVATE_SYMBOL][this.name] = value;
     }
     toString() {
         return `#${this.name}`;
     }
 };
-PrivateIdentifier = PrivateIdentifier_1 = __decorate_1([
+PrivateIdentifier = PrivateIdentifier_1 = __decorate([
     Deserializer('PrivateIdentifier')
 ], PrivateIdentifier);
 export { PrivateIdentifier };
@@ -139,23 +201,10 @@ export { PrivateIdentifier };
  */
 let StaticBlock = StaticBlock_1 = class StaticBlock extends BlockStatement {
     static fromJSON(node, deserializer) {
-        return new StaticBlock_1(deserializer(node.body));
-    }
-    constructor(body) {
-        super(body);
-    }
-    get(stack, classConstructor) {
-        const constructor = classConstructor;
-        constructor[STATIC_INITIALIZATION_BLOCK].push(() => {
-            const scope = new ClassScope(constructor);
-            stack.pushScope(scope);
-            try {
-                super.get(stack);
-            }
-            finally {
-                stack.clearTo(scope);
-            }
-        });
+        return new StaticBlock_1(deserializer(node.body), node.range, node.loc);
+    }
+    get(stack, classInitializer) {
+        classInitializer?.addStaticInitializerBlock(super.get(stack));
     }
     toString() {
         return `static ${super.toString()}`;
@@ -166,14 +215,13 @@ let StaticBlock = StaticBlock_1 = class StaticBlock extends BlockStatement {
         };
     }
 };
-StaticBlock = StaticBlock_1 = __decorate_1([
-    Deserializer('StaticBlock'),
-    __metadata("design:paramtypes", [Array])
+StaticBlock = StaticBlock_1 = __decorate([
+    Deserializer('StaticBlock')
 ], StaticBlock);
 export { StaticBlock };
 export class AbstractDefinition extends AbstractExpressionNode {
-    constructor(key, decorators, computed, isStatic, value) {
-        super();
+    constructor(key, decorators, computed, isStatic, value, range, loc) {
+        super(range, loc);
         this.key = key;
         this.decorators = decorators;
         this.computed = computed;
@@ -192,10 +240,12 @@ export class AbstractDefinition extends AbstractExpressionNode {
     isStatic() {
         return this.static;
     }
+    isPrivate() {
+        return this.key instanceof PrivateIdentifier;
+    }
     getDecorators() {
         return this.decorators;
     }
-    shareVariables(scopeList) { }
     set(stack, value) {
         throw new Error('AbstractDefinition.#set() Method not implemented.');
     }
@@ -205,101 +255,106 @@ export class AbstractDefinition extends AbstractExpressionNode {
     dependencyPath(computed) {
         return [];
     }
-    getTarget(classConstructor) {
-        return this.static
-            ? (this.key instanceof PrivateIdentifier ? classConstructor[PRIVATE_SYMBOL] : classConstructor)
-            : (this.key instanceof PrivateIdentifier ? classConstructor[INSTANCE_PRIVATE_SYMBOL] : classConstructor.prototype);
-    }
     getKeyName(stack) {
-        switch (true) {
-            case this.computed:
-                return this.key.get(stack);
-            case this.key instanceof Identifier:
-            case this.key instanceof PrivateIdentifier:
-                return this.key.getName();
-            default: return this.key.toString();
+        if (this.computed) {
+            // private properties can't be computed
+            return this.key.get(stack);
+        }
+        if (this.key instanceof Identifier) {
+            return this.key.getName();
         }
+        return this.key.toString();
     }
 }
 /**
  * - When key is a PrivateIdentifier, computed must be false and kind can not be "constructor".
  */
 let MethodDefinition = MethodDefinition_1 = class MethodDefinition extends AbstractDefinition {
-    constructor(kind, key, value, decorators, computed, isStatic) {
-        super(key, decorators, computed, isStatic, value);
-        this.kind = kind;
-    }
     static fromJSON(node, deserializer) {
-        return new MethodDefinition_1(node.kind, deserializer(node.key), deserializer(node.value), node.decorators.map(deserializer), node.computed, node.static);
+        return new MethodDefinition_1(node.kind, deserializer(node.key), deserializer(node.value), node.decorators.map(deserializer), node.computed, node.static, node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.key);
         visitNode(node.value);
         node.decorators.forEach(visitNode);
     }
+    constructor(kind, key, value, decorators, computed, isStatic, range, loc) {
+        super(key, decorators, computed, isStatic, value, range, loc);
+        this.kind = kind;
+    }
     getKind() {
         return this.kind;
     }
     getValue() {
         return this.value;
     }
-    get(stack, classConstructor) {
+    get(stack, initializer) {
         if (this.kind === 'constructor') {
-            this.initConstructor(stack, classConstructor);
+            this.initConstructor(stack, initializer);
             return;
         }
-        const target = this.getTarget(classConstructor);
         const name = this.getKeyName(stack);
         const value = this.value?.get(stack);
+        const attributes = this.getPropertyAttributes(value);
+        if (this.isStatic() && this.isPrivate()) {
+            initializer.addStaticPrivateInitializer(name, attributes);
+        }
+        else if (this.isStatic()) {
+            initializer.addStaticInitializer(name, attributes);
+        }
+        else if (this.isPrivate()) {
+            initializer.addPrivateInstanceMethod(name, attributes);
+        }
+        else {
+            initializer.addInstanceMethod(name, attributes);
+        }
+    }
+    getPropertyAttributes(value) {
         switch (this.kind) {
-            case 'method':
-                target[name] = value;
-                break;
-            case 'set':
-                Object.defineProperty(target, name, {
-                    configurable: true,
-                    enumerable: false,
-                    set: value,
-                });
-                break;
-            case 'get':
-                Object.defineProperty(target, name, {
-                    configurable: true,
-                    enumerable: false,
-                    get: value,
-                });
-                break;
+            case 'set': return {
+                writable: true,
+                configurable: true,
+                enumerable: false,
+                set: value,
+            };
+            case 'get': return {
+                writable: true,
+                configurable: true,
+                enumerable: false,
+                get: value,
+            };
             default:
-                break;
+            case 'method': return {
+                writable: true,
+                configurable: true,
+                enumerable: false,
+                value: value
+            };
         }
-        const decorators = this.decorators.map(decorator => decorator.get(stack));
-        decorators.length && __decorate(decorators, target, name, null);
     }
-    initConstructor(stack, classConstructor) {
+    initConstructor(stack, initializer) {
         const body = this.value.getBody().getBody();
         let superIndex = body
-            .findIndex(call => call instanceof CallExpression && Super.INSTANCE === call.getCallee());
-        if (superIndex === -1) {
-            superIndex = body.length;
-        }
-        const superCall = body[superIndex];
-        const blockBeforeSuper = new BlockStatement(body.slice(0, superIndex));
+            .findIndex(call => call instanceof CallExpression && call.getCallee() instanceof Super);
         const blockAfterSuper = new BlockStatement(body.slice(superIndex + 1));
-        if (superCall) {
-            classConstructor[GET_PARAMETERS] = function (params) {
+        initializer.setConstructor(function (params) {
+            const scope = stack.pushBlockScope();
+            blockAfterSuper.get(stack);
+            stack.clearTo(scope);
+        });
+        if (superIndex >= 0) {
+            const blockBeforeSuper = new BlockStatement(body.slice(0, superIndex));
+            const superCall = body[superIndex];
+            const cstrExpr = this;
+            initializer.setParameterResolver(function (params) {
                 const scope = stack.pushBlockScope();
-                this.value.setParameter(stack, params);
+                cstrExpr.value.defineFunctionArguments(stack, params);
                 blockBeforeSuper.get(stack);
                 const parameters = superCall.getCallParameters(stack);
                 stack.clearTo(scope);
                 return parameters;
-            };
+            });
         }
-        classConstructor[CONSTRUCTOR] = function (params) {
-            const scope = this[STACK].pushBlockScope();
-            blockAfterSuper.get(this[STACK]);
-            stack.clearTo(scope);
-        };
     }
     toString() {
         let str = this.decorators.map(decorator => decorator.toString()).join(' ');
@@ -349,9 +404,9 @@ let MethodDefinition = MethodDefinition_1 = class MethodDefinition extends Abstr
         };
     }
 };
-MethodDefinition = MethodDefinition_1 = __decorate_1([
+MethodDefinition = MethodDefinition_1 = __decorate([
     Deserializer('MethodDefinition'),
-    __metadata("design:paramtypes", [String, Object, FunctionExpression, Array, Boolean, Boolean])
+    __metadata("design:paramtypes", [String, Object, FunctionExpression, Array, Boolean, Boolean, Array, Object])
 ], MethodDefinition);
 export { MethodDefinition };
 /**
@@ -359,22 +414,29 @@ export { MethodDefinition };
  */
 let PropertyDefinition = PropertyDefinition_1 = class PropertyDefinition extends AbstractDefinition {
     static fromJSON(node, deserializer) {
-        return new PropertyDefinition_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value && deserializer(node.value));
+        return new PropertyDefinition_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value && deserializer(node.value), node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.key);
         node.value && visitNode(node.value);
     }
-    constructor(key, decorators, computed, isStatic, value) {
-        super(key, decorators, computed, isStatic, value);
+    constructor(key, decorators, computed, isStatic, value, range, loc) {
+        super(key, decorators, computed, isStatic, value, range, loc);
     }
-    get(stack, classConstructor) {
-        const target = this.getTarget(classConstructor);
+    get(stack, initializer) {
         const name = this.getKeyName(stack);
+        if (!this.isStatic()) {
+            initializer.addInstanceInitializer(() => ({ isPrivate: this.isPrivate(), key: name, value: this.value?.get(stack) }));
+            return;
+        }
         const value = this.value?.get(stack);
-        target[name] = value;
-        const decorators = this.decorators.map(decorator => decorator.get(stack));
-        decorators.length && __decorate(decorators, target, name, null);
+        const attributes = { writable: true, configurable: true, enumerable: true, value };
+        if (this.isPrivate()) {
+            initializer.addStaticPrivateInitializer(name, attributes);
+        }
+        else {
+            initializer.addStaticInitializer(name, attributes);
+        }
     }
     toString() {
         const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
@@ -391,45 +453,45 @@ let PropertyDefinition = PropertyDefinition_1 = class PropertyDefinition extends
         };
     }
 };
-PropertyDefinition = PropertyDefinition_1 = __decorate_1([
+PropertyDefinition = PropertyDefinition_1 = __decorate([
     Deserializer('PropertyDefinition'),
-    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object])
+    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object, Array, Object])
 ], PropertyDefinition);
 export { PropertyDefinition };
 let AccessorProperty = AccessorProperty_1 = class AccessorProperty extends AbstractDefinition {
     static fromJSON(node, deserializer) {
-        return new AccessorProperty_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value ? deserializer(node.value) : void 0);
+        return new AccessorProperty_1(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value ? deserializer(node.value) : void 0, node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.key);
         node.value && visitNode(node.value);
         node.decorators.forEach(visitNode);
     }
-    constructor(key, decorators, computed, isStatic, value) {
-        super(key, decorators, computed, isStatic, value);
+    constructor(key, decorators, computed, isStatic, value, range, loc) {
+        super(key, decorators, computed, isStatic, value, range, loc);
     }
-    get(stack, classConstructor) {
-        const target = this.getTarget(classConstructor);
+    get(stack, initializer) {
         const name = this.getKeyName(stack);
-        const value = this.value?.get(stack);
-        target[name] = value;
-        const ref = this.static ? classConstructor : classConstructor.prototype;
-        Object.defineProperty(ref, name, {
+        const accessorAttributes = {
+            writable: false,
             configurable: true,
             enumerable: false,
-            set: function (setValue) {
-                this[PRIVATE_SYMBOL][name] = setValue;
+            set: function (value) {
+                this[PRIVATE_SYMBOL][name] = value;
             },
-        });
-        Object.defineProperty(ref, name, {
-            configurable: true,
-            enumerable: false,
             get: function () {
                 return this[PRIVATE_SYMBOL][name];
             },
-        });
-        const decorators = this.decorators.map(decorator => decorator.get(stack));
-        decorators.length && __decorate(decorators, ref, name, null);
+        };
+        if (!this.isStatic()) {
+            initializer.addInstanceInitializer(() => ({ isPrivate: true, key: name, value: this.value?.get(stack) }));
+            initializer.addInstanceMethod(name, accessorAttributes);
+            return;
+        }
+        const value = this.value?.get(stack);
+        const valueAttribute = { writable: true, configurable: true, enumerable: true, value };
+        initializer.addStaticInitializer(name, accessorAttributes);
+        initializer.addStaticPrivateInitializer(name, valueAttribute);
     }
     toString() {
         const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
@@ -446,31 +508,30 @@ let AccessorProperty = AccessorProperty_1 = class AccessorProperty extends Abstr
         };
     }
 };
-AccessorProperty = AccessorProperty_1 = __decorate_1([
+AccessorProperty = AccessorProperty_1 = __decorate([
     Deserializer('AccessorProperty'),
-    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object])
+    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object, Array, Object])
 ], AccessorProperty);
 export { AccessorProperty };
 let ClassBody = ClassBody_1 = class ClassBody extends AbstractExpressionNode {
-    constructor(body) {
-        super();
-        this.body = body;
-    }
     static fromJSON(node, deserializer) {
-        return new ClassBody_1(node.body.map(deserializer));
+        return new ClassBody_1(node.body.map(deserializer), node.range, node.loc);
     }
     static visit(node, visitNode) {
         node.body.forEach(visitNode);
     }
+    constructor(body, range, loc) {
+        super(range, loc);
+        this.body = body;
+    }
     getBody() {
         return this.body;
     }
-    shareVariables(scopeList) { }
     set(stack, value) {
         throw new Error('Method not implemented.');
     }
-    get(stack, classConstructor) {
-        this.body.forEach(definition => definition.get(stack, classConstructor));
+    get(stack, initializer) {
+        this.body.forEach(definition => definition.get(stack, initializer));
     }
     dependency(computed) {
         throw new Error('Method not implemented.');
@@ -487,14 +548,14 @@ let ClassBody = ClassBody_1 = class ClassBody extends AbstractExpressionNode {
         };
     }
 };
-ClassBody = ClassBody_1 = __decorate_1([
+ClassBody = ClassBody_1 = __decorate([
     Deserializer('ClassBody'),
-    __metadata("design:paramtypes", [Array])
+    __metadata("design:paramtypes", [Array, Array, Object])
 ], ClassBody);
 export { ClassBody };
 export class Class extends AbstractExpressionNode {
-    constructor(body, decorators, id, superClass) {
-        super();
+    constructor(body, decorators, id, superClass, range, loc) {
+        super(range, loc);
         this.body = body;
         this.decorators = decorators;
         this.id = id;
@@ -512,58 +573,45 @@ export class Class extends AbstractExpressionNode {
     getSuperClass() {
         return this.superClass;
     }
-    shareVariables(scopeList) {
-        this.sharedVariables = scopeList;
-    }
     set(stack) {
         throw new Error(`Class.#set() has no implementation.`);
     }
     get(stack) {
-        const className = this.id?.getName();
-        const parentClass = this.superClass?.get(stack) ?? class {
+        // freeze stack
+        stack = stack.copyStack();
+        const className = this.id?.getName() ?? TEMP_CLASS_NAME;
+        const SuperClass = this.superClass?.get(stack) ?? class {
         };
-        let classConstructor = this.createClass(stack, parentClass, className);
+        const initializer = new ClassInitializer();
+        const ClassConstructor = this.createClass(SuperClass, className, initializer);
         // build class body
-        this.body.get(stack, classConstructor);
-        // apply class decorators
-        const decorators = this.decorators.map(decorator => decorator.get(stack));
-        classConstructor = __decorate(decorators, classConstructor);
-        // run static initialization block
-        classConstructor[STATIC_INITIALIZATION_BLOCK].forEach(block => block());
-        Reflect.deleteProperty(classConstructor, STATIC_INITIALIZATION_BLOCK);
-        return classConstructor;
-    }
-    createClass(stack, parentClass, className = TEMP_CLASS_NAME) {
-        var _a, _b, _c, _d, _e;
-        const ClassDeclaration = (_e = class extends parentClass {
-                constructor(...params) {
-                    const parameters = ClassDeclaration[GET_PARAMETERS](params);
-                    super(...parameters);
-                    this[_d] = {};
-                    this[PRIVATE_SYMBOL] = Object.assign(this[PRIVATE_SYMBOL], ClassDeclaration[INSTANCE_PRIVATE_SYMBOL]);
-                    this[STACK] = stack.copyStack();
-                    const instanceStack = this[STACK];
-                    instanceStack.pushScope(ClassScope.readOnlyScopeForThis(this));
-                    instanceStack.declareVariable(NEW_TARGET, new.target);
-                    instanceStack.declareVariable(PRIVATE_SYMBOL, this[PRIVATE_SYMBOL]);
-                    instanceStack.declareVariable(CALL_SUPER_Method, (name) => super[name]());
-                    instanceStack.declareVariable(GET_SUPER_PROPERTY, (name) => super[name]);
-                    instanceStack.pushReactiveScope();
-                    // init fields and methods values
-                    ClassDeclaration[CONSTRUCTOR]();
-                }
-                static [GET_PARAMETERS](args) {
-                    return args;
-                }
-                static [(_a = STATIC_INITIALIZATION_BLOCK, _b = PRIVATE_SYMBOL, _c = INSTANCE_PRIVATE_SYMBOL, CONSTRUCTOR)]() { }
-            },
-            _d = PRIVATE_SYMBOL,
-            _e[_a] = [],
-            _e[_b] = {},
-            _e[_c] = {},
-            _e);
-        Reflect.set(ClassDeclaration, 'name', className);
-        return ClassDeclaration;
+        stack.pushBlockScopeFor({
+            'this': ClassConstructor,
+            'super': SuperClass,
+        });
+        this.body.get(stack, initializer);
+        initializer.initClass(ClassConstructor);
+        return ClassConstructor;
+    }
+    createClass(parentClass, className, initializer) {
+        var _a, _b, _c, _d;
+        const nameClassDeclaration = {
+            [className]: (_d = class extends parentClass {
+                    constructor(...params) {
+                        const parameters = initializer.getSuperArguments(params);
+                        super(...parameters);
+                        this[_c] = {};
+                        initializer.initInstance(this);
+                    }
+                },
+                _a = Symbol.toStringTag,
+                _b = PRIVATE_SYMBOL,
+                _c = PRIVATE_SYMBOL,
+                _d[_a] = className,
+                _d[_b] = {},
+                _d)
+        };
+        return nameClassDeclaration[className];
     }
     dependency(computed) {
         throw new Error('Method not implemented.');
@@ -593,7 +641,7 @@ export class Class extends AbstractExpressionNode {
 }
 let ClassDeclaration = ClassDeclaration_1 = class ClassDeclaration extends Class {
     static fromJSON(node, deserializer) {
-        return new ClassDeclaration_1(deserializer(node.body), deserializer(node.id), node.superClass && deserializer(node.superClass));
+        return new ClassDeclaration_1(deserializer(node.body), node.decorators.map(deserializer), deserializer(node.id), node.superClass && deserializer(node.superClass), node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.body);
@@ -601,8 +649,8 @@ let ClassDeclaration = ClassDeclaration_1 = class ClassDeclaration extends Class
         visitNode(node.id);
         node.superClass && visitNode(node.superClass);
     }
-    constructor(body, decorators, id, superClass) {
-        super(body, decorators, id, superClass);
+    constructor(body, decorators, id, superClass, range, loc) {
+        super(body, decorators, id, superClass, range, loc);
     }
     declareVariable(stack, propertyValue) {
         stack.declareVariable(this.id.getName(), propertyValue);
@@ -616,14 +664,14 @@ let ClassDeclaration = ClassDeclaration_1 = class ClassDeclaration extends Class
         return classConstructor;
     }
 };
-ClassDeclaration = ClassDeclaration_1 = __decorate_1([
+ClassDeclaration = ClassDeclaration_1 = __decorate([
     Deserializer('ClassDeclaration'),
-    __metadata("design:paramtypes", [ClassBody, Array, Identifier, Object])
+    __metadata("design:paramtypes", [ClassBody, Array, Identifier, Object, Array, Object])
 ], ClassDeclaration);
 export { ClassDeclaration };
 let ClassExpression = ClassExpression_1 = class ClassExpression extends Class {
     static fromJSON(node, deserializer) {
-        return new ClassExpression_1(deserializer(node.body), node.superClass && deserializer(node.superClass));
+        return new ClassExpression_1(deserializer(node.body), node.decorators.map(deserializer), node.id && deserializer(node.id), node.superClass && deserializer(node.superClass), node.range, node.loc);
     }
     static visit(node, visitNode) {
         visitNode(node.body);
@@ -631,9 +679,13 @@ let ClassExpression = ClassExpression_1 = class ClassExpression extends Class {
         node.id && visitNode(node.id);
         node.superClass && visitNode(node.superClass);
     }
+    constructor(body, decorators, id, superClass, range, loc) {
+        super(body, decorators, id, superClass, range, loc);
+    }
 };
-ClassExpression = ClassExpression_1 = __decorate_1([
-    Deserializer('ClassExpression')
+ClassExpression = ClassExpression_1 = __decorate([
+    Deserializer('ClassExpression'),
+    __metadata("design:paramtypes", [ClassBody, Array, Identifier, Object, Array, Object])
 ], ClassExpression);
 export { ClassExpression };
 //# sourceMappingURL=class.js.map