@ibyar/expressions 0.8.5 → 1.0.0

package/api/statement/iterations/for.js

@@ -1,5 +1,4 @@
-var ForNode_1, ForOfNode_1, ForInNode_1, ForAwaitOfNode_1;
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { AbstractExpressionNode, ReturnValue } from '../../abstract.js';
 import { Deserializer } from '../../deserialize/deserialize.js';
 import { TerminateReturnType } from '../control/terminate.js';
@@ -8,297 +7,338 @@ import { TerminateReturnType } from '../control/terminate.js';
  * If the condition is falsy, another statement can be executed.
  *
  */
-let ForNode = ForNode_1 = class ForNode extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ForNode_1(deserializer(node.body), node.init && deserializer(node.init), node.test && deserializer(node.test), node.update && deserializer(node.update), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.body);
-        node.init && visitNode(node.init);
-        node.test && visitNode(node.test);
-        node.update && visitNode(node.update);
-    }
-    constructor(body, init, test, update, range, loc) {
-        super(range, loc);
-        this.body = body;
-        this.init = init;
-        this.test = test;
-        this.update = update;
-    }
-    getBody() {
-        return this.body;
-    }
-    getInit() {
-        return this.init;
-    }
-    getTest() {
-        return this.test;
-    }
-    getUpdate() {
-        return this.update;
-    }
-    set(stack, value) {
-        throw new Error(`ForNode#set() has no implementation.`);
-    }
-    get(stack) {
-        const forBlock = stack.pushBlockScope();
-        for (this.init?.get(stack); this.test?.get(stack) ?? true; this.update?.get(stack)) {
-            const result = this.body.get(stack);
-            // useless case, as it at the end of for statement
-            // an array/block statement, should return last signal
-            if (result instanceof TerminateReturnType) {
-                if (result.type === 'continue') {
-                    continue;
+export let ForNode = (() => {
+    let _classDecorators = [Deserializer('ForStatement')];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ForNode = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor = { value: this }, _classDecorators, { kind: "class", name: this.name }, null, _classExtraInitializers);
+            ForNode = _classThis = _classDescriptor.value;
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        body;
+        init;
+        test;
+        update;
+        static fromJSON(node, deserializer) {
+            return new ForNode(deserializer(node.body), node.init && deserializer(node.init), node.test && deserializer(node.test), node.update && deserializer(node.update), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.body);
+            node.init && visitNode(node.init);
+            node.test && visitNode(node.test);
+            node.update && visitNode(node.update);
+        }
+        constructor(body, init, test, update, range, loc) {
+            super(range, loc);
+            this.body = body;
+            this.init = init;
+            this.test = test;
+            this.update = update;
+        }
+        getBody() {
+            return this.body;
+        }
+        getInit() {
+            return this.init;
+        }
+        getTest() {
+            return this.test;
+        }
+        getUpdate() {
+            return this.update;
+        }
+        set(stack, value) {
+            throw new Error(`ForNode#set() has no implementation.`);
+        }
+        get(stack) {
+            const forBlock = stack.pushBlockScope();
+            for (this.init?.get(stack); this.test?.get(stack) ?? true; this.update?.get(stack)) {
+                const result = this.body.get(stack);
+                // useless case, as it at the end of for statement
+                // an array/block statement, should return last signal
+                if (result instanceof TerminateReturnType) {
+                    if (result.type === 'continue') {
+                        continue;
+                    }
+                    else {
+                        break;
+                    }
                 }
-                else {
-                    break;
+                if (result instanceof ReturnValue) {
+                    stack.clearTo(forBlock);
+                    return result;
                 }
             }
-            if (result instanceof ReturnValue) {
-                stack.clearTo(forBlock);
-                return result;
-            }
+            stack.clearTo(forBlock);
+            return void 0;
         }
-        stack.clearTo(forBlock);
-        return void 0;
-    }
-    dependency(computed) {
-        let dependency = this.body.dependency(computed);
-        this.init && (dependency = dependency.concat(this.init.dependency(computed)));
-        this.test && (dependency = dependency.concat(this.test.dependency(computed)));
-        this.update && (dependency = dependency.concat(this.update.dependency(computed)));
-        return dependency;
-    }
-    dependencyPath(computed) {
-        let dependencyPath = this.body.dependencyPath(computed);
-        this.init && (dependencyPath = dependencyPath.concat(this.init.dependencyPath(computed)));
-        this.test && (dependencyPath = dependencyPath.concat(this.test.dependencyPath(computed)));
-        this.update && (dependencyPath = dependencyPath.concat(this.update.dependencyPath(computed)));
-        return dependencyPath;
-    }
-    toString() {
-        return `for (${this.init?.toString()};${this.test?.toString()};${this.init?.toString()}) ${this.body.toString()}`;
-    }
-    toJson() {
-        return {
-            body: this.body.toJSON(),
-            init: this.init?.toJSON(),
-            test: this.test?.toJSON(),
-            update: this.update?.toJSON(),
-        };
-    }
-};
-ForNode = ForNode_1 = __decorate([
-    Deserializer('ForStatement'),
-    __metadata("design:paramtypes", [Object, Object, Object, Object, Array, Object])
-], ForNode);
-export { ForNode };
-let ForOfNode = ForOfNode_1 = class ForOfNode extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ForOfNode_1(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.left);
-        visitNode(node.right);
-        visitNode(node.body);
-    }
-    constructor(left, right, body, range, loc) {
-        super(range, loc);
-        this.left = left;
-        this.right = right;
-        this.body = body;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    getBody() {
-        return this.body;
-    }
-    set(stack, value) {
-        throw new Error(`ForOfNode#set() has no implementation.`);
-    }
-    get(stack) {
-        const iterable = this.right.get(stack);
-        for (const iterator of iterable) {
-            const forBlock = stack.pushBlockScope();
-            this.left.declareVariable(stack, iterator);
-            const result = this.body.get(stack);
-            // useless case, as it at the end of for statement
-            // an array/block statement, should return last signal
-            if (result instanceof TerminateReturnType) {
-                if (result.type === 'continue') {
-                    continue;
+        dependency(computed) {
+            let dependency = this.body.dependency(computed);
+            this.init && (dependency = dependency.concat(this.init.dependency(computed)));
+            this.test && (dependency = dependency.concat(this.test.dependency(computed)));
+            this.update && (dependency = dependency.concat(this.update.dependency(computed)));
+            return dependency;
+        }
+        dependencyPath(computed) {
+            let dependencyPath = this.body.dependencyPath(computed);
+            this.init && (dependencyPath = dependencyPath.concat(this.init.dependencyPath(computed)));
+            this.test && (dependencyPath = dependencyPath.concat(this.test.dependencyPath(computed)));
+            this.update && (dependencyPath = dependencyPath.concat(this.update.dependencyPath(computed)));
+            return dependencyPath;
+        }
+        toString() {
+            return `for (${this.init?.toString()};${this.test?.toString()};${this.init?.toString()}) ${this.body.toString()}`;
+        }
+        toJson() {
+            return {
+                body: this.body.toJSON(),
+                init: this.init?.toJSON(),
+                test: this.test?.toJSON(),
+                update: this.update?.toJSON(),
+            };
+        }
+    };
+    return ForNode = _classThis;
+})();
+export let ForOfNode = (() => {
+    let _classDecorators_1 = [Deserializer('ForOfStatement')];
+    let _classDescriptor_1;
+    let _classExtraInitializers_1 = [];
+    let _classThis_1;
+    var ForOfNode = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_1 = { value: this }, _classDecorators_1, { kind: "class", name: this.name }, null, _classExtraInitializers_1);
+            ForOfNode = _classThis_1 = _classDescriptor_1.value;
+            __runInitializers(_classThis_1, _classExtraInitializers_1);
+        }
+        left;
+        right;
+        body;
+        static fromJSON(node, deserializer) {
+            return new ForOfNode(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.left);
+            visitNode(node.right);
+            visitNode(node.body);
+        }
+        constructor(left, right, body, range, loc) {
+            super(range, loc);
+            this.left = left;
+            this.right = right;
+            this.body = body;
+        }
+        getLeft() {
+            return this.left;
+        }
+        getRight() {
+            return this.right;
+        }
+        getBody() {
+            return this.body;
+        }
+        set(stack, value) {
+            throw new Error(`ForOfNode#set() has no implementation.`);
+        }
+        get(stack) {
+            const iterable = this.right.get(stack);
+            for (const iterator of iterable) {
+                const forBlock = stack.pushBlockScope();
+                this.left.declareVariable(stack, iterator);
+                const result = this.body.get(stack);
+                // useless case, as it at the end of for statement
+                // an array/block statement, should return last signal
+                if (result instanceof TerminateReturnType) {
+                    if (result.type === 'continue') {
+                        continue;
+                    }
+                    else {
+                        break;
+                    }
                 }
-                else {
-                    break;
+                else if (result instanceof ReturnValue) {
+                    stack.clearTo(forBlock);
+                    return result;
                 }
-            }
-            else if (result instanceof ReturnValue) {
                 stack.clearTo(forBlock);
-                return result;
             }
-            stack.clearTo(forBlock);
+            return void 0;
         }
-        return void 0;
-    }
-    dependency(computed) {
-        return this.right.dependency(computed);
-    }
-    dependencyPath(computed) {
-        return this.right.dependencyPath(computed);
-    }
-    toString() {
-        return `for (${this.left?.toString()} of ${this.right.toString()}) ${this.body.toString()}`;
-    }
-    toJson() {
-        return {
-            left: this.left.toJSON(),
-            right: this.right.toJSON(),
-            body: this.body.toJSON(),
-        };
-    }
-};
-ForOfNode = ForOfNode_1 = __decorate([
-    Deserializer('ForOfStatement'),
-    __metadata("design:paramtypes", [Object, Object, Object, Array, Object])
-], ForOfNode);
-export { ForOfNode };
-let ForInNode = ForInNode_1 = class ForInNode extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ForInNode_1(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.left);
-        visitNode(node.right);
-        visitNode(node.body);
-    }
-    // variable of iterable
-    constructor(left, right, body, range, loc) {
-        super(range, loc);
-        this.left = left;
-        this.right = right;
-        this.body = body;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    getBody() {
-        return this.body;
-    }
-    set(stack, value) {
-        throw new Error(`ForOfNode#set() has no implementation.`);
-    }
-    get(stack) {
-        const iterable = this.right.get(stack);
-        for (const iterator in iterable) {
-            const forBlock = stack.pushBlockScope();
-            this.left.declareVariable(stack, iterator);
-            const result = this.body.get(stack);
-            // useless case, as it at the end of for statement
-            // an array/block statement, should return last signal
-            if (result instanceof TerminateReturnType) {
-                if (result.type === 'continue') {
-                    continue;
+        dependency(computed) {
+            return this.right.dependency(computed);
+        }
+        dependencyPath(computed) {
+            return this.right.dependencyPath(computed);
+        }
+        toString() {
+            return `for (${this.left?.toString()} of ${this.right.toString()}) ${this.body.toString()}`;
+        }
+        toJson() {
+            return {
+                left: this.left.toJSON(),
+                right: this.right.toJSON(),
+                body: this.body.toJSON(),
+            };
+        }
+    };
+    return ForOfNode = _classThis_1;
+})();
+export let ForInNode = (() => {
+    let _classDecorators_2 = [Deserializer('ForInStatement')];
+    let _classDescriptor_2;
+    let _classExtraInitializers_2 = [];
+    let _classThis_2;
+    var ForInNode = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_2 = { value: this }, _classDecorators_2, { kind: "class", name: this.name }, null, _classExtraInitializers_2);
+            ForInNode = _classThis_2 = _classDescriptor_2.value;
+            __runInitializers(_classThis_2, _classExtraInitializers_2);
+        }
+        left;
+        right;
+        body;
+        static fromJSON(node, deserializer) {
+            return new ForInNode(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.left);
+            visitNode(node.right);
+            visitNode(node.body);
+        }
+        // variable of iterable
+        constructor(left, right, body, range, loc) {
+            super(range, loc);
+            this.left = left;
+            this.right = right;
+            this.body = body;
+        }
+        getLeft() {
+            return this.left;
+        }
+        getRight() {
+            return this.right;
+        }
+        getBody() {
+            return this.body;
+        }
+        set(stack, value) {
+            throw new Error(`ForOfNode#set() has no implementation.`);
+        }
+        get(stack) {
+            const iterable = this.right.get(stack);
+            for (const iterator in iterable) {
+                const forBlock = stack.pushBlockScope();
+                this.left.declareVariable(stack, iterator);
+                const result = this.body.get(stack);
+                // useless case, as it at the end of for statement
+                // an array/block statement, should return last signal
+                if (result instanceof TerminateReturnType) {
+                    if (result.type === 'continue') {
+                        continue;
+                    }
+                    else {
+                        break;
+                    }
                 }
-                else {
-                    break;
+                else if (result instanceof ReturnValue) {
+                    stack.clearTo(forBlock);
+                    return result;
                 }
+                stack.clearTo(forBlock);
             }
-            else if (result instanceof ReturnValue) {
+            return void 0;
+        }
+        dependency(computed) {
+            return this.right.dependency(computed);
+        }
+        dependencyPath(computed) {
+            return this.right.dependencyPath(computed);
+        }
+        toString() {
+            return `for (${this.left.toString()} in ${this.right.toString()}) ${this.body.toString()}`;
+        }
+        toJson() {
+            return {
+                left: this.left.toJSON(),
+                right: this.right.toJSON(),
+                body: this.body.toJSON(),
+            };
+        }
+    };
+    return ForInNode = _classThis_2;
+})();
+export let ForAwaitOfNode = (() => {
+    let _classDecorators_3 = [Deserializer('ForAwaitOfStatement')];
+    let _classDescriptor_3;
+    let _classExtraInitializers_3 = [];
+    let _classThis_3;
+    var ForAwaitOfNode = class extends AbstractExpressionNode {
+        static {
+            __esDecorate(null, _classDescriptor_3 = { value: this }, _classDecorators_3, { kind: "class", name: this.name }, null, _classExtraInitializers_3);
+            ForAwaitOfNode = _classThis_3 = _classDescriptor_3.value;
+            __runInitializers(_classThis_3, _classExtraInitializers_3);
+        }
+        left;
+        right;
+        body;
+        static fromJSON(node, deserializer) {
+            return new ForAwaitOfNode(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
+        }
+        static visit(node, visitNode) {
+            visitNode(node.left);
+            visitNode(node.right);
+            visitNode(node.body);
+        }
+        // variable of iterable
+        constructor(left, right, body, range, loc) {
+            super(range, loc);
+            this.left = left;
+            this.right = right;
+            this.body = body;
+        }
+        getLeft() {
+            return this.left;
+        }
+        getRight() {
+            return this.right;
+        }
+        getBody() {
+            return this.body;
+        }
+        set(stack, value) {
+            throw new Error(`ForAwaitOfNode#set() has no implementation.`);
+        }
+        get(stack) {
+            const iterable = this.right.get(stack);
+            const forAwaitBody = (iterator) => {
+                const forBlock = stack.pushBlockScope();
+                this.left.declareVariable(stack, iterator);
+                const result = this.body.get(stack);
                 stack.clearTo(forBlock);
                 return result;
-            }
-            stack.clearTo(forBlock);
+            };
+            stack.forAwaitAsyncIterable = { iterable, forAwaitBody };
         }
-        return void 0;
-    }
-    dependency(computed) {
-        return this.right.dependency(computed);
-    }
-    dependencyPath(computed) {
-        return this.right.dependencyPath(computed);
-    }
-    toString() {
-        return `for (${this.left.toString()} in ${this.right.toString()}) ${this.body.toString()}`;
-    }
-    toJson() {
-        return {
-            left: this.left.toJSON(),
-            right: this.right.toJSON(),
-            body: this.body.toJSON(),
-        };
-    }
-};
-ForInNode = ForInNode_1 = __decorate([
-    Deserializer('ForInStatement'),
-    __metadata("design:paramtypes", [Object, Object, Object, Array, Object])
-], ForInNode);
-export { ForInNode };
-let ForAwaitOfNode = ForAwaitOfNode_1 = class ForAwaitOfNode extends AbstractExpressionNode {
-    static fromJSON(node, deserializer) {
-        return new ForAwaitOfNode_1(deserializer(node.left), deserializer(node.right), deserializer(node.body), node.range, node.loc);
-    }
-    static visit(node, visitNode) {
-        visitNode(node.left);
-        visitNode(node.right);
-        visitNode(node.body);
-    }
-    // variable of iterable
-    constructor(left, right, body, range, loc) {
-        super(range, loc);
-        this.left = left;
-        this.right = right;
-        this.body = body;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    getBody() {
-        return this.body;
-    }
-    set(stack, value) {
-        throw new Error(`ForAwaitOfNode#set() has no implementation.`);
-    }
-    get(stack) {
-        const iterable = this.right.get(stack);
-        const forAwaitBody = (iterator) => {
-            const forBlock = stack.pushBlockScope();
-            this.left.declareVariable(stack, iterator);
-            const result = this.body.get(stack);
-            stack.clearTo(forBlock);
-            return result;
-        };
-        stack.forAwaitAsyncIterable = { iterable, forAwaitBody };
-    }
-    dependency(computed) {
-        return this.right.dependency(computed);
-    }
-    dependencyPath(computed) {
-        return this.right.dependencyPath(computed);
-    }
-    toString() {
-        return `for (${this.left?.toString()} of ${this.right.toString()}) ${this.body.toString()}`;
-    }
-    toJson() {
-        return {
-            left: this.left.toJSON(),
-            right: this.right.toJSON(),
-            body: this.body.toJSON(),
-        };
-    }
-};
-ForAwaitOfNode = ForAwaitOfNode_1 = __decorate([
-    Deserializer('ForAwaitOfStatement'),
-    __metadata("design:paramtypes", [Object, Object, Object, Array, Object])
-], ForAwaitOfNode);
-export { ForAwaitOfNode };
+        dependency(computed) {
+            return this.right.dependency(computed);
+        }
+        dependencyPath(computed) {
+            return this.right.dependencyPath(computed);
+        }
+        toString() {
+            return `for (${this.left?.toString()} of ${this.right.toString()}) ${this.body.toString()}`;
+        }
+        toJson() {
+            return {
+                left: this.left.toJSON(),
+                right: this.right.toJSON(),
+                body: this.body.toJSON(),
+            };
+        }
+    };
+    return ForAwaitOfNode = _classThis_3;
+})();
 //# sourceMappingURL=for.js.map