@lcap/nasl 3.3.3-beta.5 → 3.3.3-beta.7

package/src/concepts/Param__.ts

@@ -1,5 +1,14 @@
+import { wrapForEachToGenerator as wrapForEach, runGeneratorSync as runSync } from '../utils/time-slicing';
 import { dataTypesMap } from './basics/types';
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import LogicItem from './LogicItem__';
 import EntityProperty from './EntityProperty__';
 import Structure from './Structure__';
@@ -12,7 +21,7 @@ function tryJSONParse(str: string) {
 
   try {
     result = JSON.parse(str);
-  } catch (e) {}
+  } catch (e) { }
 
   return result;
 }
@@ -256,9 +265,12 @@ export class Param extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -281,13 +293,13 @@ export class Param extends BaseNode {
   @property()
   useComponent: {
     type:
-      | 's-member-identifier-select'
-      | 's-enum-select'
-      | 's-schema-select'
-      | 's-datatype-select'
-      | 's-config-select'
-      | 's-options-select'
-      | 's-bidirectional-bind-switch';
+    | 's-member-identifier-select'
+    | 's-enum-select'
+    | 's-schema-select'
+    | 's-datatype-select'
+    | 's-config-select'
+    | 's-options-select'
+    | 's-bidirectional-bind-switch';
     attrs?: any;
   } = undefined;
 
@@ -367,15 +379,16 @@ export class Param extends BaseNode {
     return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState, dontType?: boolean): string {
-    let code = this.name;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState(), dontType?: boolean): TranslatorGenerator {
+    const self = this;
+    let code = self.name;
     // 回调函数类的参数
-    if (this?.typeAnnotation?.typeKind === 'function') {
+    if (self?.typeAnnotation?.typeKind === 'function') {
       code += ':{(';
-      const paramTypes = this.typeAnnotation?.typeArguments || [];
-      paramTypes.forEach((type, index) => {
-        code += `type${index + 1}:${type.toEmbeddedTS(shiftState(state, code))}`;
+      const paramTypes = self.typeAnnotation?.typeArguments || [];
+      yield* wrapForEach(paramTypes, function* warpForEachGenerator(type, index) {
+        code += `type${index + 1}:${yield* type.toEmbeddedTS(shiftState(state, code))}`;
         if (index !== paramTypes.length - 1) {
           code += ',';
         } else {
@@ -383,27 +396,26 @@ export class Param extends BaseNode {
         }
       });
       code += ':';
-      const returnTypes = this.typeAnnotation?.returnType || [];
-      returnTypes.forEach((type) => {
-        code += type.toEmbeddedTS(shiftState(state, code));
+      const returnTypes = self.typeAnnotation?.returnType || [];
+      yield* wrapForEach(returnTypes, function* warpForEachGenerator(type) {
+        code += yield* type.toEmbeddedTS(shiftState(state, code));
       });
       code += '}';
       return code;
     }
-
-    if (this.defaultExpression instanceof Function || this.defaultExpression instanceof AnonymousFunction) {
-      code += this.required ? ': ' : '?: ';
-      code += this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
-    } else if (!dontType && this.typeAnnotation) {
+    if (self.defaultExpression instanceof Function || self.defaultExpression instanceof AnonymousFunction) {
+      code += self.required ? ': ' : '?: ';
+      code += yield* self.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
+    } else if (!dontType && self.typeAnnotation) {
       // TODO
       code += ': ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
       // toTS暂时只需要翻译引用数据类型的，因为值都是字符串
       // 就不在这里赋值了，这里单纯就为了快速查找
       // 并且屏蔽了一些异常的错误
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
-        if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+      if (self.typeAnnotation?.typeKind !== 'primitive' && self.defaultValue) {
+        if (self.isEnum()) {
+          code += `= ${self.typeAnnotation.typeKey}['${self.defaultValue}']`;
         }
       }
     }
@@ -436,7 +448,7 @@ export class Param extends BaseNode {
 
     if (this.defaultExpression instanceof Function || this.defaultExpression instanceof AnonymousFunction) {
       code += this.required ? ': ' : '?: ';
-      code += this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
+      code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
     } else if (!dontType && this.typeAnnotation) {
       code += ': ';
       code += this.typeAnnotation.toNaturalTS(shiftState(state, code));
@@ -449,8 +461,8 @@ export class Param extends BaseNode {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedNameTS(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedNameTS(state?: TranslatorState) {
     return `${this.name}`;
   }
 
@@ -569,3 +581,5 @@ export default Param;
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
 //================================================================================
+
+

package/src/concepts/ProcessComponent__.ts

@@ -459,9 +459,12 @@ export class ProcessComponent extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -512,9 +515,12 @@ export class ProcessComponent extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;

package/src/concepts/ProcessElement__.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 {
   genUserTaskLogic,
   getPreviousTask,
@@ -1243,9 +1253,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1296,9 +1309,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1349,9 +1365,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1402,9 +1421,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1455,9 +1477,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1508,9 +1533,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1561,9 +1589,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1614,9 +1645,12 @@ export class ProcessElement extends BaseNode {
         const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
         ~index && (this as any)[parentKey].splice(index, 1);
         params.index = index;
-      } else if ((t as any)[parentKey] === n) {
-        params.index = 0;
-        (this as any)[parentKey] = undefined;
+      } else {
+        const q = (t as any)[parentKey];
+        if ((q.__v_raw || q) === n) {
+          params.index = 0;
+          (this as any)[parentKey] = undefined;
+        }
       }
     }
     return params;
@@ -1706,8 +1740,9 @@ export class ProcessElement extends BaseNode {
     return uniqueName;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     // this.syncLogic();
     const tab0 = indent(state?.tabSize || 0);
     const tab1 = indent((state?.tabSize || 0) + 1);
@@ -1717,78 +1752,75 @@ export class ProcessElement extends BaseNode {
     const tab6 = indent((state?.tabSize || 0) + 5);
     const constantsArr: any = [];
     const returnsArr: any = [];
-    let code = `${this.name}: {\n`;
-    this.variables.forEach((property) => {
+    let code = `${self.name}: {\n`;
+    yield* wrapForEach(self.variables, function* warpForEachGenerator(property) {
       code += `${tab1}`;
-      code += `${property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
+      code += `${yield* property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true }))},\n`;
     });
-    this.returns.forEach((property, index) => {
+    yield* wrapForEach(self.returns, function* warpForEachGenerator(property, index) {
       code += `${tab1}`;
-      returnsArr.push(property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true })));
+      returnsArr.push(yield* property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true })));
       code += `${returnsArr[index]},\n`;
     });
-    this.constants.forEach((property, index) => {
+    yield* wrapForEach(self.constants, function* warpForEachGenerator(property, index) {
       code += `${tab1}`;
-      constantsArr.push(property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true })));
+      constantsArr.push(yield* property.toEmbeddedTSInProcess(shiftState(state, code, { inline: true })));
       code += `${constantsArr[index]},\n`;
     });
     const afterLinks = getFlowAfterElements(this);
     const beforeLinks = getFlowBeforeElements(this);
     if (
-      this.isUserTask ||
-      this.type === 'ExclusiveGateway' ||
-      this.type === 'AutoTask' ||
-      this.type === 'InclusiveGateway'
+      self.isUserTask ||
+      self.type === 'ExclusiveGateway' ||
+      self.type === 'AutoTask' ||
+      self.type === 'InclusiveGateway'
     ) {
       const prevTasks = getPreviousTask(this);
       let prevCode = `${tab4}__ProcessIdentification__;\n`;
-      prevCode += `${tab4}const ${this.process.name} = {\n`;
-      const processName = this.process.name;
-      this.process.params.forEach((p) => {
+      prevCode += `${tab4}const ${self.process.name} = {\n`;
+      const processName = self.process.name;
+      yield* wrapForEach(self.process.params, function* warpForEachGenerator(p) {
         prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
       });
-      this.process.returns.forEach((p) => {
+      yield* wrapForEach(self.process.returns, function* warpForEachGenerator(p) {
         prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
       });
-      this.process.constants.forEach((p) => {
+      yield* wrapForEach(self.process.constants, function* warpForEachGenerator(p) {
         prevCode += `${tab5}${p.name}: app.processes.${processName}.${p.name},\n`;
       });
       // prevCode += `${tab4}elements: {\n`
       prevCode += prevTasks.map((t) => `${tab5}${t.name}: elements.${t.name},\n`).join(``);
-
       // prevCode += `${tab4}}\n`
-
-      if (this.isUserTask) {
+      if (self.isUserTask) {
         // 任务完成时可以拿到输出参数，prevCodeClose包含输出参数
-        let prevCodeClose = `${prevCode}\n${tab5}${this.name}: { \n`;
-        this.constants.forEach((c, index) => {
+        let prevCodeClose = `${prevCode}\n${tab5}${self.name}: { \n`;
+        yield* wrapForEach(self.constants, function* warpForEachGenerator(c, index) {
           prevCodeClose += tab6;
           prevCodeClose += constantsArr[index];
           prevCodeClose += ',';
         });
-        this.returns.forEach((c, index) => {
+        yield* wrapForEach(self.returns, function* warpForEachGenerator(c, index) {
           prevCodeClose += `\n${tab6}`;
           prevCodeClose += returnsArr[index];
           prevCodeClose += ',';
         });
         prevCodeClose += ` \n${tab5}}\n`;
         prevCodeClose += `${tab4}}\n`;
-
-        prevCode += `\n${tab5}${this.name}: { \n`;
-        this.constants.forEach((c, index) => {
+        prevCode += `\n${tab5}${self.name}: { \n`;
+        yield* wrapForEach(self.constants, function* warpForEachGenerator(c, index) {
           prevCode += `${tab6}`;
           prevCode += constantsArr[index];
           prevCode += ',';
         });
         prevCode += ` \n${tab5}}\n`;
         prevCode += `${tab4}}\n`;
-        if (Array.isArray(this.bindEvents)) {
-          this.bindEvents.forEach((bindEvent) => {
+        if (Array.isArray(self.bindEvents)) {
+          yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(bindEvent) {
             // 任务完成时可以拿到输出参数
             const currentPrevCode = bindEvent.name === 'OnClose' ? prevCodeClose : prevCode;
             code += `${tab1}${bindEvent.name}: () => [\n`;
-            bindEvent.logics.forEach((logic) => {
-              code += `${logic.toEmbeddedTSInProcess(
+            yield* wrapForEach(bindEvent.logics, function* warpForEachGenerator(logic) {
+              code += `${yield* logic.toEmbeddedTSInProcess(
                 shiftState(state, code, { tabSize: 0 }),
                 currentPrevCode,
                 true,
@@ -1799,29 +1831,29 @@ export class ProcessElement extends BaseNode {
           });
         }
         code += `${tab1}logics: {\n`;
-        let destinationAttrs = this.bindAttrs.filter(
+        let destinationAttrs = self.bindAttrs.filter(
           (attr) => attr.name === 'destination' || attr.name.startsWith('destination-'),
         );
         const destinationAllEmpty =
           destinationAttrs.length && destinationAttrs.every((attr) => !attr.destination.viewNamespace);
         if (destinationAllEmpty) {
-          code += `${destinationAttrs[0].destination.toEmbeddedTSInProcess(
+          code += `${yield* destinationAttrs[0].destination.toEmbeddedTSInProcess(
             shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }),
             prevCode,
           )},\n`;
         } else {
           destinationAttrs = destinationAttrs.filter((attr) => attr.destination.viewNamespace);
-          destinationAttrs.forEach((attr) => {
-            code += `${attr.destination.toEmbeddedTSInProcess(
+          yield* wrapForEach(destinationAttrs, function* warpForEachGenerator(attr) {
+            code += `${yield* attr.destination.toEmbeddedTSInProcess(
               shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }),
               prevCode,
             )},\n`;
           });
         }
-        this.bindAttrs.forEach((attr) => {
+        yield* wrapForEach(self.bindAttrs, function* warpForEachGenerator(attr) {
           if (attr.name === 'assignee') {
             code += `${tab3}assignee: function(): string[] {\n`;
-            code += `${attr.assignee.toEmbeddedTSInProcess(
+            code += `${yield* attr.assignee.toEmbeddedTSInProcess(
               shiftState(state, code, { tabSize: state.tabSize + 3 }),
               prevCode,
             )}\n`;
@@ -1830,33 +1862,30 @@ export class ProcessElement extends BaseNode {
         });
         const logics = genUserTaskLogic(this);
         // sourceMap 映射
-
-        logics.forEach((logic) => {
-          logic.parentNode = this.process;
-
-          code += logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }));
+        yield* wrapForEach(logics, function* warpForEachGenerator(logic) {
+          logic.parentNode = self.process;
+          code += yield* logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }));
           code += ',\n';
         });
         code += `${tab1}},\n`;
       }
-
-      if (['ExclusiveGateway', 'AutoTask', 'InclusiveGateway'].includes(this.type)) {
-        prevCode += `\n${tab5}${this.name}:  elements.${this.name},\n`;
+      if (['ExclusiveGateway', 'AutoTask', 'InclusiveGateway'].includes(self.type)) {
+        prevCode += `\n${tab5}${self.name}:  elements.${self.name},\n`;
         prevCode += `${tab3}}\n`;
         code += `${tab1}logic: `;
-        code += `${this.logic.toEmbeddedTSInProcess(
+        code += `${yield* self.logic.toEmbeddedTSInProcess(
           shiftState(state, code, { tabSize: (state?.tabSize || 0) + 3 }),
           prevCode,
           true,
         )},\n`;
       }
     }
-    if (this.isUserTask || this.type === 'AutoTask' || this.type === 'StartNoneEvent') {
+    if (self.isUserTask || self.type === 'AutoTask' || self.type === 'StartNoneEvent') {
       code += '_constraints: function() {\n';
       code += `${tab1}nasl.process.oneOutcomeFlow(${afterLinks.map((l) => `'${l.name}'`).join(',')})\n`;
       code += '},\n';
     }
-    if (['ExclusiveGateway', 'ParallelGateway', 'InclusiveGateway'].includes(this.type)) {
+    if (['ExclusiveGateway', 'ParallelGateway', 'InclusiveGateway'].includes(self.type)) {
       code += '_constraints: function() {\n';
       code += `${tab1}nasl.process.atLeastOneOutcomeFlow(${afterLinks.map((l) => `'${l.name}'`).join(',')})\n`;
       code += `${tab1}nasl.process.atLeastOneOutcomeFlow(${beforeLinks.map((l) => `'${l.name}'`).join(',')})\n`;
@@ -1868,11 +1897,9 @@ export class ProcessElement extends BaseNode {
       }
       code += '},\n';
     }
-
     if (!isFromStartNode(this)) {
       code += '__outOfProcess__,';
     }
-
     code += `${tab0}\n},`;
     // let code = '';
     // this.variables.forEach((property) => {
@@ -1880,7 +1907,6 @@ export class ProcessElement extends BaseNode {
     //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
     //     code += ';\n';
     // });
-
     // this.returns.forEach((property) => {
     //     code += `${tab0}export let `;
     //     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));

package/src/concepts/ProcessOutcome__.ts

@@ -1,4 +1,12 @@
-import { indent, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  indent,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { getFlowAfterElements } from '../server/getProcesses';
 
 //================================================================================
@@ -72,18 +80,18 @@ export class ProcessOutcome extends LogicItem {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const tab0 = indent(state?.tabSize || 0);
     const tab1 = indent((state?.tabSize || 0) + 1);
-    let code = ''
-
+    let code = '';
     const afterLinkValues = getFlowAfterElements(this.processElement).map((l) => l.flowValue);
-    code += `return () => `
-    if (this.flowRef) {
+    code += `return () => `;
+    if (self.flowRef) {
       code += `{\n`;
       code += `${tab1}let afterLinks: ${afterLinkValues.map((item) => `'${item}'`).join(' | ')};\n`;
-      code += `${tab1}let outCome: '${this.flowRef}';\n`;
+      code += `${tab1}let outCome: '${self.flowRef}';\n`;
       code += `${tab1}nasl.core.assign(afterLinks, outCome);\n`;
       code += `${tab0}};\n`;
     } else {

package/src/concepts/ProcessOutcomes__.ts

@@ -1,4 +1,12 @@
-import { indent, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  indent,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { getFlowAfterElements } from '../server/getProcesses';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -70,18 +78,18 @@ export class ProcessOutcomes extends LogicItem {
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     const tab0 = indent(state?.tabSize || 0);
     const tab1 = indent((state?.tabSize || 0) + 1);
-    let code = ''
-
-    const afterLinkValues = getFlowAfterElements(this.processElement).map((l) => l.flowValue);
-    code += `return () => `
-    if (this.flowRefs.length > 0) {
+    let code = '';
+    const afterLinkValues = getFlowAfterElements(self.processElement).map((l) => l.flowValue);
+    code += `return () => `;
+    if (self.flowRefs.length > 0) {
       code += `{\n`;
       code += `${tab1}let afterLinks: ${afterLinkValues.map((item) => `'${item}'`).join(' | ')};\n`;
-      code += `${tab1}let outComes: ${this.flowRefs.map((item) => `'${item}'`).join(' | ')};\n`;
+      code += `${tab1}let outComes: ${self.flowRefs.map((item) => `'${item}'`).join(' | ')};\n`;
       code += `${tab1}nasl.core.assign(afterLinks, outComes);\n`;
       code += `${tab0}};\n`;
     } else {