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

package/src/concepts/NewComposite__.ts

@@ -1,7 +1,9 @@
-import { TranslatorState, shiftState, withSourceMap} from '../translator';
+import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import MemberExpression from './MemberExpression__';
 import StructureProperty from './StructureProperty__';
+import App from './App__';
+import { genHash } from '../generator';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -18,7 +20,6 @@ import Identifier from './Identifier__';
 import SelectMembers from './SelectMembers__';
 import AssignmentLine from './AssignmentLine__';
 import LogicItem from './LogicItem__';
-import App from './App__';
 
 /**
  * 实体/（匿名）数据结构构造器
@@ -73,8 +74,6 @@ export class NewComposite extends LogicItem {
     @property()
     autoConnection: boolean = true;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -88,7 +87,6 @@ export class NewComposite extends LogicItem {
         return super.from(source, parentNode, parentKey) as NewComposite;
     }
 
-    
     /**
      * 设置类型
      */
@@ -176,7 +174,7 @@ export class NewComposite extends LogicItem {
         });
     }
 
-        getIdentifierExistingNames(excludedList: Array<Identifier> = []) {
+    getIdentifierExistingNames(excludedList: Array<Identifier> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.properties as Identifier[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -317,7 +315,6 @@ export class NewComposite extends LogicItem {
         return node;
     }
 
-
     getSelectMembersExistingNames(excludedList: Array<SelectMembers> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.rights as SelectMembers[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -459,7 +456,6 @@ export class NewComposite extends LogicItem {
         return node;
     }
 
-
     getAssignmentLineExistingNames(excludedList: Array<AssignmentLine> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.assignmentLines as AssignmentLine[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -601,9 +597,6 @@ export class NewComposite extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -652,8 +645,6 @@ export class NewComposite extends LogicItem {
         return params;
     }
 
-
-
     /**
     * 删除标识符
     * @param name 标识符名称
@@ -702,8 +693,6 @@ export class NewComposite extends LogicItem {
         return params;
     }
 
-
-
     /**
     * 删除选择成员
     * @param name 选择成员名称
@@ -752,8 +741,6 @@ export class NewComposite extends LogicItem {
         return params;
     }
 
-
-
     /**
     * 删除赋值连线
     * @param name 赋值连线名称
@@ -813,7 +800,6 @@ export class NewComposite extends LogicItem {
     async newConnection(addRightIndex?: number) {
         const leftLineSet = new Set();
         const lineArr: Array<AssignmentLine> = [];
-        const connectionArr: any = [];
         // 系统属性不可自动连线
         ['id', 'createdTime', 'updatedTime', 'createdBy', 'updatedBy'].forEach((name) => leftLineSet.add(name));
         // 左边已连线的下标
@@ -823,17 +809,13 @@ export class NewComposite extends LogicItem {
         });
 
         const autoConnection = () => {
-            let structure: any;
             const isAnnotation = this.typeAnnotation.typeKind === 'anonymousStructure';
-            if (!isAnnotation)
-                structure = this.app.findNodeByCompleteName(this.typeAnnotation.typeNamespace + '.' + this.typeAnnotation.typeName);
             this.app.emit('collect:start', {
                 actionMsg: '自动连线',
             });
             this.properties.forEach((property: Identifier, leftSecondIndex: number) => {
                 const leftName = property.name;
-                const leftTypeAnnotation = !isAnnotation && structure.properties.find((p: StructureProperty) => p.name === property.name).typeAnnotation;
-                const typeStruct = isAnnotation && this.typeAnnotation.properties[leftSecondIndex]; // 获取匿名数据结构typeAnnotation的具体property
+                const leftTypeAnnotation = !isAnnotation && property.__TypeAnnotation;
                 if (leftLineSet.has(leftSecondIndex) || leftLineSet.has(leftName))
                     return;
 
@@ -858,10 +840,6 @@ export class NewComposite extends LogicItem {
                             rightIndex: [rightFirstIndex],
                         });
                         lineArr.push(Line);
-                        connectionArr.push({
-                            leftItem: typeStruct,
-                            rightItem: expression,
-                        });
                         leftLineSet.add(leftSecondIndex);
                         return;
                     }
@@ -878,33 +856,21 @@ export class NewComposite extends LogicItem {
                             const rightIndex = [rightFirstIndex, rightSecondIndex];
                             const Line: AssignmentLine = new AssignmentLine({ leftIndex, rightIndex });
                             lineArr.push(Line);
-                            connectionArr.push({
-                                leftItem: typeStruct,
-                                rightItem: rightMember,
-                            });
                             leftLineSet.add(leftSecondIndex);
                         }
                     });
                 });
             });
             lineArr.length && this.setAssignmentLines([...this.assignmentLines, ...lineArr]);
-            if (this.typeAnnotation.typeKind === 'anonymousStructure') {
-                connectionArr.forEach(({ leftItem, rightItem }: any) => {
-                    if (rightItem.__TypeAnnotation) {
-                        leftItem.update({
-                            typeAnnotation: TypeAnnotation.from({ ...rightItem.__TypeAnnotation.toJSON() }),
-                        });
-                    }
-                });
-            }
             this.app.emit('collect:end');
         };
 
         let count = 0;
         const typeAnnotationEnd = () => {
-            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation));
+            const l = this.properties.every((item) => item.__isCorrectTypeAnnotation);
+            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
             count++;
-            if (r) {
+            if (r && l) {
                 autoConnection();
             } else if (count <= 10) {
                 setTimeout(() => {
@@ -947,47 +913,17 @@ export class NewComposite extends LogicItem {
         });
         newLines.push(Line);
 
-        if (this.typeAnnotation.typeKind !== 'anonymousStructure') {
-            this.update({
-                assignmentLines: newLines,
-                properties: newProperties,
-            });
-        } else {
-            this.app.emit('collect:start', {
-                actionMsg: '匿名数据结构连线',
-            });
-            // 匿名数据结构typeAnnotation变化
-            const structureProperty = this.typeAnnotation.properties.find(({ name }) => name === leftItem.name);
-            const exp = rightItem.concept === 'SelectMembers' ? rightItem.expression : rightItem;
-            // 场景：右侧连接是非匿名数据
-            if (exp.__TypeAnnotation && exp.__TypeAnnotation.typeKey !== 'nasl.core.Null') {
-                structureProperty.update({
-                    typeAnnotation: TypeAnnotation.from({ ...exp.__TypeAnnotation.toJSON() }),
-                });
-            }
-            this.update({
-                assignmentLines: newLines,
-                properties: newProperties,
-            });
-            this.app.emit('collect:end');
-        }
+        this.update({
+            assignmentLines: newLines,
+            properties: newProperties,
+        });
     }
 
     deleteAssignmentLine(assignmentLine: AssignmentLine) {
         const newLine = this.assignmentLines.filter((line) => line !== assignmentLine);
-        this.app.emit('collect:start', {
-            actionMsg: '删除连线',
-        });
-        if (this.typeAnnotation.typeKind === 'anonymousStructure') {
-            const typeStructureProperty = this.findMember(assignmentLine.leftIndex, 'left', true);
-            typeStructureProperty.update({
-                typeAnnotation: null,
-            });
-        }
         this.update({
             assignmentLines: newLine,
         });
-        this.app.emit('collect:end');
     }
 
     changeLinesLocation(selectMember: any) {
@@ -999,7 +935,6 @@ export class NewComposite extends LogicItem {
             const newRights = this.rights.filter((member) => selectMember !== member);
             const filterLine = this.assignmentLines.filter((line) => line.rightIndex[0] !== index);
             const newLines: Array<AssignmentLine> = [];
-            const oldLines: AssignmentLine[] = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] === index);
             filterLine.forEach((line) => {
                 if (line.rightIndex[0] > index) {
                     if (line.rightIndex[1] === undefined) {
@@ -1013,22 +948,10 @@ export class NewComposite extends LogicItem {
                     newLines.push(line);
                 }
             });
-            this.app.emit('collect:start', {
-                actionMsg: '匿名数据结构删除右侧变量',
-            });
-            if (this.typeAnnotation.typeKind === 'anonymousStructure') {
-                oldLines.forEach(({ leftIndex }) => {
-                    const leftItem = this.typeAnnotation.properties[leftIndex[1]];
-                    leftItem.update({
-                        typeAnnotation: null,
-                    });
-                });
-            }
             this.update({
                 rights: newRights,
                 assignmentLines: newLines,
             });
-            this.app.emit('collect:end');
         }
     }
 
@@ -1044,7 +967,7 @@ export class NewComposite extends LogicItem {
         let oldLines: AssignmentLine[] = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] === splitIndex);
         // 右侧变量改变后，修改连线
         members.forEach((item, index) => {
-            if (keepMembers.has(item.completeName)) {
+            if (keepMembers?.has(item.completeName)) {
                 const lines = this.findlines(item, selectMember);
                 lines.forEach((line) => {
                     const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0], index] });
@@ -1054,14 +977,6 @@ export class NewComposite extends LogicItem {
             }
         });
 
-        if (this.typeAnnotation.typeKind === 'anonymousStructure') {
-            oldLines.forEach(({ leftIndex }) => {
-                const leftItem = this.typeAnnotation.properties[leftIndex[1]];
-                leftItem.update({
-                    typeAnnotation: null,
-                });
-            });
-        }
         this.update({
             assignmentLines: newLines,
             rights: [...this.rights.slice(0, splitIndex), newSelectMember, ...this.rights.slice(splitIndex + 1, this.rights.length)],
@@ -1094,11 +1009,8 @@ export class NewComposite extends LogicItem {
         return lines;
     }
 
-    findMember(arrIndex: Array<number>, place: string, isAnnotation?: boolean) {
+    findMember(arrIndex: Array<number>, place: string) {
         const [firstIndex, secondIndex] = [arrIndex[0], arrIndex[1]];
-        if (isAnnotation) {
-            return this.typeAnnotation.properties[secondIndex];
-        }
 
         if (place === 'left') {
             if (secondIndex === undefined) {
@@ -1219,34 +1131,35 @@ export class NewComposite extends LogicItem {
             });
             // 方便ts报错检查
             code += 'function __newComposite() {\n';
-            code += `let obj = nasl.util.New<${this.typeAnnotation.sortedTypeKey}>();`;
-            code += '\n';
+            code += `let __obj = nasl.util.New<${this.typeAnnotation.sortedTypeKey}>();\n`;
             // 是否是左边的顶层连线
             const leftTopIndex = this.assignmentLines.findIndex(({ leftIndex }) => leftIndex[1] === undefined);
             if (leftTopIndex !== -1) {
                 const rightIndex = this.assignmentLines[leftTopIndex].rightIndex;
                 const rightExpression = rightIndex[1] !== undefined ? this.rights[rightIndex[0]].members[rightIndex[1]] : this.rights[rightIndex[0]].expression;
-                code += `obj = ${rightExpression.toEmbeddedTS(shiftState(state, code, { inline: true }))};`;
+                code += `__obj = ${rightExpression.toEmbeddedTS(shiftState(state, code, { inline: true }))};`;
                 code += '\n';
             } else {
+                // 左侧properties的identifier的类型标注
+                code += 'const { ';
+                this.properties.forEach((item, index) => {
+                    code += item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    if (index < this.properties.length - 1)
+                        code += ', ';
+                });
+                code += ' } = __obj;\n';
                 this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
                     const leftSecondIndex = leftIndex[1];
                     const [rightFirst, rightSecond] = [rightIndex[0], rightIndex[1]];
                     const leftItem = this.properties[leftSecondIndex];
                     const rightItem = rightSecond !== undefined ? this.rights[rightFirst].members[rightSecond] : this.rights[rightFirst].expression;
                     const rightTs = rightMap.get(rightItem);
-                    code += `obj.${leftItem.name} = ${['__IDENTIFIER__', '__IDENTIFIER__()'].includes(rightTs) ? 'null' : rightTs};`;
-                    code += '\n';
-                });
-                // 左侧properties的identifier的类型标注
-                this.properties.forEach((item) => {
-                    code += '{ const ';
-                    const name = item.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                    code += `${name} = obj.${name};`;
-                    code += '}\n';
+                    code += `nasl.core.compareNew(`;
+                    code += `${['__IDENTIFIER__', '__IDENTIFIER__()'].includes(rightTs) ? 'null' : rightMap.get(rightItem)}, `;
+                    code += `${leftItem.toEmbeddedTS(shiftState(state, code, { inline: true }))});\n`;
                 });
             }
-            code += 'return obj;\n';
+            code += 'return __obj;\n';
             code += '};\n';
 
             code += 'return __newComposite();\n';
@@ -1280,24 +1193,35 @@ export class NewComposite extends LogicItem {
                 code += right.members.length ? '\n' : '';
             });
             // 方便ts报错检查
-            code += 'function __newComposite(): ';
-            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
-            code += '{\n';
-            this.properties.forEach((property) => {
+            code += 'function __newComposite() {\n';
+            this.properties.forEach((property, index) => {
+                const temp = `temp${index}`;
                 const name = property.name;
                 const rightItem = nameMap.get(name);
-                if (rightMap.get(rightItem) !== undefined) {
-                    code += `{ const x = ${rightMap.get(rightItem)}; const `;
+                const ts = rightMap.get(rightItem);
+                if (ts !== undefined) {
+                    if (['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+                        code += `const ${temp}: any = null; `;
+                    } else {
+                        code += `const ${temp}${ts === 'null' ? ':void' : ''} = ${ts}; `;
+                    }
+                    code += 'const ';
                     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                    code += `: nasl.core.Incompatible<typeof x, void> = x`;
-                    code += '; }\n';
+                    code += `: nasl.core.Incompatible<typeof ${temp}, void> = ${temp}`;
+                    code += ';\n';
                 } else {
-                    code += '{ const ';
+                    code += 'const ';
                     code += property.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                    code += '; }\n';
+                    code += ';\n';
                 }
             });
-            code += 'return;\n';
+            code += 'return {\n';
+            code += `__name: "AStructure_${genHash(JSON.stringify(this))}" as const,\n`;
+            this.properties.forEach((property) => {
+                code += `${property.name},\n`;
+            });
+            code += '}\n';
+
             code += '};\n';
 
             code += 'return __newComposite();\n';
@@ -1306,9 +1230,58 @@ export class NewComposite extends LogicItem {
         return code;
     }
 
-    __addIdentifier(App: App) {
-        const app = this.app || App;
-        app.emit('collect:start', {
+    getInitCode(state?: TranslatorState): string {
+        let code = '';
+        const nameMap = new Map();
+        const rightMap = new Map();
+        this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
+            const leftSecondIndex = leftIndex[1];
+            const [rightFirst, rightSecond] = [rightIndex[0], rightIndex[1]];
+            const leftItem = this.properties[leftSecondIndex];
+            const rightItem = rightSecond !== undefined ? this.rights[rightFirst].members[rightSecond] : this.rights[rightFirst].expression;
+            nameMap.set(leftItem.name, rightItem);
+            rightMap.set(rightItem, null);
+        });
+        code += '(() => { ';
+        // 提供sourcemap，获取类型标注和上下文可选变量
+        this.rights.forEach((right) => {
+            let ts = right.expression.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            if (rightMap.has(right.expression))
+                rightMap.set(right.expression, ts);
+            right.members.forEach((member) => {
+                ts = member.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                if (rightMap.has(member))
+                    rightMap.set(member, ts);
+            });
+        });
+        // 方便ts报错检查
+        code += 'function __newComposite() { ';
+        this.properties.forEach((property) => {
+            const name = property.name;
+            const rightItem = nameMap.get(name);
+            const ts = rightMap.get(rightItem);
+            if (ts !== undefined) {
+                code += `const ${name} = ${['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts}; `;
+            } else {
+                code += `const ${name}; `;
+            }
+        });
+        code += '\nreturn {\n';
+        code += `__name: "AStructure_${genHash(JSON.stringify(this))}" as const,\n`;
+        this.properties.forEach((property) => {
+            code += `${property.name},\n`;
+        });
+        code += '}\n';
+
+        code += '};\n';
+
+        code += 'return __newComposite();\n';
+        code += '})()';
+        return code;
+    }
+
+    __addIdentifier() {
+        this.app.emit('collect:start', {
             actionMsg: '添加匿名数据结构属性',
         });
         const node = this.addIdentifier({ name: this.getIdentifierUniqueName('property1') });
@@ -1317,13 +1290,13 @@ export class NewComposite extends LogicItem {
             typeAnnotation: null,
         });
         this.typeAnnotation.addStructureProperty(struct);
-        app.emit('collect:end');
+        this.app.emit('collect:end');
     }
 
     __deleteIdentifier(property: Identifier) {
         const index = this.properties.findIndex((p) => p === property);
         const newLines: AssignmentLine[] = [];
-        const newProperties = [...this.typeAnnotation.properties.slice(0, index), ...this.typeAnnotation.properties.slice(index + 1, this.properties.length)];
+        const newProperties = this.typeAnnotation.properties.filter((item) => item.name !== property.name);
         this.assignmentLines.forEach((line) => {
             const { leftIndex } = line;
             if (leftIndex[1] < index) {

package/src/concepts/NewList__.ts

@@ -326,6 +326,22 @@ export class NewList extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    toBrief(): string {
+        let code = '';
+        code += '[ ';
+        this.items.forEach((value, index) => {
+            if (index >= 10)
+                return;
+            if (index)
+                code += '，';
+            code += value.toBrief();
+        });
+        if (this.items.length > 10)
+            code += ', ...';
+        code += ' ]';
+        return code;
+    }
+
     toUI(state?: TranslatorState): string {
         let code = '';
         code += '[';
@@ -376,11 +392,16 @@ export class NewList extends LogicItem {
             code += '(() => { \n';
             const arr: any = [];
             this.items.forEach((item, index) => {
+                if (item.concept === 'Unparsed')
+                    return;
+                code += 'nasl.core.ensureVoid(';
                 arr.push(item.toEmbeddedTS(shiftState(state, code, { inline: true })));
                 code += arr[index];
-                code += '; ';
+                code += '); ';
             });
             code += '\n';
+            if (!arr.length || arr.every((item: any) => ['__IDENTIFIER__', '__IDENTIFIER__()', 'null'].includes(item)))
+                code += '__IDENTIFIER__;\n';
             // ts报错检查
             code += 'function __newComposite() {\n';
             if (this.items.length === 0) {
@@ -413,7 +434,7 @@ export class NewList extends LogicItem {
             code += 'let arr = [';
             this.items.forEach((item, index) => {
                 const ts = item.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                code += ts === '__IDENTIFIER__' ? null : ts;
+                code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
                 if (index + 1 < this.items.length)
                     code += ', ';
             });

package/src/concepts/NewMap__.ts

@@ -43,8 +43,6 @@ export class NewMap extends LogicItem {
     @property('LogicItem')
     values: Array<LogicItem> = [];
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -58,7 +56,6 @@ export class NewMap extends LogicItem {
         return super.from(source, parentNode, parentKey) as NewMap;
     }
 
-    
     /**
      * 设置类型
      */
@@ -98,7 +95,7 @@ export class NewMap extends LogicItem {
         });
     }
 
-        getItemExistingNames(excludedList: Array<LogicItem> = []) {
+    getItemExistingNames(excludedList: Array<LogicItem> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.keys as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -372,9 +369,6 @@ export class NewMap extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
     * 删除类型标注
     * @param name 类型标注名称
@@ -423,8 +417,6 @@ export class NewMap extends LogicItem {
         return params;
     }
 
-
-
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -450,8 +442,6 @@ export class NewMap extends LogicItem {
         return logicItem.delete();
     }
 
-    
-
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -516,7 +506,7 @@ export class NewMap extends LogicItem {
         this.update({
             keys: [...this.keys, undefined],
             values: [...this.values, undefined],
-        })
+        });
     }
 
     removePair(idx: number) {
@@ -527,7 +517,24 @@ export class NewMap extends LogicItem {
         this.update({
             keys: k,
             values: v,
-        })
+        });
+    }
+
+    toBrief(): string {
+        let code = '';
+        code += '[<br />';
+        this.keys.forEach((key, index) => {
+            if (index >= 10)
+                return;
+            const value = this.values[index];
+            code += '&nbsp;&nbsp;&nbsp;&nbsp;';
+            code += `${key ? key.toBrief() : 'null'} -> ${value ? value.toBrief() : 'null'}`;
+            code += '<br />';
+        });
+        if (this.keys.length > 10)
+            code += '&nbsp;&nbsp;&nbsp;&nbsp...<br />';
+        code += ']';
+        return code;
     }
 
     toJS(state?: TranslatorState): string {
@@ -576,48 +583,65 @@ export class NewMap extends LogicItem {
             code += 'return __newComposite();\n';
             code += '})()';
         } else {
-            if (this.keys.length) {
+            if (this.keys.some((key) => key) || this.values.some((value) => value)) {
                 code += '(() => { \n';
                 const valueTsArr: any = [];
                 let keyTs = 'null';
-                let keyBol = false;
-                this.keys.forEach((key) => {
+                let valueTs = false;
+                let keyIndex = -1;
+                this.keys.forEach((key, index) => {
                     if (key) {
                         const ts = key.toEmbeddedTS(shiftState(state, code, { inline: true }));
-                        if (!keyBol && !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
-                            keyBol = true;
+                        if (keyIndex === -1 && !['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts)) {
+                            keyIndex = index;
                             keyTs = ts;
                         }
                     }
                 });
                 this.values.forEach((item, index) => {
+                    if (item)
+                        valueTs = true;
+                    code += 'nasl.core.ensureVoid(';
                     const ts = item ? item.toEmbeddedTS(shiftState(state, code, { inline: true })) : null;
                     valueTsArr.push(ts);
                     code += valueTsArr[index];
-                    code += '; ';
+                    code += '); ';
                 });
                 code += '\n';
+                if (keyTs === 'null' || !valueTs) {
+                    code += '__IDENTIFIER__;\n';
+                }
                 // 方便ts报错检查
                 code += 'function __newComposite() {\n';
                 this.keys.forEach((key: any) => {
-                    code += `nasl.core.compare2(${keyTs}, `;
+                    if (!key)
+                        return;
+                    code += `nasl.core.compareNew(${keyTs}, `;
                     code += key.toEmbeddedTS(shiftState(state, code, { inline: true }));
                     code += ');\n';
                 });
-                code += `return nasl.util.NewMap(${keyTs}, `;
+                code += `return nasl.util.NewMap(`;
+                code += `${keyIndex === -1 ? 'null' : this.keys[keyIndex].toEmbeddedTS(shiftState(state, code, { inline: true }))}, ...[`;
                 valueTsArr.forEach((ts: any, index: number) => {
                     code += ['__IDENTIFIER__', '__IDENTIFIER__()'].includes(ts) ? null : ts;
                     if (index + 1 < this.values.length)
                         code += ', ';
                 });
-                code += ');\n';
+                code += ']);\n';
 
                 code += '};\n';
 
                 code += 'return __newComposite();\n';
                 code += '})()';
             } else {
-                code += `nasl.util.NewMap(${null}, ${null})`;
+                code += '(() => {\n';
+                code += '__IDENTIFIER__;\n';
+                code += 'function __newComposite() {\n';
+                code += `return nasl.util.NewMap(${null}, ${null});\n`;
+                code += '};\n';
+
+                code += 'return __newComposite();\n';
+                code += '})()';
             }
         }
         return code;
@@ -625,7 +649,7 @@ export class NewMap extends LogicItem {
 
     getInitCode(state?: TranslatorState): string {
         let code = '';
-        if (this.keys.length) {
+        if (this.keys.some((key) => key) || this.values.some((value) => value)) {
             let keyBol = false;
             code += `nasl.util.NewMap(`;
             this.keys.forEach((key) => {