@ibyar/expressions 0.8.6 → 1.0.0

package/api/definition/function.js

@@ -1,491 +1,528 @@
-var AssignmentPattern_1, FunctionExpression_1, FunctionDeclaration_1, ArrowFunctionExpression_1;
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { AbstractExpressionNode, AwaitPromise, ReturnValue, YieldDelegateValue, YieldValue } from '../abstract.js';
 import { Deserializer } from '../deserialize/deserialize.js';
-import { Identifier } from './values.js';
 import { TerminateReturnType } from '../statement/control/terminate.js';
 import { RestElement } from '../computing/rest.js';
-let AssignmentPattern = AssignmentPattern_1 = class AssignmentPattern extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new AssignmentPattern_1(deserializer(node.left), deserializer(node.right), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.left);
-        visitNode(node.right);
-    }
-    constructor(left, right, range, loc) {
-        super(range, loc);
-        this.left = left;
-        this.right = right;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    set(stack, value) {
-        throw new Error('AssignmentPattern#set() has no implementation.');
-    }
-    get(stack) {
-        throw new Error('AssignmentPattern#get() has no implementation.');
-    }
-    declareVariable(stack, value) {
-        if (value === undefined) {
-            value = this.right.get(stack);
-        }
-        this.left.declareVariable(stack, value);
-    }
-    dependency(computed) {
-        return [this.right];
-    }
-    dependencyPath(computed) {
-        return this.right.dependencyPath(computed) || [];
-    }
-    toString() {
-        return `${this.left.toString()} = ${this.right.toString()}`;
-    }
-    toJson() {
-        return {
-            left: this.left.toJSON(),
-            right: this.right.toJSON()
-        };
-    }
-};
-AssignmentPattern = AssignmentPattern_1 = __decorate([
-    Deserializer('AssignmentPattern'),
-    __metadata("design:paramtypes", [Object, Object, Array, Object])
-], AssignmentPattern);
-export { AssignmentPattern };
-let FunctionExpression = FunctionExpression_1 = class FunctionExpression extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new FunctionExpression_1(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, node.id ? deserializer(node.id) : void 0, node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        node.id && visitNode(node.id);
-        node.params.forEach(visitNode);
-        visitNode(node.body);
-    }
-    constructor(params, body, async, generator, id, range, loc) {
-        super(range, loc);
-        this.params = params;
-        this.body = body;
-        this.async = async;
-        this.generator = generator;
-        this.id = id;
-    }
-    getParams() {
-        return this.params;
-    }
-    getBody() {
-        return this.body;
-    }
-    getGenerator() {
-        return this.generator;
-    }
-    getId() {
-        return this.id;
-    }
-    getAsync() {
-        return this.async;
-    }
-    set(stack, value) {
-        throw new Error(`${this.constructor.name}#set() has no implementation.`);
-    }
-    defineFunctionArguments(stack, args) {
-        const rest = this.params[this.params.length - 1] instanceof RestElement;
-        const limit = rest ? this.params.length - 1 : this.params.length;
-        for (let i = 0; i < limit; i++) {
-            this.params[i].declareVariable(stack, args[i]);
-        }
-        if (rest) {
-            this.params[limit].declareVariable(stack, args.slice(limit));
-        }
-    }
-    get(stack) {
-        // freeze scopes
-        stack = stack.copyStack();
-        let func;
-        if (this.async && this.generator) {
-            func = this.getAsyncGeneratorFunction(stack);
-        }
-        else if (this.async) {
-            func = this.getAsyncFunction(stack);
-        }
-        else if (this.generator) {
-            func = this.getGeneratorFunction(stack);
-        }
-        else {
-            func = this.getFunction(stack);
-        }
-        // this.id?.declareVariable(stack, func);
-        return func;
-    }
-    getAsyncFunction(gStack) {
-        const self = this;
-        return async function (...args) {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            stack.declareVariable('this', this);
-            stack.declareVariable('super', this?.constructor?.prototype);
-            self.defineFunctionArguments(stack, args);
-            let returnValue;
-            const statements = self.body.getBody();
-            for (const statement of statements) {
-                returnValue = statement.get(stack);
-                if (stack.awaitPromise?.length > 0) {
-                    for (const awaitRef of stack.awaitPromise) {
-                        const awaitValue = await awaitRef.promise;
-                        if (awaitRef.declareVariable) {
-                            awaitRef.node.declareVariable(stack, awaitValue);
-                        }
-                        else {
-                            awaitRef.node.set(stack, awaitValue);
+export let AssignmentPattern = (() => {
+    let _classDecorators = [Deserializer('AssignmentPattern')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var AssignmentPattern = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor = { value: this }, _classDecorators, { kind: "class", name: this.name }, null, _classExtraInitializers);
+            AssignmentPattern = _classThis = _classDescriptor.value;
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        left;
+        right;
+        static fromJSON(node, deserializer) {
+            return new AssignmentPattern(deserializer(node.left), deserializer(node.right), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.left);
+            visitNode(node.right);
+        }
+        constructor(left, right, range, loc) {
+            super(range, loc);
+            this.left = left;
+            this.right = right;
+        }
+        getLeft() {
+            return this.left;
+        }
+        getRight() {
+            return this.right;
+        }
+        set(stack, value) {
+            throw new Error('AssignmentPattern#set() has no implementation.');
+        }
+        get(stack) {
+            throw new Error('AssignmentPattern#get() has no implementation.');
+        }
+        declareVariable(stack, value) {
+            if (value === undefined) {
+                value = this.right.get(stack);
+            }
+            this.left.declareVariable(stack, value);
+        }
+        dependency(computed) {
+            return [this.right];
+        }
+        dependencyPath(computed) {
+            return this.right.dependencyPath(computed) || [];
+        }
+        toString() {
+            return `${this.left.toString()} = ${this.right.toString()}`;
+        }
+        toJson() {
+            return {
+                left: this.left.toJSON(),
+                right: this.right.toJSON()
+            };
+        }
+    };
+    return AssignmentPattern = _classThis;
+})();
+export let FunctionExpression = (() => {
+    let _classDecorators_1 = [Deserializer('FunctionExpression')];
+    let _classDescriptor_1;
+    let _classExtraInitializers_1 = [];
+    let _classThis_1;
+    var FunctionExpression = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_1 = { value: this }, _classDecorators_1, { kind: "class", name: this.name }, null, _classExtraInitializers_1);
+            FunctionExpression = _classThis_1 = _classDescriptor_1.value;
+            __runInitializers(_classThis_1, _classExtraInitializers_1);
+        }
+        params;
+        body;
+        async;
+        generator;
+        id;
+        static fromJSON(node, deserializer) {
+            return new FunctionExpression(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, node.id ? deserializer(node.id) : void 0, node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            node.id && visitNode(node.id);
+            node.params.forEach(visitNode);
+            visitNode(node.body);
+        }
+        constructor(params, body, async, generator, id, range, loc) {
+            super(range, loc);
+            this.params = params;
+            this.body = body;
+            this.async = async;
+            this.generator = generator;
+            this.id = id;
+        }
+        getParams() {
+            return this.params;
+        }
+        getBody() {
+            return this.body;
+        }
+        getGenerator() {
+            return this.generator;
+        }
+        getId() {
+            return this.id;
+        }
+        getAsync() {
+            return this.async;
+        }
+        set(stack, value) {
+            throw new Error(`${this.constructor.name}#set() has no implementation.`);
+        }
+        defineFunctionArguments(stack, args) {
+            const rest = this.params[this.params.length - 1] instanceof RestElement;
+            const limit = rest ? this.params.length - 1 : this.params.length;
+            for (let i = 0; i < limit; i++) {
+                this.params[i].declareVariable(stack, args[i]);
+            }
+            if (rest) {
+                this.params[limit].declareVariable(stack, args.slice(limit));
+            }
+        }
+        get(stack) {
+            // freeze scopes
+            stack = stack.copyStack();
+            let func;
+            if (this.async && this.generator) {
+                func = this.getAsyncGeneratorFunction(stack);
+            }
+            else if (this.async) {
+                func = this.getAsyncFunction(stack);
+            }
+            else if (this.generator) {
+                func = this.getGeneratorFunction(stack);
+            }
+            else {
+                func = this.getFunction(stack);
+            }
+            // this.id?.declareVariable(stack, func);
+            return func;
+        }
+        getAsyncFunction(gStack) {
+            const self = this;
+            return async function (...args) {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                stack.declareVariable('this', this);
+                stack.declareVariable('super', this?.constructor?.prototype);
+                self.defineFunctionArguments(stack, args);
+                let returnValue;
+                const statements = self.body.getBody();
+                for (const statement of statements) {
+                    returnValue = statement.get(stack);
+                    if (stack.awaitPromise?.length > 0) {
+                        for (const awaitRef of stack.awaitPromise) {
+                            const awaitValue = await awaitRef.promise;
+                            if (awaitRef.declareVariable) {
+                                awaitRef.node.declareVariable(stack, awaitValue);
+                            }
+                            else {
+                                awaitRef.node.set(stack, awaitValue);
+                            }
                         }
+                        stack.awaitPromise.splice(0);
                     }
-                    stack.awaitPromise.splice(0);
-                }
-                else if (stack.forAwaitAsyncIterable) {
-                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                        if (result instanceof TerminateReturnType) {
-                            if (result.type === 'continue') {
-                                continue;
+                    else if (stack.forAwaitAsyncIterable) {
+                        for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                            const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                            if (result instanceof TerminateReturnType) {
+                                if (result.type === 'continue') {
+                                    continue;
+                                }
+                                else {
+                                    break;
+                                }
                             }
-                            else {
+                            else if (result instanceof ReturnValue) {
+                                returnValue = result;
                                 break;
                             }
                         }
-                        else if (result instanceof ReturnValue) {
-                            returnValue = result;
-                            break;
+                        stack.forAwaitAsyncIterable = undefined;
+                    }
+                    if (returnValue instanceof ReturnValue) {
+                        returnValue = returnValue.value;
+                        if (returnValue instanceof AwaitPromise) {
+                            returnValue = await returnValue.promise;
                         }
+                        return returnValue;
                     }
-                    stack.forAwaitAsyncIterable = undefined;
                 }
-                if (returnValue instanceof ReturnValue) {
-                    returnValue = returnValue.value;
-                    if (returnValue instanceof AwaitPromise) {
-                        returnValue = await returnValue.promise;
+            };
+        }
+        getGeneratorFunction(gStack) {
+            const self = this;
+            return function* (...args) {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                stack.declareVariable('this', this);
+                stack.declareVariable('super', this?.constructor?.prototype);
+                self.defineFunctionArguments(stack, args);
+                let returnValue;
+                const statements = self.body.getBody();
+                for (const statement of statements) {
+                    returnValue = statement.get(stack);
+                    if (returnValue instanceof ReturnValue) {
+                        return returnValue.value;
                     }
-                    return returnValue;
-                }
-            }
-        };
-    }
-    getGeneratorFunction(gStack) {
-        const self = this;
-        return function* (...args) {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            stack.declareVariable('this', this);
-            stack.declareVariable('super', this?.constructor?.prototype);
-            self.defineFunctionArguments(stack, args);
-            let returnValue;
-            const statements = self.body.getBody();
-            for (const statement of statements) {
-                returnValue = statement.get(stack);
-                if (returnValue instanceof ReturnValue) {
-                    return returnValue.value;
-                }
-                else if (returnValue instanceof YieldValue) {
-                    yield returnValue.value;
-                }
-                else if (returnValue instanceof YieldDelegateValue) {
-                    yield* returnValue.value;
-                }
-            }
-        };
-    }
-    getAsyncGeneratorFunction(gStack) {
-        const self = this;
-        return async function* (...args) {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            stack.declareVariable('this', this);
-            stack.declareVariable('super', this?.constructor?.prototype);
-            self.defineFunctionArguments(stack, args);
-            let returnValue;
-            const statements = self.body.getBody();
-            for (const statement of statements) {
-                returnValue = statement.get(stack);
-                if (stack.awaitPromise?.length > 0) {
-                    for (const awaitRef of stack.awaitPromise) {
-                        const awaitValue = await awaitRef.promise;
-                        if (awaitRef.declareVariable) {
-                            awaitRef.node.declareVariable(stack, awaitValue);
-                        }
-                        else {
-                            awaitRef.node.set(stack, awaitValue);
-                        }
+                    else if (returnValue instanceof YieldValue) {
+                        yield returnValue.value;
+                    }
+                    else if (returnValue instanceof YieldDelegateValue) {
+                        yield* returnValue.value;
                     }
-                    stack.awaitPromise.splice(0);
                 }
-                else if (stack.forAwaitAsyncIterable) {
-                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                        if (result instanceof TerminateReturnType) {
-                            if (result.type === 'continue') {
-                                continue;
+            };
+        }
+        getAsyncGeneratorFunction(gStack) {
+            const self = this;
+            return async function* (...args) {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                stack.declareVariable('this', this);
+                stack.declareVariable('super', this?.constructor?.prototype);
+                self.defineFunctionArguments(stack, args);
+                let returnValue;
+                const statements = self.body.getBody();
+                for (const statement of statements) {
+                    returnValue = statement.get(stack);
+                    if (stack.awaitPromise?.length > 0) {
+                        for (const awaitRef of stack.awaitPromise) {
+                            const awaitValue = await awaitRef.promise;
+                            if (awaitRef.declareVariable) {
+                                awaitRef.node.declareVariable(stack, awaitValue);
                             }
                             else {
-                                break;
+                                awaitRef.node.set(stack, awaitValue);
                             }
                         }
-                        else if (result instanceof ReturnValue) {
-                            returnValue = returnValue.value;
-                            if (returnValue instanceof AwaitPromise) {
-                                return await returnValue.promise;
-                            }
-                            else if (returnValue instanceof YieldValue) {
-                                yield returnValue.value;
+                        stack.awaitPromise.splice(0);
+                    }
+                    else if (stack.forAwaitAsyncIterable) {
+                        for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                            const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                            if (result instanceof TerminateReturnType) {
+                                if (result.type === 'continue') {
+                                    continue;
+                                }
+                                else {
+                                    break;
+                                }
                             }
-                            else if (returnValue instanceof YieldDelegateValue) {
-                                yield* returnValue.value;
+                            else if (result instanceof ReturnValue) {
+                                returnValue = returnValue.value;
+                                if (returnValue instanceof AwaitPromise) {
+                                    return await returnValue.promise;
+                                }
+                                else if (returnValue instanceof YieldValue) {
+                                    yield returnValue.value;
+                                }
+                                else if (returnValue instanceof YieldDelegateValue) {
+                                    yield* returnValue.value;
+                                }
+                                return returnValue;
                             }
-                            return returnValue;
                         }
+                        stack.forAwaitAsyncIterable = undefined;
+                    }
+                    if (returnValue instanceof ReturnValue) {
+                        returnValue = returnValue.value;
+                        if (returnValue instanceof AwaitPromise) {
+                            return await returnValue.promise;
+                        }
+                        return returnValue;
                     }
-                    stack.forAwaitAsyncIterable = undefined;
                 }
-                if (returnValue instanceof ReturnValue) {
-                    returnValue = returnValue.value;
-                    if (returnValue instanceof AwaitPromise) {
-                        return await returnValue.promise;
+            };
+        }
+        getFunction(gStack) {
+            const self = this;
+            return function (...args) {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                stack.declareVariable('this', this);
+                stack.declareVariable('super', this?.constructor?.prototype);
+                self.defineFunctionArguments(stack, args);
+                let returnValue;
+                const statements = self.body.getBody();
+                for (const statement of statements) {
+                    returnValue = statement.get(stack);
+                    if (returnValue instanceof ReturnValue) {
+                        return returnValue.value;
                     }
-                    return returnValue;
                 }
+            };
+        }
+        dependency(computed) {
+            return this.params.flatMap(param => param.dependency());
+        }
+        dependencyPath(computed) {
+            return this.params.flatMap(param => param.dependencyPath(computed));
+        }
+        toString() {
+            let declare = 'function ';
+            if (this.async && this.generator) {
+                declare = 'async function* ';
             }
-        };
-    }
-    getFunction(gStack) {
-        const self = this;
-        return function (...args) {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            stack.declareVariable('this', this);
-            stack.declareVariable('super', this?.constructor?.prototype);
-            self.defineFunctionArguments(stack, args);
-            let returnValue;
-            const statements = self.body.getBody();
-            for (const statement of statements) {
-                returnValue = statement.get(stack);
-                if (returnValue instanceof ReturnValue) {
-                    return returnValue.value;
-                }
+            else if (this.async) {
+                declare = 'async function ';
             }
-        };
-    }
-    dependency(computed) {
-        return this.params.flatMap(param => param.dependency());
-    }
-    dependencyPath(computed) {
-        return this.params.flatMap(param => param.dependencyPath(computed));
-    }
-    toString() {
-        let declare = 'function ';
-        if (this.async && this.generator) {
-            declare = 'async function* ';
-        }
-        else if (this.async) {
-            declare = 'async function ';
-        }
-        else if (this.generator) {
-            declare = 'function* ';
-        }
-        return `${declare}${this.id?.toString() || ''}${this.paramsAndBodyToString()}`;
-    }
-    paramsAndBodyToString() {
-        return `(${this.params.map(param => param.toString()).join(', ')}) ${this.body.toString()}`;
-    }
-    toJson() {
-        return {
-            params: this.params.map(param => param.toJSON()),
-            body: this.body.toJSON(),
-            async: this.async,
-            id: this.id?.toJSON(),
-            generator: this.generator
-        };
-    }
-};
-FunctionExpression = FunctionExpression_1 = __decorate([
-    Deserializer('FunctionExpression'),
-    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean, Identifier, Array, Object])
-], FunctionExpression);
-export { FunctionExpression };
-let FunctionDeclaration = FunctionDeclaration_1 = class FunctionDeclaration extends FunctionExpression {
-    static fromJSON(node, deserializer) {
-        return new FunctionDeclaration_1(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, deserializer(node.id), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.id);
-        node.params.forEach(visitNode);
-        visitNode(node.body);
-    }
-    constructor(params, body, async, generator, id, range, loc) {
-        super(params, body, async, generator, id, range, loc);
-    }
-    get(stack) {
-        const func = super.get(stack);
-        this.declareVariable(stack, func);
-        return func;
-    }
-    declareVariable(stack, value) {
-        this.id.declareVariable(stack, value);
-    }
-};
-FunctionDeclaration = FunctionDeclaration_1 = __decorate([
-    Deserializer('FunctionDeclaration'),
-    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean, Identifier, Array, Object])
-], FunctionDeclaration);
-export { FunctionDeclaration };
-let ArrowFunctionExpression = ArrowFunctionExpression_1 = class ArrowFunctionExpression extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ArrowFunctionExpression_1(node.params.map(deserializer), Array.isArray(node.body)
-            ? node.body.map(deserializer)
-            : deserializer(node.body), node.expression, node.async, node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        node.params.forEach(visitNode);
-        Array.isArray(node.body)
-            ? node.body.forEach(visitNode)
-            : visitNode(node.body);
-    }
-    constructor(params, body, expression, async, range, loc) {
-        super(range, loc);
-        this.params = params;
-        this.body = body;
-        this.expression = expression;
-        this.async = async;
-        this.generator = false;
-    }
-    getParams() {
-        return this.params;
-    }
-    getBody() {
-        return this.body;
-    }
-    getExpression() {
-        return this.expression;
-    }
-    set(stack, value) {
-        throw new Error('ArrowFunctionExpression#set() has no implementation.');
-    }
-    setParameter(stack, args) {
-        const rest = this.params[this.params.length - 1] instanceof RestElement;
-        const limit = rest ? this.params.length - 1 : this.params.length;
-        for (let i = 0; i < limit; i++) {
-            this.params[i].declareVariable(stack, args[i]);
-        }
-        if (rest) {
-            this.params[limit].declareVariable(stack, args.slice(limit));
-        }
-    }
-    get(stack) {
-        // freeze stack
-        stack = stack.copyStack();
-        return this.async ? this.getAsyncArrowFunction(stack) : this.getArrowFunction(stack);
-    }
-    getAsyncArrowFunction(gStack) {
-        async (...args) => {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            this.setParameter(stack, args);
-            let returnValue;
-            const statements = Array.isArray(this.body) ? this.body : [this.body];
-            for (const state of statements) {
-                returnValue = state.get(stack);
-                if (stack.awaitPromise?.length > 0) {
-                    for (const awaitRef of stack.awaitPromise) {
-                        const awaitValue = await awaitRef.promise;
-                        if (awaitRef.declareVariable) {
-                            awaitRef.node.declareVariable(stack, awaitValue);
-                        }
-                        else {
-                            awaitRef.node.set(stack, awaitValue);
+            else if (this.generator) {
+                declare = 'function* ';
+            }
+            return `${declare}${this.id?.toString() || ''}${this.paramsAndBodyToString()}`;
+        }
+        paramsAndBodyToString() {
+            return `(${this.params.map(param => param.toString()).join(', ')}) ${this.body.toString()}`;
+        }
+        toJson() {
+            return {
+                params: this.params.map(param => param.toJSON()),
+                body: this.body.toJSON(),
+                async: this.async,
+                id: this.id?.toJSON(),
+                generator: this.generator
+            };
+        }
+    };
+    return FunctionExpression = _classThis_1;
+})();
+export let FunctionDeclaration = (() => {
+    let _classDecorators_2 = [Deserializer('FunctionDeclaration')];
+    let _classDescriptor_2;
+    let _classExtraInitializers_2 = [];
+    let _classThis_2;
+    var FunctionDeclaration = class extends FunctionExpression {
+        static {
+            __esDecorate(null, _classDescriptor_2 = { value: this }, _classDecorators_2, { kind: "class", name: this.name }, null, _classExtraInitializers_2);
+            FunctionDeclaration = _classThis_2 = _classDescriptor_2.value;
+            __runInitializers(_classThis_2, _classExtraInitializers_2);
+        }
+        static fromJSON(node, deserializer) {
+            return new FunctionDeclaration(node.params.map(deserializer), deserializer(node.body), node.async, node.generator, deserializer(node.id), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.id);
+            node.params.forEach(visitNode);
+            visitNode(node.body);
+        }
+        constructor(params, body, async, generator, id, range, loc) {
+            super(params, body, async, generator, id, range, loc);
+        }
+        get(stack) {
+            const func = super.get(stack);
+            this.declareVariable(stack, func);
+            return func;
+        }
+        declareVariable(stack, value) {
+            this.id.declareVariable(stack, value);
+        }
+    };
+    return FunctionDeclaration = _classThis_2;
+})();
+export let ArrowFunctionExpression = (() => {
+    let _classDecorators_3 = [Deserializer('ArrowFunctionExpression')];
+    let _classDescriptor_3;
+    let _classExtraInitializers_3 = [];
+    let _classThis_3;
+    var ArrowFunctionExpression = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_3 = { value: this }, _classDecorators_3, { kind: "class", name: this.name }, null, _classExtraInitializers_3);
+            ArrowFunctionExpression = _classThis_3 = _classDescriptor_3.value;
+            __runInitializers(_classThis_3, _classExtraInitializers_3);
+        }
+        params;
+        body;
+        expression;
+        async;
+        static fromJSON(node, deserializer) {
+            return new ArrowFunctionExpression(node.params.map(deserializer), Array.isArray(node.body)
+                ? node.body.map(deserializer)
+                : deserializer(node.body), node.expression, node.async, node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            node.params.forEach(visitNode);
+            Array.isArray(node.body)
+                ? node.body.forEach(visitNode)
+                : visitNode(node.body);
+        }
+        generator = false;
+        constructor(params, body, expression, async, range, loc) {
+            super(range, loc);
+            this.params = params;
+            this.body = body;
+            this.expression = expression;
+            this.async = async;
+        }
+        getParams() {
+            return this.params;
+        }
+        getBody() {
+            return this.body;
+        }
+        getExpression() {
+            return this.expression;
+        }
+        set(stack, value) {
+            throw new Error('ArrowFunctionExpression#set() has no implementation.');
+        }
+        setParameter(stack, args) {
+            const rest = this.params[this.params.length - 1] instanceof RestElement;
+            const limit = rest ? this.params.length - 1 : this.params.length;
+            for (let i = 0; i < limit; i++) {
+                this.params[i].declareVariable(stack, args[i]);
+            }
+            if (rest) {
+                this.params[limit].declareVariable(stack, args.slice(limit));
+            }
+        }
+        get(stack) {
+            // freeze stack
+            stack = stack.copyStack();
+            return this.async ? this.getAsyncArrowFunction(stack) : this.getArrowFunction(stack);
+        }
+        getAsyncArrowFunction(gStack) {
+            async (...args) => {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                this.setParameter(stack, args);
+                let returnValue;
+                const statements = Array.isArray(this.body) ? this.body : [this.body];
+                for (const state of statements) {
+                    returnValue = state.get(stack);
+                    if (stack.awaitPromise?.length > 0) {
+                        for (const awaitRef of stack.awaitPromise) {
+                            const awaitValue = await awaitRef.promise;
+                            if (awaitRef.declareVariable) {
+                                awaitRef.node.declareVariable(stack, awaitValue);
+                            }
+                            else {
+                                awaitRef.node.set(stack, awaitValue);
+                            }
                         }
+                        stack.awaitPromise.splice(0);
                     }
-                    stack.awaitPromise.splice(0);
-                }
-                else if (stack.forAwaitAsyncIterable) {
-                    for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
-                        const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
-                        if (result instanceof TerminateReturnType) {
-                            if (result.type === 'continue') {
-                                continue;
+                    else if (stack.forAwaitAsyncIterable) {
+                        for await (let iterator of stack.forAwaitAsyncIterable.iterable) {
+                            const result = stack.forAwaitAsyncIterable.forAwaitBody(iterator);
+                            if (result instanceof TerminateReturnType) {
+                                if (result.type === 'continue') {
+                                    continue;
+                                }
+                                else {
+                                    break;
+                                }
                             }
-                            else {
+                            else if (result instanceof ReturnValue) {
+                                returnValue = result;
                                 break;
                             }
                         }
-                        else if (result instanceof ReturnValue) {
-                            returnValue = result;
-                            break;
+                        stack.forAwaitAsyncIterable = undefined;
+                    }
+                    if (returnValue instanceof ReturnValue) {
+                        returnValue = returnValue.value;
+                        if (returnValue instanceof AwaitPromise) {
+                            return await returnValue.promise;
                         }
                     }
-                    stack.forAwaitAsyncIterable = undefined;
                 }
-                if (returnValue instanceof ReturnValue) {
-                    returnValue = returnValue.value;
-                    if (returnValue instanceof AwaitPromise) {
-                        return await returnValue.promise;
+                if (this.expression) {
+                    return returnValue;
+                }
+            };
+        }
+        getArrowFunction(gStack) {
+            return (...args) => {
+                const stack = gStack.copyStack();
+                stack.pushBlockScope();
+                this.setParameter(stack, args);
+                let returnValue;
+                const statements = Array.isArray(this.body) ? this.body : [this.body];
+                for (const statement of statements) {
+                    returnValue = statement.get(stack);
+                    if (returnValue instanceof ReturnValue) {
+                        return returnValue.value;
                     }
                 }
-            }
-            if (this.expression) {
-                return returnValue;
-            }
-        };
-    }
-    getArrowFunction(gStack) {
-        return (...args) => {
-            const stack = gStack.copyStack();
-            stack.pushBlockScope();
-            this.setParameter(stack, args);
-            let returnValue;
-            const statements = Array.isArray(this.body) ? this.body : [this.body];
-            for (const statement of statements) {
-                returnValue = statement.get(stack);
-                if (returnValue instanceof ReturnValue) {
-                    return returnValue.value;
+                if (this.expression) {
+                    return returnValue;
                 }
+            };
+        }
+        dependency(computed) {
+            return this.params.flatMap(param => param.dependency());
+        }
+        dependencyPath(computed) {
+            return this.params.flatMap(param => param.dependencyPath(computed));
+        }
+        toString() {
+            let str = this.async ? 'async ' : '';
+            if (this.params.length === 1) {
+                str += this.params[0].toString();
             }
-            if (this.expression) {
-                return returnValue;
+            else {
+                str += `(${this.params.map(param => param.toString()).join(', ')})`;
             }
-        };
-    }
-    dependency(computed) {
-        return this.params.flatMap(param => param.dependency());
-    }
-    dependencyPath(computed) {
-        return this.params.flatMap(param => param.dependencyPath(computed));
-    }
-    toString() {
-        let str = this.async ? 'async ' : '';
-        if (this.params.length === 1) {
-            str += this.params[0].toString();
-        }
-        else {
-            str += `(${this.params.map(param => param.toString()).join(', ')})`;
-        }
-        str += ' => ';
-        str += this.body.toString();
-        return str;
-    }
-    toJson() {
-        return {
-            params: this.params.map(param => param.toJSON()),
-            body: Array.isArray(this.body) ? this.body.map(item => item.toJSON()) : this.body.toJSON(),
-            expression: true,
-            async: this.async,
-            generator: this.generator
-        };
-    }
-};
-ArrowFunctionExpression = ArrowFunctionExpression_1 = __decorate([
-    Deserializer('ArrowFunctionExpression'),
-    __metadata("design:paramtypes", [Array, Object, Boolean, Boolean, Array, Object])
-], ArrowFunctionExpression);
-export { ArrowFunctionExpression };
+            str += ' => ';
+            str += this.body.toString();
+            return str;
+        }
+        toJson() {
+            return {
+                params: this.params.map(param => param.toJSON()),
+                body: Array.isArray(this.body) ? this.body.map(item => item.toJSON()) : this.body.toJSON(),
+                expression: true,
+                async: this.async,
+                generator: this.generator
+            };
+        }
+    };
+    return ArrowFunctionExpression = _classThis_3;
+})();
 //# sourceMappingURL=function.js.map