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

package/src/concepts/Process__.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 { genLaunchProcess, syncMemberExpression } from '../server/getProcesses';
 import { process2LogicNamespace } from '../server/process2LogicNamespace';
 import Namespace from './Namespace__';
@@ -977,9 +988,12 @@ export class Process 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;
@@ -1030,9 +1044,12 @@ export class Process 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;
@@ -1083,9 +1100,12 @@ export class Process 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;
@@ -1136,9 +1156,12 @@ export class Process 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;
@@ -1189,9 +1212,12 @@ export class Process 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;
@@ -1322,57 +1348,52 @@ 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 += logic.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }));
+    logic.parentNode = self;
+    code += yield* logic.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 2 }));
     code += `${tab1}}\n`;
-
-    this.params.forEach((property) => {
+    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) => {
+    yield* wrapForEach(self.returns, 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.constants.forEach((property) => {
+    yield* wrapForEach(self.constants, 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';
     });
-
     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 += `${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,
           }),
@@ -1384,12 +1405,12 @@ export class Process extends BaseNode {
     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 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -108,9 +116,12 @@ export class QueryAggregateExpression extends LogicItem {
         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;
@@ -129,8 +140,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 自动生成，请不手动修改！
@@ -134,10 +142,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 自动生成，请不手动修改！
@@ -213,9 +223,12 @@ export class QueryFromExpression extends LogicItem {
         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;
@@ -254,14 +267,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`;

package/src/concepts/QueryGroupByExpression__.ts

@@ -1,4 +1,11 @@
-import { withSourceMap } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  withSourceMap,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+  createCompilerState,
+} from '../translator';
 import type CallQueryComponent from './CallQueryComponent__';
 import type QueryFieldExpression from './QueryFieldExpression__';
 
@@ -111,9 +118,12 @@ export class QueryGroupByExpression extends LogicItem {
         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;
@@ -141,14 +151,15 @@ export class QueryGroupByExpression extends LogicItem {
     (this.groupElement as QueryFieldExpression).setPropertyName(name);
   }
 
-  @withSourceMap()
-  toEmbeddedTS(): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     // 判断老应用
-    if ((this.parentNode as CallQueryComponent).isAutoInfer()) {
+    if ((self.parentNode as CallQueryComponent).isAutoInfer()) {
       // 2.11版本后 分组使用别名
-      return `__${(this.groupElement as QueryFieldExpression).asName || 'EMPTY_GROUP_BY_ALIAS__'}`;
+      return `__${(self.groupElement as QueryFieldExpression).asName || 'EMPTY_GROUP_BY_ALIAS__'}`;
     }
-    return (this.groupElement as QueryFieldExpression).toEmbeddedTS();
+    return yield* (self.groupElement as QueryFieldExpression).toEmbeddedTS();
   }
 
   //================================================================================

package/src/concepts/QueryJoinExpression__.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 CallQueryComponent from './CallQueryComponent__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -424,9 +434,12 @@ export class QueryJoinExpression extends LogicItem {
         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;
@@ -466,22 +479,23 @@ export class QueryJoinExpression extends LogicItem {
     });
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
     let code = '';
-    code += `.${this.joinType}_JOIN(new nasl.langUtil.Collection<[${this.entityKey}]>())\n`;
-    if (this.onExpressions.length > 0) {
+    code += `.${self.joinType}_JOIN(new nasl.langUtil.Collection<[${self.entityKey}]>())\n`;
+    if (self.onExpressions.length > 0) {
       code += `${indent(state?.tabSize || 0)}.ON(() => `;
-      this.onExpressions.forEach((expression, index) => {
+      yield* wrapForEach(self.onExpressions, function* warpForEachGenerator(expression, index) {
         if (index > 0) code += `\n${indent((state?.tabSize || 0) + 1)}&& `;
-        code += expression.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
+        code += yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
       });
-      if (this.onExpressions.length > 1) code += `\n${indent(state?.tabSize || 0)}`;
+      if (self.onExpressions.length > 1) code += `\n${indent(state?.tabSize || 0)}`;
       code += ')\n';
     }
-    if (this.joinParts.length > 0) {
-      this.joinParts.forEach((joinPart) => {
-        code += joinPart.toEmbeddedTS(shiftState(state, code));
+    if (self.joinParts.length > 0) {
+      yield* wrapForEach(self.joinParts, function* warpForEachGenerator(joinPart) {
+        code += yield* joinPart.toEmbeddedTS(shiftState(state, code));
       });
     }
     return code;

package/src/concepts/QueryLimitExpression__.ts

@@ -1,4 +1,13 @@
-import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
+import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
+import {
+  TranslatorState,
+  shiftState,
+  withSourceMap,
+  createCompilerState,
+  withSourceMapGenerator,
+  withGenerator,
+  TranslatorGenerator,
+} from '../translator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -155,9 +164,12 @@ export class QueryLimitExpression extends LogicItem {
         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;
@@ -168,12 +180,13 @@ export class QueryLimitExpression extends LogicItem {
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    const { pageElement, pageSizeElement } = this;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const { pageElement, pageSizeElement } = self;
     let code = '[';
-    code += `${pageElement.toEmbeddedTS(shiftState(state, code))}, `;
-    code += `${pageSizeElement.toEmbeddedTS(shiftState(state, code))}]`;
+    code += `${yield* pageElement.toEmbeddedTS(shiftState(state, code))}, `;
+    code += `${yield* pageSizeElement.toEmbeddedTS(shiftState(state, code))}]`;
     return code;
   }
 

package/src/concepts/QueryOrderByExpression__.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';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -155,9 +165,12 @@ export class QueryOrderByExpression extends LogicItem {
         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;
@@ -182,12 +195,13 @@ export class QueryOrderByExpression extends LogicItem {
     };
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    const { orderElement, order } = this;
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    const { orderElement, order } = self;
     let code = '[';
-    code += `${orderElement.toEmbeddedTS(shiftState(state, code))}, `;
-    code += `${order.toEmbeddedTS(shiftState(state, code))}]`;
+    code += `${yield* orderElement.toEmbeddedTS(shiftState(state, code))}, `;
+    code += `${yield* order.toEmbeddedTS(shiftState(state, code))}]`;
     return code;
   }
 

package/src/concepts/QuerySelectExpression__.ts

@@ -496,9 +496,12 @@ export class QuerySelectExpression extends LogicItem {
         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/Return__.ts

@@ -1,5 +1,14 @@
+import { wrapForEachToGenerator as wrapForEach } 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 EntityProperty from './EntityProperty__';
 import StructureProperty from './StructureProperty__';
 
@@ -233,9 +242,12 @@ export class Return 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;
@@ -313,18 +325,19 @@ export class Return extends BaseNode {
     return code;
   }
 
-  @withSourceMap()
-  toEmbeddedTS(state = createCompilerState()): string {
-    let code = this.name || '__return';
-    if (this.typeAnnotation) {
+  @withSourceMapGenerator
+  *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = self.name || '__return';
+    if (self.typeAnnotation) {
       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}']`;
         }
       }
     }
@@ -356,12 +369,13 @@ export class Return extends BaseNode {
     return this.typeAnnotation?.typeNamespace?.endsWith('.enums');
   }
 
-  @withSourceMap()
-  toEmbeddedTSInProcess(state?: TranslatorState): string {
-    let code = this.name;
-    if (this.typeAnnotation) {
+  @withSourceMapGenerator
+  *toEmbeddedTSInProcess(state = createCompilerState()): TranslatorGenerator {
+    const self = this;
+    let code = self.name;
+    if (self.typeAnnotation) {
       code += ': undefined as ';
-      code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
     }
     // if (this.defaultValue) {
     //     code += `: ${this.defaultValue}`;