@lcap/nasl 3.3.0-beta.2 → 3.3.2-beta.2

package/src/concepts/CallFunction__.ts

@@ -20,6 +20,7 @@ import BaseNode from '../common/BaseNode';
 import TypeAnnotation from './TypeAnnotation__';
 import Argument from './Argument__';
 import LogicItem from './LogicItem__';
+import StringLiteral from './StringLiteral__';
 
 /**
  * 调用函数
@@ -371,9 +372,12 @@ export class CallFunction extends LogicItem {
       const needToString = ['Concat'].includes(this.calleeName);
       this.arguments?.forEach((arg: any, index) => {
         let argStr = arg?.toVue(options);
+        const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
+
         if (needToString) {
-          const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
-          argStr = `$utils['ToString'](${argStr}, '${argTypeAnnotation?.sortedTypeKey}')`;
+          argStr = `$utils['ToString']('${argTypeAnnotation?.sortedTypeKey}', ${argStr})`;
+        } else if (['HasValue'].includes(this.calleeName)) {
+          argStr = `{ type: '${argTypeAnnotation?.sortedTypeKey}', value: ${argStr} }`;
         }
         code += argStr;
         if (index !== this.arguments?.length - 1) code += ', ';
@@ -421,47 +425,61 @@ export class CallFunction extends LogicItem {
     }
     code += `this.$utils['${calleeName}']`;
     code += '(';
+
+
+    let argTyAnno;
+    if (this.calleeName === 'ToString') {
+      const arg0 = this.arguments[0];
+      argTyAnno = (arg0 as any).typeAnnotation || arg0.__TypeAnnotation;
+    } else if (this.calleeName === 'FromString') {
+      argTyAnno = this.typeArguments?.[0];
+    }
+
+
+    // 调整 ToString 的 typeKey 到第一个参数，剩下的以后重构。
+    // 事实上，大部分编译器都会选择把 type tag 放到前端来做运行时匹配，而非末位。
+    if (this.calleeName === 'ToString' && argTyAnno) {
+      code += `'${argTyAnno?.sortedTypeKey}', `
+    }
+
     if (Array.isArray(this.arguments) && this.arguments.length) {
       const needToString = ['Concat'].includes(this.calleeName);
+
       this.arguments.forEach((arg: any, index) => {
         let argStr = arg?.toJS(shiftState(state, code));
         const argTypeAnnotation = arg.typeAnnotation || arg.__TypeAnnotation;
+
         if (needToString) {
-          argStr = `this.$utils['ToString'](${argStr}, '${argTypeAnnotation?.sortedTypeKey}')`;
+          argStr = `this.$utils['ToString']('${argTypeAnnotation?.sortedTypeKey}', ${argStr})`;
         } else if (['HasValue'].includes(this.calleeName)) {
-          argStr = `{ value: ${argStr}, type: '${argTypeAnnotation?.sortedTypeKey}' }`;
+          argStr = `{ type: '${argTypeAnnotation?.sortedTypeKey}', value: ${argStr} }`;
         }
         code += argStr;
         if (index !== this.arguments?.length - 1) code += ', ';
       });
     }
-    const isStringConvert = ['ToString', 'FromString'].includes(this.calleeName);
-    let argTypeAnnotation;
-    if (isStringConvert) {
-      if (this.calleeName === 'ToString') {
-        const arg = this.arguments[0];
-        argTypeAnnotation = (arg as any).typeAnnotation || arg.__TypeAnnotation;
-      } else if (this.calleeName === 'FromString') {
-        argTypeAnnotation = this.typeArguments?.[0];
-      }
+
+    if (this.calleeName === 'fromString' && argTyAnno) {
+      code += `, '${argTyAnno?.sortedTypeKey}'`
     }
-    if (argTypeAnnotation) {
-      code += `, '${argTypeAnnotation?.sortedTypeKey}'`;
-    } else if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+    // 用作做语义控制。后面这段代码没完全理解，需要保持进入条件不变。
+    const flagControl = ['ToString', 'fromString'].includes(this.calleeName) && argTyAnno;
+    if (!flagControl && Array.isArray(this.typeArguments) && this.typeArguments.length) {
       if (this.arguments?.length) code += ', ';
-      this.typeArguments?.forEach((arg, index) => {
-        code += arg?.toJS(shiftState(state, code));
+
+      this.typeArguments?.forEach((tyArg, index) => {
+        code += tyArg?.toJS(shiftState(state, code));
         if (index !== this.typeArguments?.length - 1) code += ', ';
       });
     }
 
     code += ')';
-    const typeAnnotation = (this as any).typeAnnotation || this.__TypeAnnotation;
+    const tyAnno = (this as any).typeAnnotation || this.__TypeAnnotation;
     const needGenInitFromSchema =
-      typeAnnotation &&
-      (!['primitive', 'union'].includes(typeAnnotation.typeKind) || typeAnnotation.typeName === 'DateTime');
+    tyAnno &&
+      (!['primitive', 'union'].includes(tyAnno.typeKind) || tyAnno.typeName === 'DateTime');
     if (needGenInitFromSchema) {
-      code = `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', ${code})`;
+      code = `this.$genInitFromSchema('${tyAnno?.sortedTypeKey}', ${code})`;
     }
     return code;
   }

package/src/concepts/CallLogic__.ts

@@ -1,4 +1,5 @@
 import * as JSON5 from 'json5';
+import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap, createCompilerState } from '../translator';
 import Logic from './Logic__';
 import type Param from './Param__';
@@ -11,15 +12,14 @@ import type { ViewElement, ElementToVueOptions } from './ViewElement__';
 import type { MemberExpression } from './MemberExpression__';
 import type { TSPPosition } from '../translator';
 
-//================================================================================
+//= ===============================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//================================================================================
+//= ===============================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import TypeAnnotation from './TypeAnnotation__';
 import Argument from './Argument__';
@@ -112,7 +112,7 @@ export class CallLogic extends LogicItem {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<CallLogic>) {
-    source = Object.assign({}, CallLogic.getDefaultOptions(), source);
+    source = { ...CallLogic.getDefaultOptions(), ...source};
     super(source);
     super.subConstructor(source);
   }
@@ -355,12 +355,12 @@ export class CallLogic extends LogicItem {
   removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
 
   removeTypeAnnotation(options: TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation = options;
+    const typeAnnotation: TypeAnnotation = options;
     return typeAnnotation.delete();
   }
 
   __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
+    const {parentKey} = typeAnnotation;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -389,12 +389,12 @@ export class CallLogic extends LogicItem {
   removeArgument(argument: Argument): void;
 
   removeArgument(options: Argument) {
-    let argument: Argument = options;
+    const argument: Argument = options;
     return argument.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const {parentKey} = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -433,7 +433,7 @@ export class CallLogic extends LogicItem {
     if (typeof options === 'string') {
       validation = this.validation;
       if (!validation) {
-        throw new Error('找不到元素绑定属性 ' + options);
+        throw new Error(`找不到元素绑定属性 ${  options}`);
       }
     } else {
       validation = options;
@@ -442,7 +442,7 @@ export class CallLogic extends LogicItem {
   }
 
   __removeBindAttribute(bindAttribute: BindAttribute) {
-    const parentKey = bindAttribute.parentKey;
+    const {parentKey} = bindAttribute;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -464,10 +464,10 @@ export class CallLogic extends LogicItem {
     return params;
   }
 
-  //================================================================================
+  //= ===============================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //================================================================================
+  //= ===============================================================================
 
   get tsCalleeNamespace() {
     if (this.calleeNamespace) {
@@ -708,7 +708,7 @@ export class CallLogic extends LogicItem {
     ) {
       code += '$global.';
     }
-    const completeArguments = this.completeArguments;
+    const {completeArguments} = this;
 
     if (this.concept === 'CallLogic' && this.getAncestor('BindAttribute')?.name === 'data-source') {
       if (this.calleeNamespace) {
@@ -775,7 +775,6 @@ export class CallLogic extends LogicItem {
       });
     }
     code += ')}';
-
     return code;
   }
 
@@ -989,6 +988,7 @@ export class CallLogic extends LogicItem {
             breakBody = true;
             break;
           }
+          default: break;
         }
         const bodyArgument = logicArgs.find((arg) => arg.keyword === 'body');
         if (!breakBody) {
@@ -1023,7 +1023,7 @@ export class CallLogic extends LogicItem {
       code += '\n})';
     } else {
       if (isComponentLogic) {
-        // 组件ref元素的对象没有qu dao的容错
+        // 组件ref元素的对象没有取到的容错
         code += `this.$refs && this.$refs[\`${refName}\`] && this.$refs[\`${refName}\`].${this.calleeName} && this.$refs[\`${refName}\`].${this.calleeName}`;
       } else if (calleeNamespace === 'nasl.ui' || calleeNamespace === 'nasl.util') {
         switch (this.calleeName) {
@@ -1034,11 +1034,17 @@ export class CallLogic extends LogicItem {
             code += `console.log`;
             break;
           case 'jsonSerialize':
-            code += `JSON.stringify`;
+            if (this.arguments[0]?.expression?.__TypeAnnotation?.typeName === 'String' &&
+                this.arguments[0]?.expression?.__TypeAnnotation?.typeNamespace === 'nasl.core') {
+              code += `JSON.stringify`;
+            } else {
+              code += `this.$utils['JsonSerialize']`
+            }
             break;
           case 'jsonDeserialize':
             code += `JSON.parse`;
             break;
+          default: ;
         }
       } else if (
         calleeNamespace === 'nasl.browser' ||
@@ -1071,17 +1077,18 @@ export class CallLogic extends LogicItem {
           code += `this.$utils['ToString'](`;
         }
         if (Array.isArray(completeArguments) && completeArguments.length) {
-          completeArguments.forEach((arg, index) => {
-            code += arg?.toJS(shiftState(state, code));
-            if (index !== completeArguments?.length - 1) code += ', ';
-          });
           if (needToString) {
             const arg = this.arguments[0];
             const argTypeAnnotation = (arg as any).typeAnnotation || arg.__TypeAnnotation;
             if (argTypeAnnotation) {
-              code += `, '${argTypeAnnotation?.sortedTypeKey}'`;
+              code += `'${argTypeAnnotation?.sortedTypeKey}', `;
             }
           }
+
+          completeArguments.forEach((arg, index) => {
+            code += arg?.toJS(shiftState(state, code));
+            if (index !== completeArguments?.length - 1) code += ', ';
+          });
         }
         if (needToString) {
           code += `)`;
@@ -1320,7 +1327,6 @@ export class CallLogic extends LogicItem {
   toNaturalTS(state = createCompilerState()): string {
     const {
       handleError,
-      calleeKey,
       calleeName,
       parentKey,
       typeArguments,
@@ -1333,9 +1339,10 @@ export class CallLogic extends LogicItem {
       arguments: logicArgs,
     } = this;
 
-    let code = calleeKey.replace('__elements', '$refs');
+    let code = '';
+    let calleeKey = this.calleeKey.replace('__elements', '$refs');
     if (/^app.+?\.entities\..+?logics/.test(code))
-      code = code.replace(/^app.+?\.entities\.(.+?)\.logics/, '$1');
+      calleeKey = calleeKey.replace(/^app.+?\.entities\.(.+?)\.logics/, '$1');
     /** 设置函数范型参数 */
     const setTypeArguments = () => {
       if (Array.isArray(typeArguments) && typeArguments.length) {
@@ -1357,7 +1364,7 @@ export class CallLogic extends LogicItem {
         code += '(';
         logicArgs.forEach((arg, index) => {
           // 页面逻辑先都非必填
-          code += arg.toNaturalTS(shiftState(state, code), paramRequired);
+          code += arg.toNaturalTS(shiftState(state, code, { tabSize: 0 }), paramRequired);
           if (index !== logicArgs.length - 1) code += ', ';
         });
         code += ')';
@@ -1365,7 +1372,7 @@ export class CallLogic extends LogicItem {
         code += '(';
         completeArguments.forEach((arg, index) => {
           // 取到是不是必填放入参数中
-          code += arg.toNaturalTS(shiftState(state, code), arg?.paramRequired);
+          code += arg.toNaturalTS(shiftState(state, code, { tabSize: 0 }), arg?.paramRequired);
           if (index !== logicArgs.length - 1) code += ', ';
         });
         code += ')';
@@ -1478,7 +1485,7 @@ export class CallLogic extends LogicItem {
         line: detail.line + lineOffset,
         offset: characterOffset,
       };
-    } else {
+    } 
       let indexOf = 0;
 
       // 没有括号，表示括号在外面
@@ -1503,7 +1510,7 @@ export class CallLogic extends LogicItem {
         ...detail,
         offset: detail.offset + indexOf,
       };
-    }
+    
   }
 
   /**
@@ -1553,14 +1560,14 @@ export class CallLogic extends LogicItem {
   public static getDefaultOptions() {
     return {};
   }
-  //================================================================================
+  //= ===============================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //================================================================================
+  //= ===============================================================================
 }
 
 export default CallLogic;
-//================================================================================
+//= ===============================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//================================================================================
+//= ===============================================================================

package/src/concepts/Connection__.ts

@@ -401,7 +401,7 @@ export class Connection extends BaseNode {
   @withSourceMap()
   toEmbeddedTS(state?: TranslatorState, prependCode?: string, noName?: boolean, prefix?: boolean): string {
     let code = '';
-    code += `export function ${this.name}<T extends (...args: any[]) => any>(`;
+    code += `export function ${this.tsName}<T extends (...args: any[]) => any>(`;
     code += 'cb: T';
     code += `): ReturnType<T> {\n`;
     code += '\n';

package/src/concepts/ForEachStatement__.ts

@@ -77,7 +77,7 @@ export class ForEachStatement extends LogicItem {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<ForEachStatement>) {
-    source = Object.assign({}, ForEachStatement.getDefaultOptions(), source);
+    source = { ...ForEachStatement.getDefaultOptions(), ...source};
     super(source);
     super.subConstructor(source);
   }
@@ -278,7 +278,7 @@ export class ForEachStatement extends LogicItem {
     if (typeof options === 'string') {
       each = this.each;
       if (!each) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${  options}`);
       }
     } else {
       each = options;
@@ -303,7 +303,7 @@ export class ForEachStatement extends LogicItem {
     if (typeof options === 'string') {
       start = this.start;
       if (!start) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${  options}`);
       }
     } else {
       start = options;
@@ -328,7 +328,7 @@ export class ForEachStatement extends LogicItem {
     if (typeof options === 'string') {
       end = this.end;
       if (!end) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${  options}`);
       }
     } else {
       end = options;
@@ -343,12 +343,12 @@ export class ForEachStatement extends LogicItem {
   removeItemInBody(logicItem: LogicItem): void;
 
   removeItemInBody(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const {parentKey} = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -387,7 +387,7 @@ export class ForEachStatement extends LogicItem {
     if (typeof options === 'string') {
       item = this.item;
       if (!item) {
-        throw new Error('找不到输入参数 ' + options);
+        throw new Error(`找不到输入参数 ${  options}`);
       }
     } else {
       item = options;
@@ -412,7 +412,7 @@ export class ForEachStatement extends LogicItem {
     if (typeof options === 'string') {
       index = this.index;
       if (!index) {
-        throw new Error('找不到输入参数 ' + options);
+        throw new Error(`找不到输入参数 ${  options}`);
       }
     } else {
       index = options;
@@ -421,7 +421,7 @@ export class ForEachStatement extends LogicItem {
   }
 
   __removeParam(param: Param) {
-    const parentKey = param.parentKey;
+    const {parentKey} = param;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -469,7 +469,7 @@ export class ForEachStatement extends LogicItem {
     }
   }
 
-  public static getDefaultOptions() {
+  public static getDefaultOptions(): any {
     return {
       label: 'ForEach 循环分支',
       item: {
@@ -519,11 +519,11 @@ export class ForEachStatement extends LogicItem {
     if (Array.isArray(this.body)) {
       this.body.forEach((logicItem) => {
         code +=
-          logicItem.toJS(
+          `${logicItem.toJS(
             shiftState(state, code, {
               tabSize: 0,
             }),
-          ) + '\n';
+          )  }\n`;
       });
     }
     code += '}\n';
@@ -554,14 +554,14 @@ export class ForEachStatement extends LogicItem {
     if (Array.isArray(this.body)) {
       this.body.forEach((logicItem) => {
         code +=
-          logicItem.toEmbeddedTS(
+          `${logicItem.toEmbeddedTS(
             shiftState(state, code, {
               tabSize: (state?.tabSize || 0) + 1,
             }),
-          ) + ';\n';
+          )  };\n`;
       });
     }
-    code += indent(state?.tabSize || 0) + '})\n';
+    code += `${indent(state?.tabSize || 0)  }})\n`;
 
     return code;
   }
@@ -603,6 +603,8 @@ export class ForEachStatement extends LogicItem {
           })
         )};\n`;
       });
+      if (state.focusedNodePath === `${this.nodePath}.body[${this.body.length}]`)
+          code += `${indent(state.tabSize + 1)}// 当前位置\n`;
     }
     code += `${indent(state?.tabSize || 0)}})\n`;
 

package/src/concepts/IfStatement__.ts

@@ -1,3 +1,4 @@
+import { v4 as uuidv4 } from 'uuid';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 
 //================================================================================
@@ -8,7 +9,6 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
-import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import LogicItem from './LogicItem__';
 
@@ -51,7 +51,7 @@ export class IfStatement extends LogicItem {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<IfStatement>) {
-    source = Object.assign({}, IfStatement.getDefaultOptions(), source);
+    source = { ...IfStatement.getDefaultOptions(), ...source};
     super(source);
     super.subConstructor(source);
   }
@@ -316,7 +316,7 @@ export class IfStatement extends LogicItem {
     if (typeof options === 'string') {
       test = this.test;
       if (!test) {
-        throw new Error('找不到逻辑项 ' + options);
+        throw new Error(`找不到逻辑项 ${  options}`);
       }
     } else {
       test = options;
@@ -331,7 +331,7 @@ export class IfStatement extends LogicItem {
   removeItemInConsequent(logicItem: LogicItem): void;
 
   removeItemInConsequent(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
@@ -342,12 +342,12 @@ export class IfStatement extends LogicItem {
   removeItemInAlternate(logicItem: LogicItem): void;
 
   removeItemInAlternate(options: LogicItem) {
-    let logicItem: LogicItem = options;
+    const logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
   __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
+    const {parentKey} = logicItem;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -403,7 +403,7 @@ export class IfStatement extends LogicItem {
     }
     code += '}';
     if (Array.isArray(this.alternate)) {
-      code += `${indent(state?.tabSize || 0)} else {\n`;
+      code += `${indent((state?.tabSize || 0))} else {\n`;
       this.alternate.forEach((logicItem) => {
         code += `${logicItem.toJS(
           shiftState(state, code, {
@@ -440,7 +440,7 @@ export class IfStatement extends LogicItem {
       });
     }
 
-    code += `${indent(state?.tabSize || 0)}}`;
+    code += `${indent((state?.tabSize || 0))}}`;
     if (Array.isArray(this.alternate)) {
       code += ' else {\n';
       this.alternate.forEach((logicItem) => {
@@ -450,7 +450,7 @@ export class IfStatement extends LogicItem {
           }),
         )};\n`;
       });
-      code += `${indent(state?.tabSize || 0)}}\n`;
+      code += `${indent((state?.tabSize || 0))}}\n`;
     }
     return code;
   }
@@ -465,28 +465,28 @@ export class IfStatement extends LogicItem {
 
     code += ') {\n';
 
-    if (Array.isArray(this.consequent)) {
-      this.consequent.forEach((logicItem) => {
-        code += `${logicItem.toNaturalTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 1,
-          })
-        )};\n`;
-      });
-    }
+    this.consequent.forEach((item) => {
+      code += `${item.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: (state?.tabSize || 0) + 1,
+        })
+      )}\n`;
+    });
+    if (state.focusedNodePath === `${this.nodePath}.consequent[${this.consequent.length}]`)
+      code += `${indent((state?.tabSize || 0) + 1)}// 当前位置\n`;
+
+    code += `${indent((state?.tabSize || 0))}} else {\n`;
+    this.alternate.forEach((item) => {
+      code += `${item.toNaturalTS(
+        shiftState(state, code, {
+          tabSize: (state?.tabSize || 0) + 1,
+        })
+      )}\n`;
+    });
+    if (state.focusedNodePath === `${this.nodePath}.alternate[${this.alternate.length}]`)
+      code += `${indent((state?.tabSize || 0) + 1)}// 当前位置\n`;
+    code += `${indent((state?.tabSize || 0))}}\n`;
 
-    code += `${indent(state?.tabSize || 0)}}\n`;
-    if (Array.isArray(this.alternate)) {
-      code += ' else {\n';
-      this.alternate.forEach((logicItem) => {
-        code += `${logicItem.toNaturalTS(
-          shiftState(state, code, {
-            tabSize: (state?.tabSize || 0) + 1,
-          })
-        )};\n`;
-      });
-      code += `${indent(state?.tabSize || 0)}}\n`;
-    }
     return code;
   }