@ibyar/expressions 0.8.5 → 1.0.0

package/api/class/class.js

@@ -1,45 +1,45 @@
-var Super_1, MetaProperty_1, PrivateIdentifier_1, StaticBlock_1, MethodDefinition_1, PropertyDefinition_1, AccessorProperty_1, ClassBody_1, ClassDeclaration_1, ClassExpression_1;
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { AbstractExpressionNode } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
 import { Identifier } from '../definition/values.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 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 = [];
-    }
+    /**
+     * register class public static properties and methods
+     */
+    staticInitializer = {};
+    /**
+     * register class private static properties and methods
+     */
+    staticPrivateInitializer = {};
+    /**
+     * register static initialization block
+     */
+    staticInitializerBlock = [];
+    /**
+     * register class constructor function
+     */
+    instanceConstructor;
+    /**
+     * register super parameter resolver
+     */
+    superParameterResolver = (params) => params;
+    /**
+     * register in class property
+     */
+    instanceMethod = {};
+    /**
+     * register method in instance private space
+     */
+    privateInstanceMethod = {};
+    /**
+     * register property in instance itself
+     */
+    instanceInitializer = [];
     addStaticInitializer(key, attributes) {
         Reflect.set(this.staticInitializer, key, attributes);
     }
@@ -86,37 +86,44 @@ class ClassInitializer {
 /**
  * A `super` pseudo-expression.
  */
-let Super = Super_1 = class Super extends AbstractExpressionNode {
-    static fromJSON(node) {
-        return new Super_1(node.range, node.loc);
-    }
-    constructor(range, loc) {
-        super(range, loc);
-    }
-    set(stack, value) {
-        throw new Error('Super.#set() Method not implemented.');
-    }
-    get(stack, thisContext) {
-        return stack.get('super');
-    }
-    dependency(computed) {
-        throw new Error('Super.#dependency() Method not implemented.');
-    }
-    dependencyPath(computed) {
-        throw new Error('Super.#dependencyPath() Method not implemented.');
-    }
-    toString() {
-        return `super`;
-    }
-    toJson() {
-        return {};
-    }
-};
-Super = Super_1 = __decorate([
-    Deserializer('Super'),
-    __metadata("design:paramtypes", [Array, Object])
-], Super);
-export { Super };
+export let Super = (() => {
+    let _classDecorators = [Deserializer('Super')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Super = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor = { value: this }, _classDecorators, { kind: "class", name: this.name }, null, _classExtraInitializers);
+            Super = _classThis = _classDescriptor.value;
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        static fromJSON(node) {
+            return new Super(node.range, node.loc);
+        }
+        constructor(range, loc) {
+            super(range, loc);
+        }
+        set(stack, value) {
+            throw new Error('Super.#set() Method not implemented.');
+        }
+        get(stack, thisContext) {
+            return stack.get('super');
+        }
+        dependency(computed) {
+            throw new Error('Super.#dependency() Method not implemented.');
+        }
+        dependencyPath(computed) {
+            throw new Error('Super.#dependencyPath() Method not implemented.');
+        }
+        toString() {
+            return `super`;
+        }
+        toJson() {
+            return {};
+        }
+    };
+    return Super = _classThis;
+})();
 /**
  * MetaProperty node represents
  * - `new.target` meta property in ES2015.
@@ -124,102 +131,132 @@ export { Super };
  *
  * In the future, it will represent other meta properties as well.
  */
-let MetaProperty = MetaProperty_1 = class MetaProperty extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        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;
-    }
-    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()}]`);
+export let MetaProperty = (() => {
+    let _classDecorators_1 = [Deserializer('MetaProperty')];
+    let _classDescriptor_1;
+    let _classExtraInitializers_1 = [];
+    let _classThis_1;
+    var MetaProperty = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_1 = { value: this }, _classDecorators_1, { kind: "class", name: this.name }, null, _classExtraInitializers_1);
+            MetaProperty = _classThis_1 = _classDescriptor_1.value;
+            __runInitializers(_classThis_1, _classExtraInitializers_1);
         }
-        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()}`;
-    }
-    toJson() {
-        return {
-            meta: this.meta.toJSON(),
-            property: this.property.toJSON(),
-        };
-    }
-};
-MetaProperty = MetaProperty_1 = __decorate([
-    Deserializer('MetaProperty'),
-    __metadata("design:paramtypes", [Identifier, Identifier, Array, Object])
-], MetaProperty);
-export { MetaProperty };
+        meta;
+        property;
+        static fromJSON(node, deserializer) {
+            return new MetaProperty(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;
+        }
+        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 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()}`;
+        }
+        toJson() {
+            return {
+                meta: this.meta.toJSON(),
+                property: this.property.toJSON(),
+            };
+        }
+    };
+    return MetaProperty = _classThis_1;
+})();
 /**
  * A private identifier refers to private class elements. For a private name `#a`, its name is `a`.
  */
-let PrivateIdentifier = PrivateIdentifier_1 = class PrivateIdentifier extends Identifier {
-    static fromJSON(node) {
-        return new PrivateIdentifier_1(node.name, node.range, node.loc);
-    }
-    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([
-    Deserializer('PrivateIdentifier')
-], PrivateIdentifier);
-export { PrivateIdentifier };
+export let PrivateIdentifier = (() => {
+    let _classDecorators_2 = [Deserializer('PrivateIdentifier')];
+    let _classDescriptor_2;
+    let _classExtraInitializers_2 = [];
+    let _classThis_2;
+    var PrivateIdentifier = class extends Identifier {
+        static {
+            __esDecorate(null, _classDescriptor_2 = { value: this }, _classDecorators_2, { kind: "class", name: this.name }, null, _classExtraInitializers_2);
+            PrivateIdentifier = _classThis_2 = _classDescriptor_2.value;
+            __runInitializers(_classThis_2, _classExtraInitializers_2);
+        }
+        static fromJSON(node) {
+            return new PrivateIdentifier(node.name, node.range, node.loc);
+        }
+        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}`;
+        }
+    };
+    return PrivateIdentifier = _classThis_2;
+})();
 /**
  * A static block static { } is a block statement serving as an additional static initializer.
  */
-let StaticBlock = StaticBlock_1 = class StaticBlock extends BlockStatement {
-    static fromJSON(node, deserializer) {
-        return new StaticBlock_1(deserializer(node.body), node.range, node.loc);
-    }
-    get(stack, classInitializer) {
-        classInitializer?.addStaticInitializerBlock(super.get(stack));
-    }
-    toString() {
-        return `static ${super.toString()}`;
-    }
-    toJson() {
-        return {
-            body: this.body.map(node => node.toJSON())
-        };
-    }
-};
-StaticBlock = StaticBlock_1 = __decorate([
-    Deserializer('StaticBlock')
-], StaticBlock);
-export { StaticBlock };
+export let StaticBlock = (() => {
+    let _classDecorators_3 = [Deserializer('StaticBlock')];
+    let _classDescriptor_3;
+    let _classExtraInitializers_3 = [];
+    let _classThis_3;
+    var StaticBlock = class extends BlockStatement {
+        static {
+            __esDecorate(null, _classDescriptor_3 = { value: this }, _classDecorators_3, { kind: "class", name: this.name }, null, _classExtraInitializers_3);
+            StaticBlock = _classThis_3 = _classDescriptor_3.value;
+            __runInitializers(_classThis_3, _classExtraInitializers_3);
+        }
+        static fromJSON(node, deserializer) {
+            return new StaticBlock(deserializer(node.body), node.range, node.loc);
+        }
+        get(stack, classInitializer) {
+            classInitializer?.addStaticInitializerBlock(super.get(stack));
+        }
+        toString() {
+            return `static ${super.toString()}`;
+        }
+        toJson() {
+            return {
+                body: this.body.map(node => node.toJSON())
+            };
+        }
+    };
+    return StaticBlock = _classThis_3;
+})();
 export class AbstractDefinition extends AbstractExpressionNode {
+    key;
+    decorators;
+    computed;
+    value;
+    'static';
     constructor(key, decorators, computed, isStatic, value, range, loc) {
         super(range, loc);
         this.key = key;
@@ -269,291 +306,326 @@ export class AbstractDefinition extends AbstractExpressionNode {
 /**
  * - When key is a PrivateIdentifier, computed must be false and kind can not be "constructor".
  */
-let MethodDefinition = MethodDefinition_1 = class MethodDefinition extends AbstractDefinition {
-    static fromJSON(node, deserializer) {
-        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, initializer) {
-        if (this.kind === 'constructor') {
-            this.initConstructor(stack, initializer);
-            return;
+export let MethodDefinition = (() => {
+    let _classDecorators_4 = [Deserializer('MethodDefinition')];
+    let _classDescriptor_4;
+    let _classExtraInitializers_4 = [];
+    let _classThis_4;
+    var MethodDefinition = class extends AbstractDefinition {
+        static {
+            __esDecorate(null, _classDescriptor_4 = { value: this }, _classDecorators_4, { kind: "class", name: this.name }, null, _classExtraInitializers_4);
+            MethodDefinition = _classThis_4 = _classDescriptor_4.value;
+            __runInitializers(_classThis_4, _classExtraInitializers_4);
         }
-        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);
+        kind;
+        static fromJSON(node, deserializer) {
+            return new MethodDefinition(node.kind, deserializer(node.key), deserializer(node.value), node.decorators.map(deserializer), node.computed, node.static, node.range, node.loc);
         }
-        else if (this.isStatic()) {
-            initializer.addStaticInitializer(name, attributes);
+        static visit(node, visitNode) {
+            visitNode(node.key);
+            visitNode(node.value);
+            node.decorators.forEach(visitNode);
         }
-        else if (this.isPrivate()) {
-            initializer.addPrivateInstanceMethod(name, attributes);
+        afterInstanceConstruct;
+        constructor(kind, key, value, decorators, computed, isStatic, range, loc) {
+            super(key, decorators, computed, isStatic, value, range, loc);
+            this.kind = kind;
         }
-        else {
-            initializer.addInstanceMethod(name, attributes);
+        getKind() {
+            return this.kind;
         }
-    }
-    getPropertyAttributes(value) {
-        switch (this.kind) {
-            case 'set': return {
-                writable: true,
-                configurable: true,
-                enumerable: false,
-                set: value,
-            };
-            case 'get': return {
-                writable: true,
-                configurable: true,
-                enumerable: false,
-                get: value,
-            };
-            default:
-            case 'method': return {
-                writable: true,
-                configurable: true,
-                enumerable: false,
-                value: value
-            };
+        getValue() {
+            return this.value;
         }
-    }
-    initConstructor(stack, initializer) {
-        const body = this.value.getBody().getBody();
-        let superIndex = body
-            .findIndex(call => call instanceof CallExpression && call.getCallee() instanceof Super);
-        const blockAfterSuper = new BlockStatement(body.slice(superIndex + 1));
-        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) {
+        get(stack, initializer) {
+            if (this.kind === 'constructor') {
+                this.initConstructor(stack, initializer);
+                return;
+            }
+            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 'set': return {
+                    writable: true,
+                    configurable: true,
+                    enumerable: false,
+                    set: value,
+                };
+                case 'get': return {
+                    writable: true,
+                    configurable: true,
+                    enumerable: false,
+                    get: value,
+                };
+                default:
+                case 'method': return {
+                    writable: true,
+                    configurable: true,
+                    enumerable: false,
+                    value: value
+                };
+            }
+        }
+        initConstructor(stack, initializer) {
+            const body = this.value.getBody().getBody();
+            let superIndex = body
+                .findIndex(call => call instanceof CallExpression && call.getCallee() instanceof Super);
+            const blockAfterSuper = new BlockStatement(body.slice(superIndex + 1));
+            initializer.setConstructor(function (params) {
                 const scope = stack.pushBlockScope();
-                cstrExpr.value.defineFunctionArguments(stack, params);
-                blockBeforeSuper.get(stack);
-                const parameters = superCall.getCallParameters(stack);
+                blockAfterSuper.get(stack);
                 stack.clearTo(scope);
-                return parameters;
             });
+            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();
+                    cstrExpr.value.defineFunctionArguments(stack, params);
+                    blockBeforeSuper.get(stack);
+                    const parameters = superCall.getCallParameters(stack);
+                    stack.clearTo(scope);
+                    return parameters;
+                });
+            }
         }
-    }
-    toString() {
-        let str = this.decorators.map(decorator => decorator.toString()).join(' ');
-        if (str.length) {
-            str += ' ';
-        }
-        if (this.static) {
-            str += 'static ';
-        }
-        const methodName = this.key.toString();
-        switch (this.kind) {
-            case 'get':
-                str += 'get ' + methodName;
-                break;
-            case 'set':
-                str += 'set ' + methodName;
-                break;
-            case 'method':
-                if (this.value.getAsync() && this.value.getGenerator()) {
-                    str += 'async *';
-                }
-                else if (this.value.getAsync()) {
-                    str += 'async ';
-                }
-                else if (this.value.getGenerator()) {
-                    str += '*';
-                }
-                str += methodName;
-                break;
-            case 'constructor':
-                str += 'constructor';
-                break;
-            default:
-                break;
+        toString() {
+            let str = this.decorators.map(decorator => decorator.toString()).join(' ');
+            if (str.length) {
+                str += ' ';
+            }
+            if (this.static) {
+                str += 'static ';
+            }
+            const methodName = this.key.toString();
+            switch (this.kind) {
+                case 'get':
+                    str += 'get ' + methodName;
+                    break;
+                case 'set':
+                    str += 'set ' + methodName;
+                    break;
+                case 'method':
+                    if (this.value.getAsync() && this.value.getGenerator()) {
+                        str += 'async *';
+                    }
+                    else if (this.value.getAsync()) {
+                        str += 'async ';
+                    }
+                    else if (this.value.getGenerator()) {
+                        str += '*';
+                    }
+                    str += methodName;
+                    break;
+                case 'constructor':
+                    str += 'constructor';
+                    break;
+                default:
+                    break;
+            }
+            str += this.value.paramsAndBodyToString();
+            return str;
         }
-        str += this.value.paramsAndBodyToString();
-        return str;
-    }
-    toJson() {
-        return {
-            kind: this.kind,
-            key: this.key.toJSON(),
-            value: this.value.toJSON(),
-            decorators: this.decorators.map(decorator => decorator.toJSON()),
-            computed: this.computed,
-            static: this.static,
-        };
-    }
-};
-MethodDefinition = MethodDefinition_1 = __decorate([
-    Deserializer('MethodDefinition'),
-    __metadata("design:paramtypes", [String, Object, FunctionExpression, Array, Boolean, Boolean, Array, Object])
-], MethodDefinition);
-export { MethodDefinition };
+        toJson() {
+            return {
+                kind: this.kind,
+                key: this.key.toJSON(),
+                value: this.value.toJSON(),
+                decorators: this.decorators.map(decorator => decorator.toJSON()),
+                computed: this.computed,
+                static: this.static,
+            };
+        }
+    };
+    return MethodDefinition = _classThis_4;
+})();
 /**
  * - When key is a PrivateIdentifier, computed must be false.
  */
-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), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.key);
-        node.value && visitNode(node.value);
-    }
-    constructor(key, decorators, computed, isStatic, value, range, loc) {
-        super(key, decorators, computed, isStatic, value, range, loc);
-    }
-    get(stack, initializer) {
-        const name = this.getKeyName(stack);
-        if (!this.isStatic()) {
-            initializer.addInstanceInitializer(() => ({ isPrivate: this.isPrivate(), key: name, value: this.value?.get(stack) }));
-            return;
+export let PropertyDefinition = (() => {
+    let _classDecorators_5 = [Deserializer('PropertyDefinition')];
+    let _classDescriptor_5;
+    let _classExtraInitializers_5 = [];
+    let _classThis_5;
+    var PropertyDefinition = class extends AbstractDefinition {
+        static {
+            __esDecorate(null, _classDescriptor_5 = { value: this }, _classDecorators_5, { kind: "class", name: this.name }, null, _classExtraInitializers_5);
+            PropertyDefinition = _classThis_5 = _classDescriptor_5.value;
+            __runInitializers(_classThis_5, _classExtraInitializers_5);
         }
-        const value = this.value?.get(stack);
-        const attributes = { writable: true, configurable: true, enumerable: true, value };
-        if (this.isPrivate()) {
-            initializer.addStaticPrivateInitializer(name, attributes);
+        static fromJSON(node, deserializer) {
+            return new PropertyDefinition(deserializer(node.key), node.decorators.map(deserializer), node.computed, node.static, node.value && deserializer(node.value), node.range, node.loc);
         }
-        else {
-            initializer.addStaticInitializer(name, attributes);
+        static visit(node, visitNode) {
+            visitNode(node.key);
+            node.value && visitNode(node.value);
         }
-    }
-    toString() {
-        const decorators = this.decorators.map(decorator => decorator.toString()).join('\n');
-        const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
-        return `${decorators.length ? decorators + ' ' : ''}${this.static ? 'static ' : ''}${name}${this.value ? ` = ${this.value.toString()}` : ''};`;
-    }
-    toJson() {
-        return {
-            key: this.key.toJSON(),
-            value: this.value?.toJSON(),
-            decorators: this.decorators.map(decorator => decorator.toJSON()),
-            computed: this.computed,
-            static: this.static,
-        };
-    }
-};
-PropertyDefinition = PropertyDefinition_1 = __decorate([
-    Deserializer('PropertyDefinition'),
-    __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, 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, range, loc) {
-        super(key, decorators, computed, isStatic, value, range, loc);
-    }
-    get(stack, initializer) {
-        const name = this.getKeyName(stack);
-        const accessorAttributes = {
-            writable: false,
-            configurable: true,
-            enumerable: false,
-            set: function (value) {
-                this[PRIVATE_SYMBOL][name] = value;
-            },
-            get: function () {
-                return this[PRIVATE_SYMBOL][name];
-            },
-        };
-        if (!this.isStatic()) {
-            initializer.addInstanceInitializer(() => ({ isPrivate: true, key: name, value: this.value?.get(stack) }));
-            initializer.addInstanceMethod(name, accessorAttributes);
-            return;
+        constructor(key, decorators, computed, isStatic, value, range, loc) {
+            super(key, decorators, computed, isStatic, value, range, loc);
         }
-        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');
-        const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
-        return `${decorators.length ? decorators.concat(' ') : ''}${this.static ? 'static ' : ''}accessor ${name}${this.value ? ` = ${this.value.toString()}` : ''};`;
-    }
-    toJson() {
-        return {
-            key: this.key.toJSON(),
-            decorators: this.decorators.map(decorator => decorator.toJSON()),
-            computed: this.computed,
-            static: this.static,
-            value: this.value?.toJSON(),
-        };
-    }
-};
-AccessorProperty = AccessorProperty_1 = __decorate([
-    Deserializer('AccessorProperty'),
-    __metadata("design:paramtypes", [Object, Array, Boolean, Boolean, Object, Array, Object])
-], AccessorProperty);
-export { AccessorProperty };
-let ClassBody = ClassBody_1 = class ClassBody extends AbstractExpressionNode {
-    static fromJSON(node, 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;
-    }
-    set(stack, value) {
-        throw new Error('Method not implemented.');
-    }
-    get(stack, initializer) {
-        this.body.forEach(definition => definition.get(stack, initializer));
-    }
-    dependency(computed) {
-        throw new Error('Method not implemented.');
-    }
-    dependencyPath(computed) {
-        throw new Error('Method not implemented.');
-    }
-    toString() {
-        return this.body.map(definition => `\t${definition.toString()}`).join('\n');
-    }
-    toJson() {
-        return {
-            body: this.body.map(method => method.toJSON())
-        };
-    }
-};
-ClassBody = ClassBody_1 = __decorate([
-    Deserializer('ClassBody'),
-    __metadata("design:paramtypes", [Array, Array, Object])
-], ClassBody);
-export { ClassBody };
+        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);
+            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');
+            const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
+            return `${decorators.length ? decorators + ' ' : ''}${this.static ? 'static ' : ''}${name}${this.value ? ` = ${this.value.toString()}` : ''};`;
+        }
+        toJson() {
+            return {
+                key: this.key.toJSON(),
+                value: this.value?.toJSON(),
+                decorators: this.decorators.map(decorator => decorator.toJSON()),
+                computed: this.computed,
+                static: this.static,
+            };
+        }
+    };
+    return PropertyDefinition = _classThis_5;
+})();
+export let AccessorProperty = (() => {
+    let _classDecorators_6 = [Deserializer('AccessorProperty')];
+    let _classDescriptor_6;
+    let _classExtraInitializers_6 = [];
+    let _classThis_6;
+    var AccessorProperty = class extends AbstractDefinition {
+        static {
+            __esDecorate(null, _classDescriptor_6 = { value: this }, _classDecorators_6, { kind: "class", name: this.name }, null, _classExtraInitializers_6);
+            AccessorProperty = _classThis_6 = _classDescriptor_6.value;
+            __runInitializers(_classThis_6, _classExtraInitializers_6);
+        }
+        static fromJSON(node, deserializer) {
+            return new AccessorProperty(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, range, loc) {
+            super(key, decorators, computed, isStatic, value, range, loc);
+        }
+        get(stack, initializer) {
+            const name = this.getKeyName(stack);
+            const accessorAttributes = {
+                writable: false,
+                configurable: true,
+                enumerable: false,
+                set: function (value) {
+                    this[PRIVATE_SYMBOL][name] = value;
+                },
+                get: function () {
+                    return this[PRIVATE_SYMBOL][name];
+                },
+            };
+            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');
+            const name = this.computed ? `[${this.key.toString()}]` : this.key.toString();
+            return `${decorators.length ? decorators.concat(' ') : ''}${this.static ? 'static ' : ''}accessor ${name}${this.value ? ` = ${this.value.toString()}` : ''};`;
+        }
+        toJson() {
+            return {
+                key: this.key.toJSON(),
+                decorators: this.decorators.map(decorator => decorator.toJSON()),
+                computed: this.computed,
+                static: this.static,
+                value: this.value?.toJSON(),
+            };
+        }
+    };
+    return AccessorProperty = _classThis_6;
+})();
+export let ClassBody = (() => {
+    let _classDecorators_7 = [Deserializer('ClassBody')];
+    let _classDescriptor_7;
+    let _classExtraInitializers_7 = [];
+    let _classThis_7;
+    var ClassBody = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_7 = { value: this }, _classDecorators_7, { kind: "class", name: this.name }, null, _classExtraInitializers_7);
+            ClassBody = _classThis_7 = _classDescriptor_7.value;
+            __runInitializers(_classThis_7, _classExtraInitializers_7);
+        }
+        body;
+        static fromJSON(node, deserializer) {
+            return new ClassBody(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;
+        }
+        set(stack, value) {
+            throw new Error('Method not implemented.');
+        }
+        get(stack, initializer) {
+            this.body.forEach(definition => definition.get(stack, initializer));
+        }
+        dependency(computed) {
+            throw new Error('Method not implemented.');
+        }
+        dependencyPath(computed) {
+            throw new Error('Method not implemented.');
+        }
+        toString() {
+            return this.body.map(definition => `\t${definition.toString()}`).join('\n');
+        }
+        toJson() {
+            return {
+                body: this.body.map(method => method.toJSON())
+            };
+        }
+    };
+    return ClassBody = _classThis_7;
+})();
 export class Class extends AbstractExpressionNode {
+    body;
+    decorators;
+    id;
+    superClass;
     constructor(body, decorators, id, superClass, range, loc) {
         super(range, loc);
         this.body = body;
@@ -594,22 +666,17 @@ export class Class extends AbstractExpressionNode {
         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)
+            [className]: class extends parentClass {
+                static [Symbol.toStringTag] = className;
+                static [PRIVATE_SYMBOL] = {};
+                [PRIVATE_SYMBOL] = {};
+                constructor(...params) {
+                    const parameters = initializer.getSuperArguments(params);
+                    super(...parameters);
+                    initializer.initInstance(this);
+                }
+            }
         };
         return nameClassDeclaration[className];
     }
@@ -639,53 +706,67 @@ export class Class extends AbstractExpressionNode {
         };
     }
 }
-let ClassDeclaration = ClassDeclaration_1 = class ClassDeclaration extends Class {
-    static fromJSON(node, deserializer) {
-        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);
-        node.decorators.forEach(visitNode);
-        visitNode(node.id);
-        node.superClass && visitNode(node.superClass);
-    }
-    constructor(body, decorators, id, superClass, range, loc) {
-        super(body, decorators, id, superClass, range, loc);
-    }
-    declareVariable(stack, propertyValue) {
-        stack.declareVariable(this.id.getName(), propertyValue);
-    }
-    getDeclarationName() {
-        return this.id.getDeclarationName();
-    }
-    get(stack) {
-        const classConstructor = super.get(stack);
-        this.id.declareVariable(stack, classConstructor);
-        return classConstructor;
-    }
-};
-ClassDeclaration = ClassDeclaration_1 = __decorate([
-    Deserializer('ClassDeclaration'),
-    __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.decorators.map(deserializer), node.id && deserializer(node.id), node.superClass && deserializer(node.superClass), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.body);
-        node.decorators.forEach(visitNode);
-        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([
-    Deserializer('ClassExpression'),
-    __metadata("design:paramtypes", [ClassBody, Array, Identifier, Object, Array, Object])
-], ClassExpression);
-export { ClassExpression };
+export let ClassDeclaration = (() => {
+    let _classDecorators_8 = [Deserializer('ClassDeclaration')];
+    let _classDescriptor_8;
+    let _classExtraInitializers_8 = [];
+    let _classThis_8;
+    var ClassDeclaration = class extends Class {
+        static {
+            __esDecorate(null, _classDescriptor_8 = { value: this }, _classDecorators_8, { kind: "class", name: this.name }, null, _classExtraInitializers_8);
+            ClassDeclaration = _classThis_8 = _classDescriptor_8.value;
+            __runInitializers(_classThis_8, _classExtraInitializers_8);
+        }
+        static fromJSON(node, deserializer) {
+            return new ClassDeclaration(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);
+            node.decorators.forEach(visitNode);
+            visitNode(node.id);
+            node.superClass && visitNode(node.superClass);
+        }
+        constructor(body, decorators, id, superClass, range, loc) {
+            super(body, decorators, id, superClass, range, loc);
+        }
+        declareVariable(stack, propertyValue) {
+            stack.declareVariable(this.id.getName(), propertyValue);
+        }
+        getDeclarationName() {
+            return this.id.getDeclarationName();
+        }
+        get(stack) {
+            const classConstructor = super.get(stack);
+            this.id.declareVariable(stack, classConstructor);
+            return classConstructor;
+        }
+    };
+    return ClassDeclaration = _classThis_8;
+})();
+export let ClassExpression = (() => {
+    let _classDecorators_9 = [Deserializer('ClassExpression')];
+    let _classDescriptor_9;
+    let _classExtraInitializers_9 = [];
+    let _classThis_9;
+    var ClassExpression = class extends Class {
+        static {
+            __esDecorate(null, _classDescriptor_9 = { value: this }, _classDecorators_9, { kind: "class", name: this.name }, null, _classExtraInitializers_9);
+            ClassExpression = _classThis_9 = _classDescriptor_9.value;
+            __runInitializers(_classThis_9, _classExtraInitializers_9);
+        }
+        static fromJSON(node, deserializer) {
+            return new ClassExpression(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);
+            node.decorators.forEach(visitNode);
+            node.id && visitNode(node.id);
+            node.superClass && visitNode(node.superClass);
+        }
+        constructor(body, decorators, id, superClass, range, loc) {
+            super(body, decorators, id, superClass, range, loc);
+        }
+    };
+    return ClassExpression = _classThis_9;
+})();
 //# sourceMappingURL=class.js.map