@lcap/nasl 3.4.0-beta.5 → 3.4.0-beta.6

package/src/concepts/DefaultValue__.ts

@@ -1,4 +1,5 @@
-import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import { TranslatorState, shiftState, withSourceMap, TranslatorGenerator, withSourceMapGenerator } from '../translator';
+import { returnOrigin } from '../utils/time-slicing';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -24,6 +25,13 @@ export class DefaultValue extends BaseNode {
   /** 继承链 */
   static readonly inheritanceChain = ['BaseNode'];
 
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'DefaultValue';
+
   /**
    * 根表达式
    */
@@ -272,13 +280,14 @@ export class DefaultValue extends BaseNode {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, empty?: Boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state?: TranslatorState, empty?: Boolean): TranslatorGenerator {
     let code = '';
     if (empty) {
       return code;
     }
-    code += this.expression ? this.expression.toEmbeddedTS(shiftState(state, code)) : 'undefined';
+
+    code += yield* this.expression?.toEmbeddedTS?.(shiftState(state, code)) ?? returnOrigin('undefined');
     return code;
   }
   //================================================================================

package/src/concepts/Destination__.ts

@@ -1,6 +1,16 @@
+import { wrapForEachToGenerator as wrapForEach, returnOrigin } from '../utils/time-slicing';
 import View from './View__';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import { BindAttribute, Param } from '..';
 
@@ -687,22 +697,23 @@ export class Destination extends LogicItem {
     return `/${viewNameAttr.join('/')}`;
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state: TranslatorState, prependCode: string): string {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(state = createCompilerState(), prependCode: string): TranslatorGenerator {
+    const self = this;
     // const tab = indent((state?.tabSize || 0));
-    if (this.tsCalleeNamespace && this.tsName) {
-      const destinationName = this.parentNode.name.replace('-', '_');
+    if (self.tsCalleeNamespace && self.tsName) {
+      const destinationName = self.parentNode.name.replace('-', '_');
       let code = `${destinationName}: function() {\n`;
       code += prependCode;
       code += '\n';
-      if (this.tsCalleeNamespace && this.viewName) {
-        code += `${this.tsCalleeNamespace}.${this.viewName}.$destination({`;
-        if (Array.isArray(this.arguments)) {
-          this.arguments.forEach((argument: Argument) => {
-            code += `${argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
+      if (self.tsCalleeNamespace && self.viewName) {
+        code += `${self.tsCalleeNamespace}.${self.viewName}.$destination({`;
+        if (Array.isArray(self.arguments)) {
+          yield* wrapForEach(self.arguments, function* warpForEachGenerator(argument: Argument) {
+            code += `${yield* argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
           });
         }
-        code += this.anchor?.toEmbeddedTS(shiftState(state, code), true) || '';
+        code += yield* self.anchor?.toEmbeddedTS?.(shiftState(state, code), true) ?? returnOrigin('');
         code += `});\n`;
       }
       code += `${indent((state?.tabSize || 0) + 1)}}\n`;
@@ -711,53 +722,48 @@ export class Destination extends LogicItem {
     return 'destinationEmpty(){ const __destinationEmpty__: any = null}';
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-
-    const node = this.viewNode;
+    const node = self.viewNode;
     let logicParam: Param[] = [];
     if (node?.params) {
       logicParam = node.params;
     }
     const logicParamLength = logicParam.length;
-
-    if (this.parentNode instanceof BindAttribute) {
+    if (self.parentNode instanceof BindAttribute) {
       code += indent((state?.tabSize || 0) + 2);
-      if (this.tsCalleeNamespace && this.tsName) {
-        code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
-        if (Array.isArray(this.arguments)) {
-          this.arguments.forEach((argument: Argument, index) => {
+      if (self.tsCalleeNamespace && self.tsName) {
+        code += `${self.tsCalleeNamespace}.${self.tsName}.$destination({`;
+        if (Array.isArray(self.arguments)) {
+          yield* wrapForEach(self.arguments, function* warpForEachGenerator(argument: Argument, index) {
             const oldName = argument.keyword;
             if (index >= logicParamLength) {
               argument.keyword = '__unknown__';
             }
-            code += `${argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
+            code += `${yield* argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
             argument.keyword = oldName;
           });
         }
-
-        code += this.anchor?.toEmbeddedTS(shiftState(state, code), true) || '';
-
+        code += yield* self.anchor?.toEmbeddedTS?.(shiftState(state, code), true) ?? returnOrigin('');
         code += `});\n`;
       }
       return code;
     }
-    if (this.tsCalleeNamespace && this.tsName) {
-      code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
-      if (Array.isArray(this.arguments)) {
-        this.arguments.forEach((argument: Argument, index) => {
+    if (self.tsCalleeNamespace && self.tsName) {
+      code += `${self.tsCalleeNamespace}.${self.tsName}.$destination({`;
+      if (Array.isArray(self.arguments)) {
+        yield* wrapForEach(self.arguments, function* warpForEachGenerator(argument: Argument, index) {
           const oldName = argument.keyword;
           if (index >= logicParamLength) {
             argument.keyword = '__unknown__';
           }
-          code += `${argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
+          code += `${yield* argument.toEmbeddedTS(shiftState(state, code), false, true)}, `;
           argument.keyword = oldName;
         });
       }
-
-      code += this.anchor?.toEmbeddedTS(shiftState(state, code), true) || '';
-
+      code += yield* self.anchor?.toEmbeddedTS?.(shiftState(state, code), true) ?? returnOrigin('');
       code += `});\n`;
     } else {
       code += '__IDENTIFIER__';

package/src/concepts/End__.ts

@@ -1,4 +1,11 @@
-import { TranslatorState, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Return from './Return__';
 import Logic from './Logic__';
 //================================================================================
@@ -67,39 +74,41 @@ export class End extends LogicItem {
     return code;
   }
 
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
     let ret;
     let logic;
-    switch (this.parentNode.concept) {
+    switch (self.parentNode.concept) {
       case 'Logic':
-        ret = this.logic.returns[0];
+        ret = self.logic.returns[0];
         break;
       case 'AuthLogic':
-        ret = this.AuthLogic.returns[0];
+        ret = self.AuthLogic.returns[0];
         break;
       case 'AuthLogicForCallInterface':
         // 导出接口鉴权参数返回值固定为下面逻辑；
-        ret = `${indent(state?.tabSize || 0)}let ${this.parentNode.name}Result: ApiReturn; \n ${indent(
+        ret = `${indent(state?.tabSize || 0)}let ${self.parentNode.name}Result: ApiReturn; \n ${indent(
           state?.tabSize || 0,
-        )}return ${this.parentNode.name}Result;\n`;
+        )}return ${self.parentNode.name}Result;\n`;
         break;
       case 'OverriddenLogic':
-        ret = this.OverriddenLogic.returns[0];
+        ret = self.OverriddenLogic.returns[0];
         break;
       default:
         // 旧逻辑默认走这里，
         // 期望后期可以直接走完整的case， default 直接抛出异常好更明确定位错误
-        logic = logic =
-          this.parentNode.getAncestor('Logic') ||
-          this.parentNode.getAncestor('AuthLogic') ||
-          this.parentNode.getAncestor('AuthLogicForCallInterface') ||
-          this.parentNode.getAncestor('OverriddenLogic');
+        logic =
+          self.parentNode.getAncestor('Logic') ||
+          self.parentNode.getAncestor('AuthLogic') ||
+          self.parentNode.getAncestor('AuthLogicForCallInterface') ||
+          self.parentNode.getAncestor('OverriddenLogic');
         ret = (logic as Logic).returns[0];
     }
-    if (ret && this.parentNode.concept === 'AuthLogicForCallInterface') {
+    if (ret && self.parentNode.concept === 'AuthLogicForCallInterface') {
       code += ret;
-    } else if (ret && this.parentNode.concept !== 'AuthLogicForCallInterface') {
+    } else if (ret && self.parentNode.concept !== 'AuthLogicForCallInterface') {
       code += `${indent(state?.tabSize || 0)}return ${(ret as Return).name};`;
     } else {
       code += `${indent(state?.tabSize || 0)}return;`;

package/src/concepts/EntityIndex__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 
 type changeType = 'up' | 'down';
 
@@ -186,9 +194,10 @@ export class EntityIndex extends BaseNode {
     });
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    return `{ ${this.name}: [${this.propertyNames.map((item) => `this.${item}`).join(', ')}] },`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    return `{ ${self.name}: [${self.propertyNames.map((item) => `this.${item}`).join(', ')}] },`;
   }
 
   /**

package/src/concepts/EntityProperty__.ts

@@ -1,5 +1,15 @@
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import { dataTypesMap } from './basics/types';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import CallQueryComponent from './CallQueryComponent__';
 
 type changeType = 'up' | 'down';
@@ -635,23 +645,23 @@ export class EntityProperty extends BaseNode {
     }
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    if (this.relationNamespace && this.relationEntity && this.relationProperty) {
-      code += `@nasl.annotation.EntityRelation(new ${this.relationNamespace}.${this.relationEntity}().${this.relationProperty})\n`;
+    if (self.relationNamespace && self.relationEntity && self.relationProperty) {
+      code += `@nasl.annotation.EntityRelation(new ${self.relationNamespace}.${self.relationEntity}().${self.relationProperty})\n`;
       code += indent((state?.tabSize || 0) + 2);
       // code += indent((state?.tabSize || 0) + 1);
     }
-
-    code += this.name;
-    if (this.typeAnnotation) {
+    code += self.name;
+    if (self.typeAnnotation) {
       code += ': ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     if (this.defaultValue?.expression) {
       code += ` = `;
-      code += `${this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
+      code += `${yield* this.defaultValue.toEmbeddedTS(shiftState(state, code))}`;
     }
     return code;
   }

package/src/concepts/Entity__.ts

@@ -1,5 +1,16 @@
+import { wrapForEachToGenerator as wrapForEach, runGeneratorSync as runSync } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
 import Namespace from './Namespace__';
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { entity2LogicNamespace } from '../server/entity2LogicNamespace';
 import CallQueryComponent from './CallQueryComponent__';
 //================================================================================
@@ -847,55 +858,51 @@ export class Entity extends BaseNode {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = `export class ${this.name} {\n`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = `export class ${self.name} {\n`;
     code += indent((state?.tabSize || 0) + 1);
-    code += `__name: '${this.getNamespace()}.${this.name}';\n`;
-    this.properties.forEach((property) => {
+    code += `__name: '${self.getNamespace()}.${self.name}';\n`;
+    yield* wrapForEach(self.properties, function* warpForEachGenerator(property) {
       code += indent((state?.tabSize || 0) + 1);
-      code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+      code += yield* property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
       code += ';\n';
     });
-    if (this.indexes && this.indexes.length) {
+    if (self.indexes && self.indexes.length) {
       code += indent((state?.tabSize || 0) + 1);
       code += `__IndexList() {\n`;
       code += `            return [`;
-      this.indexes.forEach((entityIndex) => {
+      yield* wrapForEach(self.indexes, function* warpForEachGenerator(entityIndex) {
         code += indent((state?.tabSize || 0) + 1);
         code += '\n                ';
-        code += entityIndex.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+        code += yield* entityIndex.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
       });
       code += `${indent(state?.tabSize || 0)}\n            ];\n        }\n`;
     }
-
-    const { ns } = this;
-
+    const { ns } = self;
     /**
      * 11个函数的总行数
      * 如果修改这里,可能会影响到dataSource的重命名,  在naslserver中,可能要一起修改
      */
     code += `\n${indent((state?.tabSize || 0) + 1)}static logics = {\n`;
-    ns.logics.forEach((logic) => {
+    yield* wrapForEach(ns.logics, function* warpForEachGenerator(logic) {
       code += indent((state?.tabSize || 0) + 1);
-      code += logic.toEmbeddedTS(shiftState(state, code), 'inObject');
+      code += yield* logic.toEmbeddedTS(shiftState(state, code), 'inObject');
     });
     code += `${indent((state?.tabSize || 0) + 1)}}\n`;
 
     /* 默认值草稿区 */
     code += `${indent((state?.tabSize || 0) + 1)}static playground = () => {\n`;
-    this.properties.forEach((entityProperty) => {
-      if (entityProperty.defaultValue) {
-        entityProperty.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code));
-          code += ';\n';
-        });
+    for (const prop of self.properties) {
+      for (const item of prop?.defaultValue?.playground ?? []) {
+        code += yield* item.toEmbeddedTS(shiftState(state, code));
+        code += ';\n';
       }
-    });
-    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
+    }
 
+    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
     code += `${indent(state?.tabSize || 0)}}\n`;
-
     return code;
   }
 
@@ -913,7 +920,7 @@ export class Entity extends BaseNode {
       this.indexes.forEach((entityIndex) => {
         code += indent(state.tabSize + 1);
         code += '\n                ';
-        code += entityIndex.toEmbeddedTS(shiftState(state, code, { inline: true }));
+        code += runSync(entityIndex.toEmbeddedTS(shiftState(state, code, { inline: true })));
       });
       code += `${indent(state.tabSize)}\n            ];\n        }\n`;
     }
@@ -952,13 +959,13 @@ export class Entity extends BaseNode {
     return ns.logics;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n`;
     code += '    @nasl.annotation.Entity()\n';
 
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       code += '';
       console.log(err);

package/src/concepts/EnumItem__.ts

@@ -1,4 +1,12 @@
-import { TranslatorState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -124,9 +132,10 @@ export class EnumItem extends BaseNode {
   @property()
   expression: undefined;
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    return `static '${this.value}': ${this.enumeration.name}`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    return `static '${self.value}': ${self.enumeration.name}`;
   }
 
   @withSourceMap()

package/src/concepts/Enum__.ts

@@ -1,4 +1,15 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import Namespace from './Namespace__';
 import Identifier from './Identifier__';
 //================================================================================
@@ -310,14 +321,15 @@ export class Enum extends BaseNode {
     return utils.unique(name, this.getEnumItemExistingNames(), undefined, false);
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = `export class ${this.name} extends nasl.core.Enums {\n`;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = `export class ${self.name} extends nasl.core.Enums {\n`;
     // 增加一个单独的标签
-    code += `${indent((state?.tabSize || 0) + 1)}__name: '${this.getNamespace()}.${this.name}';\n`;
-    this.enumItems.forEach((property) => {
+    code += `${indent((state?.tabSize || 0) + 1)}__name: '${self.getNamespace()}.${self.name}';\n`;
+    yield* wrapForEach(self.enumItems, function* warpForEachGenerator(property) {
       code += indent((state?.tabSize || 0) + 1);
-      code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+      code += yield* property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
       code += ';\n';
     });
     code += `
@@ -327,7 +339,6 @@ export class Enum extends BaseNode {
         }
         `;
     code += `${indent(state?.tabSize || 0)}}\n`;
-
     return code;
   }
 
@@ -366,12 +377,12 @@ export class Enum extends BaseNode {
     return `/embedded/${this.app.name}${_path}/enums/${name}.ts`;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace()} {\n`;
 
     const state = createCompilerState(code, { tabSize: 1 });
     try {
-      code += this.toEmbeddedTS(state);
+      code += yield* this.toEmbeddedTS(state);
     } catch (err) {
       code += '';
       console.log(err);

package/src/concepts/ExternalDestination__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import { returnOrigin } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+  createCompilerState,
+} from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import StringLiteral from './StringLiteral__';
 import { BindAttribute, ViewElement, Param } from '..';
@@ -200,17 +209,17 @@ export class ExternalDestination extends LogicItem {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, isHaveKeyWord?: boolean): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), isHaveKeyWord?: boolean): TranslatorGenerator {
+    const self = this;
     let code = '';
-    if (this.link) {
-      code += `${this.link.toEmbeddedTS(shiftState(state, code))};`;
+    if (self.link) {
+      code += `${yield* self.link.toEmbeddedTS(shiftState(state, code))};`;
     } else {
       code += '__IDENTIFIER__;';
     }
     // code += this.anchor?.expression?.toEmbeddedTS(shiftState(state, code)) + ';' || '';
-    code += this.anchor?.toEmbeddedTS(shiftState(state, code), true) || '';
-
+    code += yield* self.anchor?.toEmbeddedTS(shiftState(state, code), true) ?? returnOrigin('');
     return code;
   }
 

package/src/concepts/ForEachStatement__.ts

@@ -1,4 +1,14 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import TypeAnnotation from './TypeAnnotation__';
 import Identifier from './Identifier__';
 import MemberExpression from './MemberExpression__';
@@ -564,29 +574,30 @@ export class ForEachStatement extends LogicItem {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    code += this.each
-      ? this.each.toEmbeddedTS(
+    code += self.each
+      ? yield* self.each.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: 0,
           }),
         )
       : '__IDENTIFIER__';
-    if (['NewList', 'NewMap'].includes(this.each?.concept)) code += '\n';
+    if (['NewList', 'NewMap'].includes(self.each?.concept)) code += '\n';
     code += '.__slice(';
-    code += this.start ? this.start.toEmbeddedTS(shiftState(state, code)) : '__IDENTIFIER__';
+    code += self.start ? yield* self.start.toEmbeddedTS(shiftState(state, code)) : '__IDENTIFIER__';
     code += ', ';
-    code += this.end ? this.end.toEmbeddedTS(shiftState(state, code)) : 'null';
+    code += self.end ? yield* self.end.toEmbeddedTS(shiftState(state, code)) : 'null';
     code += ').__forEach((';
-    code += this.item ? this.item.toEmbeddedTS(shiftState(state, code), true) : '__IDENTIFIER__';
+    code += self.item ? yield* self.item.toEmbeddedTS(shiftState(state, code), true) : '__IDENTIFIER__';
     code += ', ';
-    code += this.index ? this.index.toEmbeddedTS(shiftState(state, code), true) : '__IDENTIFIER__';
+    code += self.index ? yield* self.index.toEmbeddedTS(shiftState(state, code), true) : '__IDENTIFIER__';
     code += ') => {\n';
-    if (Array.isArray(this.body)) {
-      this.body.forEach((logicItem) => {
-        code += `${logicItem.toEmbeddedTS(
+    if (Array.isArray(self.body)) {
+      yield* wrapForEach(self.body, function* warpForEachGenerator(logicItem) {
+        code += `${yield* logicItem.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: (state?.tabSize || 0) + 1,
           }),
@@ -594,7 +605,6 @@ export class ForEachStatement extends LogicItem {
       });
     }
     code += `${indent(state?.tabSize || 0)}})\n`;
-
     return code;
   }