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

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,
@@ -1761,8 +1771,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);
@@ -1772,78 +1783,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,
@@ -1854,29 +1862,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`;
@@ -1885,33 +1893,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`;
@@ -1923,7 +1928,6 @@ export class ProcessElement extends BaseNode {
       }
       code += '},\n';
     }
-
     if (!isFromStartNode(this)) {
       code += '__outOfProcess__,';
     }
@@ -1934,40 +1938,25 @@ export class ProcessElement extends BaseNode {
     if (this.returns.length) {
       code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是returns的默认值草稿------ */\n`;
     }
-    this.returns.forEach((return_) => {
-      if (return_.defaultValue) {
-        return_.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-          code += ';\n';
-        });
-      }
-    });
 
-    if (this.variables.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是variable的默认值草稿------ */\n`;
-    }
-    this.variables.forEach((variable) => {
-      if (variable.defaultValue) {
-        variable.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-          code += ';\n';
-        });
+    function* setPlaygroundCode(arr: Variable[] | Constant[] | Return[], name: string) {
+      if (arr.length) {
+        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
       }
-    });
 
-    if (this.constants.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是constant的默认值草稿------ */\n`;
-    }
-    this.constants.forEach((constant) => {
-      if (constant.defaultValue) {
-        constant.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      for (const item1 of arr) {
+        for (const item of item1.defaultValue?.playground ?? []) {
+          code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
           code += ';\n';
-        });
+        }
       }
-    });
-    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
+    }
 
+    yield* setPlaygroundCode(this.variables, 'variables');
+    yield* setPlaygroundCode(this.returns, 'returns');
+    yield* setPlaygroundCode(this.constants, 'constants');
+
+    code += `${indent((state?.tabSize || 0) + 1)}}\n`;
     code += `${tab0}\n},`;
     // let code = '';
     // this.variables.forEach((property) => {
@@ -1975,7 +1964,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';
 
 //================================================================================
@@ -75,18 +83,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 = '';
-
     const afterLinkValues = getFlowAfterElements(this.processElement).map((l) => l.flowValue);
     code += `return () => `;
-    if (this.flowRef) {
+    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 自动生成，请不手动修改！
@@ -76,18 +84,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);
+    const afterLinkValues = getFlowAfterElements(self.processElement).map((l) => l.flowValue);
     code += `return () => `;
-    if (this.flowRefs.length > 0) {
+    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 {

package/src/concepts/Process__.ts

@@ -1,4 +1,15 @@
-import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach, returnOrigin } from '../utils/time-slicing';
+import type { EmbeddedTSFileGenerator } from '../utils';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  indent,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 import { genLaunchProcess, syncMemberExpression } from '../server/getProcesses';
 import { process2LogicNamespace } from '../server/process2LogicNamespace';
 import Namespace from './Namespace__';
@@ -1360,68 +1371,65 @@ export class Process extends BaseNode {
     return `let ${userTask.name} = elements.${userTask.name};`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state?: TranslatorState): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     // 获取虚拟logic的参数和内容
     // 用作展示和tots查找引用
-    this.getElementLogicRoot();
-
-    let code = `export namespace ${this.name} {\n`;
+    self.getElementLogicRoot();
+    let code = `export namespace ${self.name} {\n`;
     const tab0 = indent(state?.tabSize || 0);
     const tab1 = indent((state?.tabSize || 0) + 1);
     const tab2 = indent((state?.tabSize || 0) + 2);
     const tab3 = indent((state?.tabSize || 0) + 3);
     // code += `${tab1}namespace variables{\n`;
-
     code += `${tab1}let __ProcessIdentification__: string;\n`;
     code += `${tab1}export namespace logics {\n`;
     const logic = genLaunchProcess(this);
     // sourceMap 映射
     logic.parentNode = this;
     code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
-    code += logic.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }), null, true);
+    code += yield* logic.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }), null, true);
     code += `${tab1}}\n`;
 
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
-    const IDENTIFIERMAP = new Set();
-    this.params.forEach((property) => {
+    const IDENTIFIERMAP = new Set<Constant | Return>();
+    yield* wrapForEach(self.params, function* warpForEachGenerator(property) {
       code += `${tab1}export let `;
-      code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* property.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
     });
 
-    this.returns.forEach((property) => {
-      const ts = property.defaultValue?.toEmbeddedTS();
+    yield* wrapForEach(self.returns, function* warpForEachGenerator(property) {
+      const ts = yield* property.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
       if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
         IDENTIFIERMAP.add(property);
       }
       code += `${tab1}export let `;
-      code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* property.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
     });
-    this.constants.forEach((property) => {
-      const ts = property.defaultValue?.toEmbeddedTS();
+    yield* wrapForEach(self.constants, function* warpForEachGenerator(property) {
+      const ts = yield* property.defaultValue?.toEmbeddedTS?.() ?? returnOrigin('');
       if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
         IDENTIFIERMAP.add(property);
       }
       code += `${tab1}export let `;
-      code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
+      code += yield* property.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += ';\n';
     });
-
     code += `${tab1}export const elements = {\n`;
-
-    this.elements.forEach((ele) => {
+    yield* wrapForEach(self.elements, function* warpForEachGenerator(ele) {
       code += '\n';
       if (ele.type !== 'EndNoneEvent' && ele.type !== 'SequenceFlow') {
-        code += ele.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        code += yield* ele.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
       }
     });
     code += `\n${tab1}}\n`;
     // 流程逻辑提示错误信息
-    if (Array.isArray(this.bindEvents)) {
-      this.bindEvents.forEach((event) => {
-        code += event.toEmbeddedTS(
+    if (Array.isArray(self.bindEvents)) {
+      yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(event) {
+        code += yield* event.toEmbeddedTS(
           shiftState(state, code, {
             tabSize: state?.tabSize || 0,
           }),
@@ -1434,60 +1442,41 @@ export class Process extends BaseNode {
     code += `${tab1}const playground = () => {\n`;
 
     // 参数的默认值是__IDENTIFIER__或者__IDENTIFIER__()时不赋默认值，但是需要ts翻译出来进行报错校验
-    IDENTIFIERMAP.forEach((node: Variable | Return) => {
-      code += node.defaultValue.expression.toEmbeddedTS(shiftState(state, code, { inline: true }));
+    for (const node of IDENTIFIERMAP) {
+      code += yield* node.defaultValue.expression.toEmbeddedTS(shiftState(state, code, { inline: true }));
       code += '; ';
-    });
+    }
     code += '\n';
-
     code += `${tab1}return\n`;
-    if (this.returns.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是returns的默认值草稿------ */\n`;
-    }
-    this.returns.forEach((return_) => {
-      if (return_.defaultValue) {
-        return_.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-          code += ';\n';
-        });
-      }
-    });
 
-    if (this.params.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是params的默认值草稿------ */\n`;
-    }
-    this.params.forEach((param) => {
-      if (param.defaultValue) {
-        param.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-          code += ';\n';
-        });
+    function* setPlaygroundCode(arr: Constant[] | Param[] | Return[], name: string) {
+      if (arr.length) {
+        code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是 ${name} 的默认值草稿------ */\n`;
       }
-    });
 
-    if (this.constants.length) {
-      code += `${indent((state?.tabSize || 0) + 1)}/* -----以下是constant的默认值草稿------ */\n`;
-    }
-    this.constants.forEach((constant) => {
-      if (constant.defaultValue) {
-        constant.defaultValue.playground?.forEach((item) => {
-          code += item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      for (const item1 of arr) {
+        for (const item of item1.defaultValue?.playground ?? []) {
+          code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
           code += ';\n';
-        });
+        }
       }
-    });
-    code += `${tab1}}\n`;
+    }
 
+    yield* setPlaygroundCode(self.returns, 'returns');
+    yield* setPlaygroundCode(self.params, 'params');
+    yield* setPlaygroundCode(self.constants, 'constants');
+
+    code += `${tab1}}\n`;
     code += `}\n`;
     return code;
   }
 
-  toEmbeddedTSFile() {
+  *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
     let code = `namespace ${this.getNamespace('processes')} {\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/QueryAggregateExpression__.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 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -137,8 +145,8 @@ export class QueryAggregateExpression extends LogicItem {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     // const { aggregateName, aggregateParam, asName } = this;
     // let code = '';
     // if (aggregateName && aggregateParam) {

package/src/concepts/QueryFieldExpression__.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';
 import CallQueryComponent from './CallQueryComponent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -137,10 +145,11 @@ export class QueryFieldExpression extends LogicItem {
     return `${entityAsName}.${propertyName}`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    const { entityAsName, propertyName, isDotStar } = this;
-    const callQueryComponent = this.getAncestor('CallQueryComponent') as CallQueryComponent;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const { entityAsName, propertyName, isDotStar } = self;
+    const callQueryComponent = self.getAncestor('CallQueryComponent') as CallQueryComponent;
     if (callQueryComponent) {
       const entityNamespace = callQueryComponent?.from?.entityNamespace;
       if (entityNamespace && entityAsName && propertyName) {

package/src/concepts/QueryFromExpression__.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 type CallQueryComponent from './CallQueryComponent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -264,14 +274,15 @@ export class QueryFromExpression extends LogicItem {
     return `${this.entityNamespace}.${this.entityName}`;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    code += `nasl.langUtil.FROM(new nasl.langUtil.Collection<[${this.entityKey}]>()`;
-    if (this.joinParts.length) {
+    code += `nasl.langUtil.FROM(new nasl.langUtil.Collection<[${self.entityKey}]>()`;
+    if (self.joinParts.length) {
       code += '\n';
-      this.joinParts.forEach((joinPart) => {
-        code += joinPart.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+      yield* wrapForEach(self.joinParts, function* warpForEachGenerator(joinPart) {
+        code += yield* joinPart.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
       });
     }
     code += `${indent(state?.tabSize || 0)})\n`;