@lcap/nasl 3.5.0-beta.3 → 3.5.0-beta.5

package/src/concepts/Identifier__.ts

@@ -274,6 +274,25 @@ export class Identifier extends LogicItem {
     return self.namespace ? `${self.namespace}.${self.name}` : self.name || '__IDENTIFIER__';
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    if (this.name === undefined)
+      console.log(this.toJSON(), this.parentNode.toJSON(), this.nodePath)
+
+    if (this.namespace) {
+      const namespace = this.namespace.replace(/^app\.frontendTypes\.(.+?\.)variables\.$/, '$1');
+      const name = Number.isInteger(Number(this.name)) ? `[${this.name}]` : this.name.includes('-') ? `['${this.name}']` : `.${this.name}`;
+      return `${namespace}${name}`;
+    } else {
+      return this.name;
+    }
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    return this.namespace ? `${this.namespace}.${this.name}` : this.name;
+  }
+
   // 方便快速取值
   getValue() {
     // 实体逻辑 deleteBy/updateBy 的 filter 参数的回调函数的参数：_

package/src/concepts/JSBlock__.ts

@@ -97,7 +97,7 @@ export class JSBlock extends LogicItem {
 
   @withSourceMap()
   toNaturalTS(): string {
-    return ``;
+    return '__STATEMENT__';
   }
 
   toBrief(): string {

package/src/concepts/LogicItem__.ts

@@ -4,6 +4,7 @@ import {
   createCompilerState,
   withSourceMapGenerator,
   withGenerator,
+  withSourceMap,
   TranslatorGenerator,
 } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
@@ -342,8 +343,19 @@ export class LogicItem extends BaseNode {
    * @param state 编译状态
    * @returns 生成的代码
    */
+  // @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
-    return runSync(this.toEmbeddedTS(state));
+    return this.toTS(state);
+  }
+
+  /**
+   * 生成文本化代码
+   * @param state 编译状态
+   * @returns 生成的代码
+   */
+  // @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    return '[编译方法未实现]';
   }
 
   delete() {

package/src/concepts/Logic__.ts

@@ -2066,11 +2066,11 @@ export class Logic extends BaseNode {
   toNaturalTS(state = createCompilerState(), prefix?: string, logicName?: string, currentNode?: BaseNode): string {
     // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
     let code = '';
-    if (currentNode === this) {
-      code += `\n${indent(state.tabSize)}/**
-${indent(state.tabSize)} * 当前逻辑
-${indent(state.tabSize)} */\n`;
-    }
+//     if (currentNode === this) {
+//       code += `\n${indent(state.tabSize)}/**
+// ${indent(state.tabSize)} * 当前逻辑
+// ${indent(state.tabSize)} */\n`;
+//     }
     if (!logicName) {
       const { name, parentNode } = this;
       if (parentNode?.concept === 'View') {
@@ -2107,22 +2107,22 @@ ${indent(state.tabSize)} */\n`;
     code += ')';
 
     // 需要类型推导的局部变量/返回值需要调整申明顺序
-    const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
-    this.traverseChildren((el) => {
-      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
-        const jsCode = el.toJS();
-        const advanceVar = this.variables?.find(
-          (variable) => !variable.typeAnnotation && jsCode.includes(`${variable.name} = `),
-        );
-        if (advanceVar && !advanceMap.get(advanceVar)) {
-          advanceMap.set(advanceVar, el);
-        }
-        const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && jsCode.includes(`${ret.name} = `));
-        if (advanceRn && !advanceMap.get(advanceRn)) {
-          advanceMap.set(advanceRn, el);
-        }
-      }
-    });
+    // const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
+    // this.traverseChildren((el) => {
+    //   if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+    //     const jsCode = el.toJS();
+    //     const advanceVar = this.variables?.find(
+    //       (variable) => !variable.typeAnnotation && jsCode.includes(`${variable.name} = `),
+    //     );
+    //     if (advanceVar && !advanceMap.get(advanceVar)) {
+    //       advanceMap.set(advanceVar, el);
+    //     }
+    //     const advanceRn = this.returns?.find((ret) => !ret.typeAnnotation && jsCode.includes(`${ret.name} = `));
+    //     if (advanceRn && !advanceMap.get(advanceRn)) {
+    //       advanceMap.set(advanceRn, el);
+    //     }
+    //   }
+    // });
 
     // 兼容 return 没有类型情况
     if (this.returns.length && this.returns[0].typeAnnotation) {
@@ -2146,14 +2146,14 @@ ${indent(state.tabSize)} */\n`;
       });
 
       if (!this.body.length && this.returns.length) {
-        if (!state.focusedNodePath || `${this.nodePath}.body[0]` === state.focusedNodePath)
-          code += `${indent(state.tabSize + 1)}// 当前位置\n`;
+        // if (!state.focusedNodePath || `${this.nodePath}.body[0]` === state.focusedNodePath)
+        //   code += `${indent(state.tabSize + 1)}// 当前位置\n`;
         code += `${indent(state.tabSize + 1)}return ${this.returns[0].name};\n`;
       } else {
         this.body.forEach((item) => {
           let partialCode = '';
 
-          if (!state.focusedNodePath && item.concept === 'End') code += `${indent(state.tabSize + 1)}// 当前位置\n`;
+          // if (!state.focusedNodePath && item.concept === 'End') code += `${indent(state.tabSize + 1)}// 当前位置\n`;
           if (item.toNaturalTS) {
             partialCode = item.toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
           } else if (item.toEmbeddedTS) {

package/src/concepts/MatchCase__.ts

@@ -880,11 +880,11 @@ export class MatchCase extends LogicItem {
   }
 
   @withSourceMap()
-  toNaturalTS(state = createCompilerState(), index?: number, parentCode?: string): string {
+  toNaturalTS(state = createCompilerState(), index = 0, parentCode?: string): string {
     let code = '\n';
 
     const parentNode = this.parentNode as Match;
-    const length = parentNode?.cases?.length;
+    const length = parentNode?.cases?.length || 0;
 
     if (length > 1) {
       if (index !== length - 1) {
@@ -923,7 +923,7 @@ export class MatchCase extends LogicItem {
 
         if (Array.isArray(this.body)) {
           this.body.forEach((logicItem, bodyIndex) => {
-            if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+            if (bodyIndex === this.body.length - 1 && (this.parentNode as Match)?.isExpression) {
               code += indent(state.tabSize);
               code += `return `;
             }
@@ -941,7 +941,7 @@ export class MatchCase extends LogicItem {
         code += indent(state.tabSize);
         code += 'else {\n';
         this.body.forEach((logicItem, bodyIndex) => {
-          if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+          if (bodyIndex === this.body.length - 1 && (this.parentNode as Match)?.isExpression) {
             code += indent(state.tabSize);
             code += `return `;
           }
@@ -957,7 +957,7 @@ export class MatchCase extends LogicItem {
       }
     } else {
       this.body.forEach((logicItem, bodyIndex) => {
-        if (bodyIndex === this.body.length - 1 && logicItem.concept !== 'Assignment') {
+        if (bodyIndex === this.body.length - 1 && (this.parentNode as Match)?.isExpression) {
           code += indent(state.tabSize);
           code += `return `;
         }

package/src/concepts/Match__.ts

@@ -824,7 +824,7 @@ export class Match extends LogicItem {
       !['NewMap', 'NewList'].includes(this.parentNode.concept) &&
       this.parentKey !== 'returnExpression'
     ) {
-      code += ';\n';
+      code += '\n';
     }
     return code;
   }

package/src/concepts/MemberExpression__.ts

@@ -532,9 +532,9 @@ export class MemberExpression extends LogicItem {
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
     let code = '';
-    const leftCode = this.object ? `${this.object.toNaturalTS(shiftState(state, code, { inline: true }))}.` : '';
-    code += this.object ? `${this.object.toNaturalTS(shiftState(state, code, { inline: true }))}.` : '';
-    code += this.property ? this.property.toNaturalTS(shiftState(state, code, { inline: true })) : '';
+    const leftCode = this.object ? `${this.object.toNaturalTS(shiftState(state, code, { inline: true }))}.` : '__IDENTIFIER__';
+    code += this.object ? `${this.object.toNaturalTS(shiftState(state, code, { inline: true }))}.` : '__IDENTIFIER__';
+    code += this.property ? this.property.toNaturalTS(shiftState(state, code, { inline: true })) : '__IDENTIFIER__';
     // 就说明这是一个枚举取值操作，直接啊app.enums.color.red 要转成字符串
     // 解决枚举可能全是数字的问题
     // app.enums.color  || extensions.tool.enums.color
@@ -546,6 +546,15 @@ export class MemberExpression extends LogicItem {
     return code;
   }
 
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = '';
+    // const leftCode = this.object ? `${this.object.toTextualNASL(shiftState(state, code, { inline: true }))}.` : '';
+    code += this.object ? `${this.object.toTextualNASL(shiftState(state, code, { inline: true }))}.` : '__IDENTIFIER__';
+    code += this.property ? this.property.toTextualNASL(shiftState(state, code, { inline: true })) : '__IDENTIFIER__';
+    return code;
+  }
+
   get lastObject() {
     let tempNode: any = this;
     while (tempNode?.object?.concept === 'MemberExpression') {

package/src/concepts/NewComposite__.ts

@@ -1179,13 +1179,11 @@ export class NewComposite extends LogicItem {
     } else if (typeAnnotation.typeKind !== 'anonymousStructure') {
       // 实体、数据结构默认值使用new时需要改成vue.prototype才能获取到方法
       if (state?.getVuePrototype) {
-        code += `const obj = Vue.prototype.$genInitFromSchema('${
-          typeAnnotation.sortedTypeKey
-        }', Vue.prototype.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+        code += `const obj = Vue.prototype.$genInitFromSchema('${typeAnnotation.sortedTypeKey
+          }', Vue.prototype.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
       } else {
-        code += `const obj = this.$genInitFromSchema('${
-          typeAnnotation.sortedTypeKey
-        }', this.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+        code += `const obj = this.$genInitFromSchema('${typeAnnotation.sortedTypeKey
+          }', this.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
       }
       const rightMap = new Map();
       this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
@@ -1432,18 +1430,18 @@ export class NewComposite extends LogicItem {
     let code = 'nasl.util.';
     code +=
       this?.typeAnnotation?.typeKind === 'anonymousStructure'
-        ? 'NewAnonymityStructure'
+        ? 'NewAnonymousStructure'
         : `NewEntity<${this?.typeAnnotation?.typeName || '__IDENTIFIER__'}>`;
     let params = '';
     this?.properties?.forEach((item, index) => {
       if (item) {
         params += `${item?.toNaturalTS()}: ${this?.rights?.[index]?.expression?.toNaturalTS()}`;
         if (index !== this.properties.length - 1) {
-          params += ';';
+          params += ', ';
         }
       }
     });
-    code += `(${params ? `{${params}}` : '__IDENTIFIER__'})`;
+    code += `(${params ? `{ ${params} }` : ''})`;
     return code;
   }
 

package/src/concepts/NewList__.ts

@@ -508,16 +508,16 @@ export class NewList extends LogicItem {
     let code = '';
     const typeAnnotation =
       this?.typeAnnotation?.typeArguments?.map((item) => item?.toNaturalTS())?.join(', ') || '__IDENTIFIER__';
-    let params = '';
+    let paramStr = '';
     this?.items?.forEach((item, index) => {
       if (item) {
-        params += item.toNaturalTS(shiftState(state, code, { inline: true }));
+        paramStr += item.toNaturalTS(shiftState(state, code, { inline: true }));
         if (index !== this.items.length - 1) {
-          params += ', ';
+          paramStr += ', ';
         }
       }
     });
-    code += `nasl.util.NewList<${typeAnnotation}>(${params ? `{${params}}` : '__IDENTIFIER__'})`;
+    code += `nasl.util.NewList<${typeAnnotation}>(${paramStr ? `[${paramStr}]` : '[]'})`;
     return code;
   }
 

package/src/concepts/NewMap__.ts

@@ -742,20 +742,21 @@ export class NewMap extends LogicItem {
   }
 
   @withSourceMap()
-  toNaturalTS(): string {
+  toNaturalTS(state = createCompilerState()): string {
     let code = '';
     const typeAnnotation =
-      this?.typeAnnotation?.typeArguments?.map((item) => item?.toNaturalTS())?.join(', ') || '__IDENTIFIER__';
+      this?.typeAnnotation?.typeArguments?.map((item) => item?.toNaturalTS(shiftState(state, code, { inline: true })))?.join(', ') || '__IDENTIFIER__';
     let params = '';
     this?.keys?.forEach((item, index) => {
       if (item) {
-        params += `${item?.toNaturalTS()}: ${this?.values?.[index]?.toNaturalTS()}`;
+        const key = item?.toNaturalTS(shiftState(state, code, { inline: true, tabSize: state.tabSize + 1 })) || '__IDENTIFIER__';
+        params += `${item?.concept.endsWith('Literal') ? key : `[${key}]`}: ${this?.values?.[index]?.toNaturalTS(shiftState(state, code, { inline: true }))}`;
         if (index !== this.keys.length - 1) {
-          params += ';';
+          params += ', ';
         }
       }
     });
-    code += `nasl.util.NewMap<${typeAnnotation}>(${params ? `{${params}}` : '__IDENTIFIER__'})`;
+    code += `nasl.util.NewMap<${typeAnnotation}>(${params ? `{ ${params} }` : '{}'})`;
     return code;
   }
 

package/src/concepts/NullLiteral__.ts

@@ -78,6 +78,16 @@ export class NullLiteral extends LogicItem {
     return 'null';
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    return 'null';
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    return 'null';
+  }
+
   getValue() {
     return 'null';
   }

package/src/concepts/NumericLiteral__.ts

@@ -158,7 +158,12 @@ export class NumericLiteral extends LogicItem {
 
   @withSourceMap()
   toNaturalTS(): string {
-    return this.value;
+    return '' + this.value;
+  }
+
+  @withSourceMap()
+  toTextualNASL(): string {
+    return '' + this.value;
   }
 
   changeType(value: string | number) {

package/src/concepts/OqlQueryComponent__.ts

@@ -319,8 +319,10 @@ export class OqlQueryComponent extends LogicItem {
 
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
-    const code: string = `nasl.oql.query(\`${this.code}\`)`;
-    return code;
+    const code = this.code
+      .replace(/\.(\d+)\}/g, '[$1]}')
+      .replace(/`/g, '\\`'); // 处理枚举 TS 转不回来的情况 ${app.enums.NetStatusEnum.1}
+    return `nasl.oql.query(\`${code}\`)`;
   }
 
   // 从服务端获取 SQL -> TS 的翻译和 sourceMap

package/src/concepts/Param__.ts

@@ -480,6 +480,45 @@ export class Param extends BaseNode {
     return code;
   }
 
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState(), dontType?: boolean): string {
+    let code = this.name;
+    // 回调函数类的参数
+    if (this?.typeAnnotation?.typeKind === 'function') {
+      code += ':{(';
+      const paramTypes = this.typeAnnotation?.typeArguments || [];
+      paramTypes.forEach((type, index) => {
+        code += `type${index + 1}:${type.toTextualNASL(shiftState(state, code))}`;
+        if (index !== paramTypes.length - 1) {
+          code += ',';
+        } else {
+          code += ')';
+        }
+      });
+      code += ':';
+      const returnTypes = this.typeAnnotation?.returnType || [];
+      returnTypes.forEach((type) => {
+        code += type.toTextualNASL(shiftState(state, code));
+      });
+      code += '}';
+      return code;
+    }
+
+    if (asserts.isFunction(this.defaultExpression) || asserts.isAnonymousFunction(this.defaultExpression)) {
+      code += this.required ? ': ' : '?: ';
+      code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
+    } else if (!dontType && this.typeAnnotation) {
+      code += ': ';
+      code += this.typeAnnotation.toTextualNASL(shiftState(state, code));
+      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
+        if (this.isEnum()) {
+          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+        }
+      }
+    }
+    return code;
+  }
+
   @withSourceMapGenerator
   *toEmbeddedNameTS(state?: TranslatorState) {
     return `${this.name}`;

package/src/concepts/ProcessElement__.ts

@@ -1915,7 +1915,14 @@ export class ProcessElement extends BaseNode {
         if (Array.isArray(self.bindEvents)) {
           yield* wrapForEach(self.bindEvents, function* warpForEachGenerator(bindEvent) {
             // 任务完成时可以拿到输出参数
-            const currentPrevCode = bindEvent.name === 'OnClose' ? prevCodeClose : prevCode;
+            let currentPrevCode: any;
+            if(bindEvent.name !== 'OnClose') {
+              currentPrevCode = prevCode;
+              // 除了任务完成时的逻辑，其他逻辑拿不到自己任务下的输出参数，所以不需要__ProcessIdentification__标注
+              currentPrevCode = currentPrevCode.replace('__ProcessIdentification__', '');
+            } else {
+              currentPrevCode = prevCodeClose;
+            }
             code += `${tab1}${bindEvent.name}: () => [\n`;
             yield* wrapForEach(bindEvent.logics, function* warpForEachGenerator(logic) {
               code += `${yield* logic.toEmbeddedTSInProcess(

package/src/concepts/QueryAggregateExpression__.ts

@@ -166,6 +166,21 @@ export class QueryAggregateExpression extends LogicItem {
     });
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let code = `${this.asName}: ${this.aggregateName}(${this.aggregateParam.toTextualNASL(state)})`;
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = `${this.aggregateName}(${this.aggregateParam.toTextualNASL(state)})`;
+    if (this.asName)
+      code += ` AS ${this.asName}`;
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/QueryFieldExpression__.ts

@@ -8,6 +8,7 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import type CallQueryComponent from './CallQueryComponent__';
+import { firstLowerCase } from '../utils';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -158,6 +159,39 @@ export class QueryFieldExpression extends LogicItem {
     return '__QueryFieldExpression__';
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState(), genAs: boolean = false): string {
+    let code = '';
+
+    if (genAs) {
+      if (this.isDotStar)
+        code += `${this.asName || firstLowerCase(this.entityAsName) || '__IDENTIFIER__'}: ${this.entityAsName || '__IDENTIFIER__'}`;
+      else
+        code += `${this.asName || this.propertyName || '__IDENTIFIER__'}: ${this.entityAsName || '__IDENTIFIER__'}.${this.propertyName || '__IDENTIFIER__'}`;
+    } else {
+      if (this.isDotStar)
+        code += `${this.entityAsName || '__IDENTIFIER__'}`;
+      else
+        code += `${this.entityAsName || '__IDENTIFIER__'}.${this.propertyName || '__IDENTIFIER__'}`;
+    }
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState(), genAs: boolean = false): string {
+    let code = '';
+    if (this.isDotStar)
+      code += `${this.entityAsName}.*`;
+    else
+      code += `${this.entityAsName}.${this.propertyName}`;
+
+    if (this.asName && genAs)
+      code += ` AS ${this.asName}`;
+
+    return code;
+  }
+
   toBrief(): string {
     return this.getValue();
   }

package/src/concepts/QueryFromExpression__.ts

@@ -286,6 +286,35 @@ export class QueryFromExpression extends LogicItem {
     return code;
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    const simpleEntityKey = this.entityName + 'Entity';
+    let code = `FROM(${simpleEntityKey}, ${this.asName || this.entityName} => $`;
+
+    if (this.joinParts.length) {
+      this.joinParts.forEach((joinPart) => {
+        code += '\n';
+        code += joinPart.toNaturalTS(state);
+      });
+    }
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = `FROM ${this.entityKey}`;
+
+    if (this.joinParts.length) {
+      this.joinParts.forEach((joinPart) => {
+        code += '\n';
+        code += joinPart.toTextualNASL(state);
+      });
+    }
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/QueryGroupByExpression__.ts

@@ -158,13 +158,23 @@ export class QueryGroupByExpression extends LogicItem {
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
     // 判断老应用
-    if ((self.parentNode as CallQueryComponent).isAutoInfer()) {
+    if ((self.parentNode as CallQueryComponent)?.isAutoInfer()) {
       // 2.11版本后 分组使用别名
       return `__${(self.groupElement as QueryFieldExpression).asName || 'EMPTY_GROUP_BY_ALIAS__'}`;
     }
     return yield* (self.groupElement as QueryFieldExpression).toEmbeddedTS();
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    return (this.groupElement as QueryFieldExpression).toNaturalTS(state);
+  }
+  
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    return (this.groupElement as QueryFieldExpression).toTextualNASL(state);
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/QueryJoinExpression__.ts

@@ -509,6 +509,45 @@ export class QueryJoinExpression extends LogicItem {
     return code;
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    const simpleEntityKey = this.entityName + 'Entity';
+    let code = `.${this.joinType}_JOIN(${simpleEntityKey}, ${this.asName || this.entityName} => ON(() => `;
+    this.onExpressions.forEach((on) => {
+      code += on.toNaturalTS(shiftState(state, code, { inline: true }));
+    });
+    code += ')';
+
+    if (this.joinParts.length) {
+      this.joinParts.forEach((joinPart) => {
+        code += '\n';
+        code += joinPart.toNaturalTS(state);
+      });
+    }
+
+    return code;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let code = `${this.joinType} JOIN ${this.entityKey}`;
+    if (this.asName)
+      code += ` AS ${this.asName}`;
+    code += ' ON ';
+    this.onExpressions.forEach((on) => {
+      code += on.toTextualNASL(shiftState(state, code, { inline: true }));
+    });
+
+    if (this.joinParts.length) {
+      this.joinParts.forEach((joinPart) => {
+        code += '\n';
+        code += joinPart.toTextualNASL(state);
+      });
+    }
+
+    return code;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/QueryLimitExpression__.ts

@@ -194,6 +194,20 @@ export class QueryLimitExpression extends LogicItem {
     return code;
   }
 
+  @withSourceMap()
+  toNaturalTS(state = createCompilerState()): string {
+    let pageElement = this.pageElement.toTextualNASL(state);
+    let pageSizeElement = this.pageSizeElement.toTextualNASL(state);
+    return `[${pageElement}, ${pageSizeElement}]`;
+  }
+
+  @withSourceMap()
+  toTextualNASL(state = createCompilerState()): string {
+    let pageElement = this.pageElement.concept === 'Identifier' ? `\${${this.pageElement.toTextualNASL(state)}}` : this.pageElement.toTextualNASL(state);
+    let pageSizeElement = this.pageSizeElement.concept === 'Identifier' ? `\${${this.pageSizeElement.toTextualNASL(state)}}` : this.pageSizeElement.toTextualNASL(state);
+    return `${pageElement}, ${pageSizeElement}`;
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓