@lcap/nasl 3.7.3-beta.1 → 3.8.0-beta.2

package/src/concepts/Logic__.ts

@@ -4,7 +4,7 @@ import {
   runGeneratorSync as runSync,
   returnOrigin,
 } from '../utils/time-slicing';
-import { waitOqlQueryComponentChildrenFinish } from '../common';
+import { invokeCommand, waitOqlQueryComponentChildrenFinish } from '../common';
 import type { EmbeddedTSFileGenerator } from '../utils';
 import { FrontendLibrary } from './FrontendLibrary__';
 import {
@@ -17,7 +17,6 @@ import {
   withSourceMapGenerator,
   withGenerator,
   TranslatorGenerator,
-  createDescriptionComment,
 } from '../translator';
 import type App from './App__';
 import type Namespace from './Namespace__';
@@ -47,6 +46,7 @@ import type Process from './Process__';
 import type CallFunction from './CallFunction__';
 import ProcessElementV2 from './ProcessElementV2__';
 import ProcessV2 from './ProcessV2__';
+import type SubLogic from './SubLogic__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -65,12 +65,13 @@ import Param from './Param__';
 import Return from './Return__';
 import Variable from './Variable__';
 import LogicItem from './LogicItem__';
+import Annotatable from './Annotatable__';
 
 /**
  * 逻辑
  */
 @concept('逻辑')
-export class Logic extends BaseNode {
+export class Logic extends Annotatable {
   /** 类名 */
   static readonly ConceptName: string = 'Logic';
   /**
@@ -79,7 +80,7 @@ export class Logic extends BaseNode {
    */
   static isAbstract: boolean = false;
   /** 继承链 */
-  static readonly inheritanceChain: string[] = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['Annotatable', 'BaseNode'];
 
   /**
    * 产品概念
@@ -1545,6 +1546,11 @@ export class Logic extends BaseNode {
     prefix?: boolean,
   ): TranslatorGenerator {
     const self = this;
+
+    // 获取所有子节点用于树上填充
+    self.getSubLogics()
+
+    yield waitOqlQueryComponentChildrenFinish(self);
     let code = '';
     if (!prefix) code += `${noName ? '' : `${self.name}:`} function(`;
     else code += `function ${self.name}(`; // 加空格会导致无法查询到引用
@@ -1826,13 +1832,15 @@ export class Logic extends BaseNode {
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState(), prefix?: string, hideDefaultValue?: boolean): TranslatorGenerator {
     const self = this;
+    // 获取所有子节点用于树上填充
+    self.getSubLogics();
+
     // 等待 oql 查询返回内容
     yield waitOqlQueryComponentChildrenFinish(self);
     // 如果传了不要前缀那就为空， 要不用传进来的，要是都没有就默认导出
     let code = '';
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
     const IDENTIFIERMAP = new Set<Variable | Return>();
-
     if (!prefix) {
       code += `export function ${self.tsName}`;
     } else if (prefix === 'noExport') {
@@ -1840,11 +1848,13 @@ export class Logic extends BaseNode {
     } else if (prefix === 'inObject') {
       code += `${self.tsName}`;
     }
-    if (self.typeParams?.length) {
+    const completeTypeParams = this.completeTypeParams;
+    const noChooseParamTypes = completeTypeParams.filter((typeParam) => !typeParam.needChoose);
+    if (noChooseParamTypes?.length) {
       code += '<';
-      yield* wrapForEach(self.typeParams, function* warpForEachGenerator(typeParam, typeParamIndex) {
+      yield* wrapForEach(noChooseParamTypes, function* warpForEachGenerator(typeParam, typeParamIndex) {
         code += yield* typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
-        if (typeParamIndex !== self.typeParams.length - 1) code += ', ';
+        if (typeParamIndex !== noChooseParamTypes.length - 1) code += ', ';
       });
       code += '>';
     }
@@ -1916,8 +1926,44 @@ export class Logic extends BaseNode {
       }
     });
 
+    const needChooseParamTypes = completeTypeParams.filter((typeParam) => typeParam.needChoose);
     // 兼容 return 没有类型情况
-    if (self.returns.length && self.returns[0].typeAnnotation) {
+    /**
+     *为了翻译成一部分推导一部分手选,翻译和调用同时需要特殊翻译
+      declare function singleTypeParam3<T, S, V>(param: T, param2: S): Map<V, Array<T>>
+      declare function singleTypeParam4<T, S>(param: T, param2: S): <V>() => Map<V, Array<T>>
+
+      发现还有问题，所以，翻译在调整一下
+      把所有的泛型拼接在函数后面方便去取回来特殊处理， 因为tsserver没有返回泛型，所以需要手动处理
+      等后面沟通一下
+      declare function singleTypeParam4<T, S>(param: T, param2: S): <V>() => [Map<V, Array<T>>, T, S]
+    */
+    if (completeTypeParams.length) {
+      code += ': ';
+      if (needChooseParamTypes?.length) {
+        code += '<';
+        yield* wrapForEach(needChooseParamTypes, function* warpForEachGenerator(typeParam, typeParamIndex) {
+          code += yield* typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          if (typeParamIndex !== needChooseParamTypes.length - 1) code += ', ';
+        });
+        code += '>';
+      }
+      code += '() => [';
+      if (self.returns.length && self.returns[0].typeAnnotation) {
+        code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+          returnOrigin('');
+      } else {
+        code += 'void';
+      }
+      if (noChooseParamTypes?.length) {
+        code += ',';
+        yield* wrapForEach(noChooseParamTypes, function* warpForEachGenerator(typeParam, typeParamIndex) {
+          code += yield* typeParam.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          if (typeParamIndex !== noChooseParamTypes.length - 1) code += ', ';
+        });
+      }
+      code += ']';
+    } else if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
       code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
         returnOrigin('');
@@ -2168,8 +2214,6 @@ export class Logic extends BaseNode {
   @withSourceMap()
   toNaturalTS(state = createCompilerState()): string {
     let code = '';
-    if (state.descriptionComment)
-      code += createDescriptionComment(state, this, ['description']);
 
     let logicName = this.name;
     if (state.autoPrefixName) {
@@ -2457,7 +2501,7 @@ export class Logic extends BaseNode {
 
   getNamespace(): string {
     if (this.parentNode) {
-      const parentNamespace = (this.parentNode as any)?.getNamespace();
+      const parentNamespace = (this.parentNode as any)?.getNamespace?.();
       // 针对Connector, 其对应的引入入口只有连接器。且唯一标识由
       // calleeName、calleeNamespace 两个字段组合确认，
       // 故这里只返回 Connector 对应的nameSpace 且 俩字段组合默认会含带logic 字段
@@ -2645,11 +2689,6 @@ export class Logic extends BaseNode {
       actionMsg,
     });
     super.delete();
-    this.body.forEach((el) => {
-      if (asserts.isCallInterface(el)) {
-        el.deleteCallNode()
-      }
-    })
     this.traverseChildren(async (el) => {
       if (el?.concept === 'CallQueryComponent') (el as CallQueryComponent).removeStructure();
       // 仅仅针对 自定义连接器下的 Loigc，其他需要界定边界
@@ -2779,6 +2818,90 @@ export class Logic extends BaseNode {
     return this.view || (this?.getAncestor('BusinessComponent') as BusinessComponent);
   }
 
+  subLogics: Array<SubLogic> = [];
+
+  getSubLogics() {
+    const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        return true;
+      }
+    });
+    this.subLogics = subLogics as Array<SubLogic>;
+  }
+
+  existingSubLogic: Set<string> = new Set<string>();
+
+  collectExistSubLogic() {
+    const existSubLogics: SubLogic[] = [];
+    this.findNaslNodeByBFS((node: BaseNode) => {
+      if (asserts.isSubLogic(node)) {
+        existSubLogics.push(node);
+      }
+      return false;
+    });
+    return existSubLogics;
+  }
+
+  // 获取当前逻辑中已经存在的子逻辑名称
+  getSubLogicExistingNames(excludedList: Array<SubLogic> = []) {
+    if (!this.existingSubLogic.size) {
+      const subLogics = this.collectExistSubLogic();
+      subLogics.forEach((subLogic) => {
+        if (!excludedList.includes(subLogic)) {
+          this.existingSubLogic.add(subLogic.name);
+        }
+      });
+    }
+    return Array.from(this.existingSubLogic);
+  }
+
+  getSubLogicUniqueName(name = 'subLogic1') {
+    const existingNames = this.getSubLogicExistingNames();
+    const uniqueName = utils.unique(name, existingNames, undefined, false);
+    this.existingSubLogic.add(uniqueName);
+    return uniqueName;
+  }
+
+  genActionListener($event: EventPayload): void {
+    super.genActionListener($event);
+    invokeCommand('logic.update', this);
+  }
+
+  /**
+   * 完成的泛型参数
+   * 先指支持依赖库的泛型参数
+   * 所以别的都输出 空数组，让别的走旧逻辑
+   */
+  get completeTypeParams() {
+    /**
+     * 遍历泛型和入参类型
+     * 如果泛型在入参中使用，则不需要选择
+     * 所以需要递归看下子集到底是否真的用到了泛型，如果用了，就不需要选择，反之就需要选择
+     */
+    const typeParams = this.typeParams ?? [];
+    if (this.module && typeParams.length) {
+      let needNoChooses = new Set();
+      this.params?.forEach((param) => {
+        param?.typeAnnotation?.traverseStrictChildren((item) => {
+          if (item.concept === 'TypeAnnotation' && item.typeKind === 'typeParam') {
+            const findItem = typeParams.find((typeParam) => typeParam.name === item.typeName);
+            if (findItem) {
+              needNoChooses.add(findItem);
+            }
+          }
+        });
+      });
+      typeParams.forEach((typeParam) => {
+        if (needNoChooses.has(typeParam)) {
+          typeParam.needChoose = false;
+        } else {
+          typeParam.needChoose = true;
+        }
+      });
+      return typeParams;
+    }
+    return [];
+  }
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/ManagerV2__.ts

@@ -0,0 +1,78 @@
+//================================================================================
+// 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+// ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+//================================================================================
+import { EventPayload, Params } from '../common/EventEmitter';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
+
+import * as utils from '../utils';
+import { createUUID } from '../utils/create';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
+import BaseNode from '../common/BaseNode';
+import MemberExpression from './MemberExpression__';
+
+/**
+ * 主管
+ */
+@concept('主管')
+export abstract class ManagerV2 extends BaseNode {
+  /** 类名 */
+  static readonly ConceptName: string = 'ManagerV2';
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = true;
+  /** 继承链 */
+  static readonly inheritanceChain: string[] = ['BaseNode'];
+
+  /**
+   * 产品概念
+   */
+  @property('concept')
+  // @ts-ignore
+  readonly concept!: 'DirectManagerV2' | 'DepartmentManagerV2';
+  /**
+   * 下属
+   */
+  @property({
+    objectRef: 'MemberExpression',
+  })
+  subordinate: MemberExpression;
+
+  /**
+   * 级数
+   */
+  @property()
+  level: number;
+
+  /**
+   * @param source 需要合并的部分参数
+   */
+  constructor(source?: Partial<ManagerV2>) {
+    source = Object.assign({}, ManagerV2.getDefaultOptions(), source);
+    super(source);
+    super.subConstructor(source);
+  }
+
+  static from(source: any, parentNode?: any, parentKey?: string): ManagerV2 {
+    return super.from(source, parentNode, parentKey) as ManagerV2;
+  }
+
+  //================================================================================
+  // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+  // 自动生成的代码已结束。下面可以手动编写。
+  //================================================================================
+
+  //================================================================================
+  // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
+  // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
+  //================================================================================
+}
+
+export default ManagerV2;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================

package/src/concepts/MatchCase__.ts

@@ -150,6 +150,15 @@ export class MatchCase extends LogicItem {
     return logicItem;
   }
 
+  getLogicItemExistingNames(excludedList: Array<LogicItem> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.patterns as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+
+  getLogicItemUniqueName(name = 'logicItem1') {
+    return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
+  }
+
   /**
    * 插入逻辑项
    * @param logicItemOptions 逻辑项参数
@@ -582,14 +591,6 @@ export class MatchCase extends LogicItem {
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
 
-  getLogicItemExistingNames(excludedList: Array<LogicItem> = []) {
-    const excludedSet = new Set(excludedList);
-    return ((this.patterns as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
-  }
-  getLogicItemUniqueName(name = 'logicItem1') {
-    return utils.unique(name, this.getLogicItemExistingNames(), undefined, false);
-  }
-
   // 是否处于禁用状态
   get isDisabled() {
     const matchExpression = this.parentNode as Match;

package/src/concepts/MemberExpression__.ts

@@ -494,6 +494,7 @@ export class MemberExpression extends LogicItem {
     if (
       leftCode.startsWith('app.enums.') ||
       leftCode.startsWith('nasl.configuration.enums.') ||
+      leftCode.startsWith('nasl.processV2.enums.') ||
       (leftCode.startsWith('extensions') && leftCode.includes('.enums.'))
     ) {
       const lastIndex = leftCode.lastIndexOf('.');

package/src/concepts/Module__.ts

@@ -36,6 +36,7 @@ import Configuration from './Configuration__';
 import TriggerLauncher from './TriggerLauncher__';
 import Connection from './Connection__';
 import MetadataType from './MetadataType__';
+import Annotation from './Annotation__';
 
 /**
  * 模块
@@ -104,6 +105,10 @@ export class Module extends BaseNode {
       artifactId: string;
       version: string;
     }>;
+    npm?: Array<{
+      name: string;
+      version: string;
+    }>;
   };
 
   /**
@@ -263,6 +268,16 @@ export class Module extends BaseNode {
   })
   metadataTypes: Array<MetadataType> = [];
 
+  /**
+   * 注解列表
+   */
+  @property({
+    objectRef: 'Annotation',
+    isArray: true,
+    defaultValue: [],
+  })
+  annotations: Array<Annotation> = [];
+
   /**
    * @param source 需要合并的部分参数
    */
@@ -2325,6 +2340,160 @@ export class Module extends BaseNode {
     return node;
   }
 
+  getAnnotationExistingNames(excludedList: Array<Annotation> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.annotations as Annotation[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getAnnotationUniqueName(name = 'annotation1') {
+    return utils.unique(name, this.getAnnotationExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入注解
+   * @internal
+   * @param name 注解名称，如果不填会自动生成一个唯一名称
+   */
+  _insertAnnotationAt(name: string, index: number): Annotation;
+
+  /**
+   * 插入注解
+   * @internal
+   * @param annotationOptions 注解参数
+   */
+  _insertAnnotationAt(annotationOptions: Partial<Annotation>, index: number): Annotation;
+
+  /**
+   * 插入注解
+   * @internal
+   * @param annotation 已有的注解实例
+   */
+  _insertAnnotationAt(annotation: Annotation, index: number): Annotation;
+
+  _insertAnnotationAt(options: string | Partial<Annotation> | Annotation, index: number) {
+    const annotationOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'annotations' };
+    const Annotation = getConceptConstructor('Annotation');
+    let annotation: Annotation;
+    if (!options) {
+      annotation = Annotation.from(
+        {
+          ...annotationOptions,
+          name: this.getAnnotationUniqueName(),
+        },
+        this,
+        'annotations',
+      );
+    } else if (typeof options === 'string') {
+      annotation = Annotation.from(
+        {
+          ...annotationOptions,
+          name: options,
+        },
+        this,
+        'annotations',
+      );
+    } else if (asserts.isAnnotation(options)) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      annotation = options;
+      Object.assign(annotation, relationOptions);
+    } else {
+      annotation = Annotation.from(
+        {
+          ...annotationOptions,
+          ...options,
+        },
+        this,
+        'annotations',
+      );
+    }
+    this.annotations.splice(index, 0, annotation);
+    return annotation;
+  }
+
+  /**
+   * 插入注解
+   * @param name 注解名称，如果不填会自动生成一个唯一名称
+   */
+  insertAnnotationAt(name: string, index: number): Annotation;
+
+  /**
+   * 插入注解
+   * @param annotationOptions 注解参数
+   */
+  insertAnnotationAt(annotationOptions: Partial<Annotation>, index: number): Annotation;
+
+  /**
+   * 插入注解
+   * @param annotation 已有的注解实例
+   */
+  insertAnnotationAt(annotation: Annotation, index: number): Annotation;
+
+  insertAnnotationAt(options: string | Partial<Annotation> | Annotation, index: number) {
+    const node = this._insertAnnotationAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'annotations',
+    });
+    return node;
+  }
+
+  /**
+   * 添加注解
+   * @internal
+   * @param name 注解名称，如果不填会自动生成一个唯一名称
+   */
+  _addAnnotation(name?: string): Annotation;
+
+  /**
+   * 添加注解
+   * @internal
+   * @param annotationOptions 注解参数
+   */
+  _addAnnotation(annotationOptions: Partial<Annotation>): Annotation;
+
+  /**
+   * 添加注解
+   * @internal
+   * @param annotation 已有的注解实例
+   */
+  _addAnnotation(annotation: Annotation): Annotation;
+
+  _addAnnotation(options?: string | Partial<Annotation> | Annotation) {
+    const index = this.annotations.length;
+    return this._insertAnnotationAt(options as any, index);
+  }
+
+  /**
+   * 添加注解
+   * @internal
+   * @param name 注解名称，如果不填会自动生成一个唯一名称
+   */
+  addAnnotation(name?: string): Annotation;
+
+  /**
+   * 添加注解
+   * @param annotationOptions 注解参数
+   */
+  addAnnotation(annotationOptions: Partial<Annotation>): Annotation;
+
+  /**
+   * 添加注解
+   * @param annotation 已有的注解实例
+   */
+  addAnnotation(annotation: Annotation): Annotation;
+
+  addAnnotation(options?: string | Partial<Annotation> | Annotation) {
+    const node = this._addAnnotation(options as any);
+    const index = this.annotations.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'annotations',
+    });
+    return node;
+  }
+
   /**
    * 删除数据源
    * @param name 数据源名称
@@ -2650,6 +2819,31 @@ export class Module extends BaseNode {
     return metadataType.delete();
   }
 
+  /**
+   * 删除注解
+   * @param name 注解名称
+   */
+  removeAnnotation(name: string): void;
+
+  /**
+   * 删除注解
+   * @param annotation 已有的注解实例
+   */
+  removeAnnotation(annotation: Annotation): void;
+
+  removeAnnotation(options: string | Annotation) {
+    let annotation: Annotation;
+    if (typeof options === 'string') {
+      annotation = (this.annotations as Annotation[]).find((item) => item.name === options);
+      if (!annotation) {
+        throw new Error('找不到注解 ' + options);
+      }
+    } else {
+      annotation = options;
+    }
+    return annotation.delete();
+  }
+
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。

package/src/concepts/OperatePermissionV2__.ts

@@ -45,7 +45,7 @@ export class OperatePermissionV2 extends BaseNode {
    * 字段名
    */
   @property()
-  name: 'approve' | 'reject' | 'reassign' | 'revert' | 'submit' | 'withdraw';
+  name: 'approve' | 'reject' | 'reassign' | 'revert' | 'submit' | 'withdraw' | 'addSign';
 
   /**
    * 是否允许操作

package/src/concepts/Param__.ts

@@ -80,6 +80,12 @@ export class Param extends BaseNode {
   @property()
   description?: string;
 
+  /**
+   * 是否为展开参数
+   */
+  @property()
+  spread?: boolean;
+
   /**
    * 类型
    */
@@ -258,27 +264,12 @@ export class Param extends BaseNode {
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState(), dontType?: boolean, hideDefaultValue?: boolean): TranslatorGenerator {
     const self = this;
-    let code = self.name;
-    // 回调函数类的参数
-    if (self?.typeAnnotation?.typeKind === 'function') {
-      code += ':{(';
-      const paramTypes = self.typeAnnotation?.typeArguments || [];
-      yield* wrapForEach(paramTypes, function* warpForEachGenerator(type, index) {
-        code += `type${index + 1}:${yield* type.toEmbeddedTS(shiftState(state, code))}`;
-        if (index !== paramTypes.length - 1) {
-          code += ',';
-        } else {
-          code += ')';
-        }
-      });
-      code += ':';
-      const returnTypes = self.typeAnnotation?.returnType || [];
-      yield* wrapForEach(returnTypes, function* warpForEachGenerator(type) {
-        code += yield* type.toEmbeddedTS(shiftState(state, code));
-      });
-      code += '}';
-      return code;
+    let code = '';
+    if (self.spread) {
+      code += '...';
     }
+    code += self.name;
+
     const { typeNamespace, typeName } = self.typeAnnotation || {};
     let typeKey = self.typeAnnotation?.typeKey;
     if (typeNamespace?.endsWith('.metadataTypes')) {
@@ -291,7 +282,13 @@ export class Param extends BaseNode {
       code += yield* self.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
     } else if (!dontType && self.typeAnnotation) {
       code += ': ';
+      if (self.spread) {
+        code += 'Array<';
+      }
       code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+      if (self.spread) {
+        code += '>';
+      }
       if (!hideDefaultValue && self.defaultValue?.expression) {
         if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(typeKey)) {
           code += yield* self.defaultValue.toEmbeddedTS(shiftState(state, code), true);