@lcap/nasl 3.3.2-beta.1 → 3.3.2-beta.3

package/coverage/src/natural/transformTSCode.ts.html

@@ -23,30 +23,30 @@
         <div class='clearfix'>
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">2.29% </span>
+                <span class="strong">2.27% </span>
                 <span class="quiet">Statements</span>
-                <span class='fraction'>9/393</span>
+                <span class='fraction'>9/396</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">0% </span>
                 <span class="quiet">Branches</span>
-                <span class='fraction'>0/305</span>
+                <span class='fraction'>0/311</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
                 <span class="strong">0% </span>
                 <span class="quiet">Functions</span>
-                <span class='fraction'>0/80</span>
+                <span class='fraction'>0/81</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">2.43% </span>
+                <span class="strong">2.41% </span>
                 <span class="quiet">Lines</span>
-                <span class='fraction'>9/370</span>
+                <span class='fraction'>9/373</span>
             </div>
         
             
@@ -1264,7 +1264,6 @@
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
@@ -1297,6 +1296,17 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-no">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-no">&nbsp;</span>
+<span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
@@ -1304,6 +1314,8 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
@@ -1319,6 +1331,8 @@
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
+<span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
@@ -1757,20 +1771,6 @@
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-no">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
 <span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">/* eslint-disable global-require */
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import * as babel from '@babel/core';
@@ -2118,24 +2118,24 @@ export function <span class="fstat-no" title="function not covered" >transformTS
           typeArguments: node?.typeParameters?.params.map(<span class="fstat-no" title="function not covered" >(c</span>urType: any) =&gt; <span class="cstat-no" title="statement not covered" >transformTypeAnnotation({ ...curType, typeNamespace }))</span>,
         });
         // console.log('lemon ~ callFunction ~ 3:', nodeElement);
-        return nodeElement;
-      }<span class="cstat-no" title="statement not covered" ></span>
-      if (callee.length === 3 &amp;&amp; calleeName.startsWith('nasl.ui.')) {
+<span class="cstat-no" title="statement not covered" >        return nodeElement;</span>
+      }
+<span class="cstat-no" title="statement not covered" >      if (callee.length === 3 &amp;&amp; calleeName.startsWith('nasl.ui.')) {</span>
 <span class="cstat-no" title="statement not covered" >        if ((callee[2] as babelTypes.Identifier).name === 'destination') {</span>
-<span class="cstat-no" title="statement not covered" >          const namespace = (node.arguments[0] as babelTypes.StringLiteral).value;</span>
-          const nsArr = names<span class="cstat-no" title="statement not covered" >pace.split('.').map((item) =&gt; item.replace(/_view$/, </span>''));
-          const viewName<span class="cstat-no" title="statement not covered" > = nsArr.pop();<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
-<span class="cstat-no" title="statement not covered" ></span>
-          return new naslTypes.Destination({
-<span class="cstat-no" title="statement not covered" >            viewNamespace: `app.frontends.pc.views${nsArr.map((item) =&gt; `.${item}.views`).join('')}`, // viewNamespace</span>
-            viewName, // viewName<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
-            arguments: node.arguments.slice(1).map((arg) =&gt; new naslTypes.Argument({
-              expression: transformLogicNode(arg),<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
+          const namespace = (<span class="cstat-no" title="statement not covered" >node.arguments[0] as babelTypes.StringLiteral).value;</span>
+          const nsArr = <span class="cstat-no" title="statement not covered" >namespace.split('.').map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >item.replace(/_view$/, ''))</span>;</span>
+          const viewName = <span class="cstat-no" title="statement not covered" >nsArr.pop();</span>
+&nbsp;
+<span class="cstat-no" title="statement not covered" >          return new naslTypes.Destination({</span>
+            viewNamespace: `app.frontends.pc.views${nsArr.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >`.${item}.views`)</span>.join('')}`, // viewNamespace
+            viewName, // viewName
+            arguments: node.arguments.slice(1).map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
+              expression: transformLogicNode(arg),
             })) as naslTypes.Argument[],
           });
         }
-        return new naslTypes.CallLogic({
-<span class="cstat-no" title="statement not covered" >          calleeNamespace: 'nasl.ui',</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallLogic({</span>
+          calleeNamespace: 'nasl.ui',
           calleeName: (callee[2] as babelTypes.Identifier).name,
           shortcut: true,
           /**
@@ -2143,411 +2143,411 @@ export function <span class="fstat-no" title="function not covered" >transformTS
            * @param node
            * @returns
            */
-          arguments: node.arguments.map((arg) =&gt; new naslTypes.Argument({
-            expression: transformLogicNo<span class="fstat-no" title="function not covered" >de</span>(arg),<span class="cstat-no" title="statement not covered" ></span>
+          arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
+            expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
       }
-      if (calleeName.endsWith('.map')) {
+<span class="cstat-no" title="statement not covered" >      if (calleeName.endsWith('.map')) {</span>
 <span class="cstat-no" title="statement not covered" >        return new naslTypes.CallFunction({</span>
-          calleeNamespace:<span class="cstat-no" title="statement not covered" > 'nasl.util',</span>
-          calleeName: 'ListTra<span class="cstat-no" title="statement not covered" >nsform',</span>
-          arguments: [new na<span class="cstat-no" title="statement not covered" >slTypes.Argument({</span>
+          calleeNamespace: 'nasl.util',
+          calleeName: 'ListTransform',
+          arguments: [new naslTypes.Argument({
             expression: transformLogicNode((node.callee as babelTypes.MemberExpression).object),
-          }), ...node.arguments.map((arg: any) =&gt; new naslTypes.Argument({
+          }), ...node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg: any) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
             expression: transformLogicNode(arg),
           }))],
         });
-      }<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ></span></span></span></span>
-      if (calleeName === 'ForEach') {
-<span class="cstat-no" title="statement not covered" >        const newCallee = no</span>de.arguments;
-        const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
-<span class="cstat-no" title="statement not covered" >        const nodeElement = new naslTypes.ForEachStatement({</span>
-          each: transformLogicN<span class="cstat-no" title="statement not covered" >ode(newCallee[0]),</span>
-<span class="cstat-no" title="statement not covered" >          start: transformLogicNode(newCallee[1]),</span>
-          end: transformLogic<span class="cstat-no" title="statement not covered" >Node(newCallee[2]),</span>
-          item: transformParam(a<span class="cstat-no" title="statement not covered" >rrowFunction.params[0] as babelTypes.Identifier),</span>
-          index: arrowFunction<span class="cstat-no" title="statement not covered" >.params[1] ? transformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({</span>
+      }
+<span class="cstat-no" title="statement not covered" >      if (calleeName === 'ForEach') {</span>
+        const newCallee = <span class="cstat-no" title="statement not covered" >node.arguments;</span>
+        const arrowFunction = <span class="cstat-no" title="statement not covered" >node.arguments[3] as babelTypes.ArrowFunctionExpression;</span>
+        const nodeElement = <span class="cstat-no" title="statement not covered" >new naslTypes.ForEachStatement({</span>
+          each: transformLogicNode(newCallee[0]),
+          start: transformLogicNode(newCallee[1]),
+          end: transformLogicNode(newCallee[2]),
+          item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
+          index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
             name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
           }),
-          body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) =&gt; transformLogicNode(item)).filter((item) =&gt; !!item),
+          body: (arrowFunction.body as babelTypes.BlockStatement).body.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
         });
-        return nodeElement;
-      }<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ></span></span></span></span>
-      if (callee.length === 2) {
-        co<span class="cstat-no" title="statement not covered" >nst curCalleeName = </span>(node.callee as any).property.name;
-        if (curCalleeName === 'forEach') {
-          con<span class="cstat-no" title="statement not covered" >st newCallee = (node.callee as any).object;</span>
-<span class="cstat-no" title="statement not covered" >          const arrowFunction = node.arguments[0] as babelTypes.Arro</span>wFunctionExpression;
-          con<span class="cstat-no" title="statement not covered" >st nodeElement = new naslTypes.ForEachStatement({</span>
-<span class="cstat-no" title="statement not covered" >            each: transformLogicNode(newCallee.callee.object),</span>
+<span class="cstat-no" title="statement not covered" >        return nodeElement;</span>
+      }
+<span class="cstat-no" title="statement not covered" >      if (callee.length === 2) {</span>
+        const curCalleeName = (<span class="cstat-no" title="statement not covered" >node.callee as any).property.name;</span>
+<span class="cstat-no" title="statement not covered" >        if (curCalleeName === 'forEach') {</span>
+          const newCallee = (<span class="cstat-no" title="statement not covered" >node.callee as any).object;</span>
+          const arrowFunction = <span class="cstat-no" title="statement not covered" >node.arguments[0] as babelTypes.ArrowFunctionExpression;</span>
+          const nodeElement = <span class="cstat-no" title="statement not covered" >new naslTypes.ForEachStatement({</span>
+            each: transformLogicNode(newCallee.callee.object),
             start: transformLogicNode(newCallee?.arguments?.[0]),
             end: transformLogicNode(newCallee?.arguments?.[1]),
             item: transformParam(arrowFunction.params[0] as babelTypes.Identifier),
-            index: arrowFunction.params[<span class="fstat-no" title="function not covered" >1]</span> ? tran<span class="cstat-no" title="statement not covered" >sformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({</span>
+            index: arrowFunction.params[1] ? transformParam(arrowFunction.params[1] as babelTypes.Identifier) : new naslTypes.Param({
               name: 'index', typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Long'),
             }),
-            body: (arrowFunction.body as babelTypes.BlockStatement).body.map((item) =&gt; transformLogicNode(item)).filter((item) =&gt; !!item),
-          });<span class="cstat-no" title="statement not covered" ></span>
+            body: (arrowFunction.body as babelTypes.BlockStatement).body.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
+          });
 <span class="cstat-no" title="statement not covered" >          return nodeElement;</span>
         }
-      } else if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(calleeName)) {
-        return handleBinaryExpression(ca<span class="fstat-no" title="function not covered" >ll</span>eeName,<span class="cstat-no" title="statement not covered" > node?.arguments);</span>
-      } else if (calleeName === 'alert') {
-        return new naslTypes.CallLogic({
+      } else <span class="cstat-no" title="statement not covered" >if (['plus', 'minus', 'multiply', 'divide', 'remainder'].includes(calleeName)) {</span>
+<span class="cstat-no" title="statement not covered" >        return handleBinaryExpression(calleeName, node?.arguments);</span>
+      } else <span class="cstat-no" title="statement not covered" >if (calleeName === 'alert') {</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallLogic({</span>
           calleeNamespace: 'nasl.ui',
-          cal<span class="cstat-no" title="statement not covered" >leeName: 'showMessage',</span>
-<span class="cstat-no" title="statement not covered" >          shortcut: true,</span>
-<span class="cstat-no" title="statement not covered" >          arguments: node.arguments.map((arg) =&gt; new naslTypes.Argument({</span>
+          calleeName: 'showMessage',
+          shortcut: true,
+          arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
-        });<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
-      } else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
-        return new naslTypes.CallLogic({
+        });
+      } else <span class="cstat-no" title="statement not covered" >if (/^app.dataSources|app.logics|load/.test(calleeName)) {</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallLogic({</span>
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-<span class="cstat-no" title="statement not covered" >          arguments: node.arguments.map((arg) =&gt; new naslTypes.Argument({</span>
+          arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
-        });<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
-      } else if (callee.length === 1) {
-        if (calleeName.startsWith('viewLogic_')) {
-          return new naslTypes.CallLogic({
-            c<span class="cstat-no" title="statement not covered" >alleeNamespace: '',</span>
-<span class="cstat-no" title="statement not covered" >            calleeName: calleeName.slice('viewLogic_'.length),</span>
-            arguments: node.arguments.map((arg) =&gt; new naslTypes.Argument({
+        });
+      } else <span class="cstat-no" title="statement not covered" >if (callee.length === 1) {</span>
+<span class="cstat-no" title="statement not covered" >        if (calleeName.startsWith('viewLogic_')) {</span>
+<span class="cstat-no" title="statement not covered" >          return new naslTypes.CallLogic({</span>
+            calleeNamespace: '',
+            calleeName: calleeName.slice('viewLogic_'.length),
+            arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
               expression: transformLogicNode(arg),
-            })) as naslTypes.Argument[],<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
+            })) as naslTypes.Argument[],
           });
         }
-        return new naslTypes.CallLogic({
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallLogic({</span>
           calleeNamespace: `app.logics`,
           calleeName,
-          arguments: node.arguments.map((arg) =&gt; new naslTypes.Argument({
+          arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
-      } else if (/interfaces/.test(calleeName)) {
-        return new naslTypes.CallInterface({
+      } else <span class="cstat-no" title="statement not covered" >if (/interfaces/.test(calleeName)) {</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallInterface({</span>
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node.arguments.map((arg: any) =&gt; new naslTypes.Argument({
+          arguments: node.arguments.map(<span class="fstat-no" title="function not covered" >(a</span>rg: any) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.Argument({</span>
             keyword: arg.properties[0].key.name,
             expression: transformLogicNode(arg.properties[0].value),
-          }<span class="cstat-no" title="statement not covered" >)) as naslTypes.Argument[],</span>
+          })) as naslTypes.Argument[],
         });
-      }<span class="cstat-no" title="statement not covered" ></span>
-      //<span class="cstat-no" title="statement not covered" > else if (/destination/.test(calleeName)) {</span>
-      //   const newCall<span class="cstat-no" title="statement not covered" >ee = flatMemberExpression((node.callee as any).object);</span>
+      }
+      // else if (/destination/.test(calleeName)) {
+      //   const newCallee = flatMemberExpression((node.callee as any).object);
       //   return new naslTypes.Destination({
       //     viewNamespace: generate((node.callee as any).object.object).code,
-      //     viewName: (newCallee[newCallee.length - 1] as babelTy<span class="fstat-no" title="function not covered" >pe</span>s.Identifier).<span class="cstat-no" title="statement not covered" >name,</span>
+      //     viewName: (newCallee[newCallee.length - 1] as babelTypes.Identifier).name,
       //     target: (node.arguments[0] as any).properties[1].value.value,
-      //     anchor: new naslTypes.Anchor({<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ></span></span></span></span></span></span>
+      //     anchor: new naslTypes.Anchor({
       //       expression: transformLogicNode((node.arguments[0] as any).properties[0].value),
       //     }),
-      //  <span class="cstat-no" title="statement not covered" > });</span>
-      // }<span class="cstat-no" title="statement not covered" ></span>
-      else if (node.callee.type === 'ArrowFunctionExpression') {
+      //   });
+      // }
+      else <span class="cstat-no" title="statement not covered" >if (node.callee.type === 'ArrowFunctionExpression') {</span>
         // NOTE: 适用于 if else
-        const newCallee = (node.callee.body as any).body;
-        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {
-<span class="cstat-no" title="statement not covered" >          const match = new na<span class="fstat-no" title="function not covered" >sl</span>Types.Match({</span>
-<span class="cstat-no" title="statement not covered" >            expression: transformLogicNode(newCallee[0]),</span>
-            is<span class="cstat-no" title="statement not covered" >Expression: type === 'expression',</span>
-            cases: flatIfStatement(newCallee[1].body.body[0]).map((_case: any) =&gt; new naslTypes.MatchCase({
-<span class="cstat-no" title="statement not covered" >              patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)) as any,</span>
-<span class="cstat-no" title="statement not covered" >              body: _case.consequent.body.filter((</span>item: any) =&gt; item.type !== 'BreakStatement').map((item: any) =&gt; transformLogicNode(item)).filter((item: any) =&gt; !!item),
-            })<span class="cstat-no" title="statement not covered" >),</span>
+        const newCallee = (<span class="cstat-no" title="statement not covered" >node.callee.body as any).body;</span>
+<span class="cstat-no" title="statement not covered" >        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__MatchExpressionFuntion') {</span>
+          const match = <span class="cstat-no" title="statement not covered" >new naslTypes.Match({</span>
+            expression: transformLogicNode(newCallee[0]),
+            isExpression: type === 'expression',
+            cases: flatIfStatement(newCallee[1].body.body[0]).map(<span class="fstat-no" title="function not covered" >(_</span>case: any) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.MatchCase({</span>
+              patterns: !_case.test ? [] : flatMatchPatternsExpression(transformLogicNode(_case.test)) as any,
+              body: _case.consequent.body.filter(<span class="fstat-no" title="function not covered" >(i</span>tem: any) =&gt; <span class="cstat-no" title="statement not covered" >item.type !== 'BreakStatement')</span>.map(<span class="fstat-no" title="function not covered" >(i</span>tem: any) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem: any) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
+            })),
           });
-          if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-            match.cases.push(new naslTypes.MatchCase({
+<span class="cstat-no" title="statement not covered" >          if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {</span>
+<span class="cstat-no" title="statement not covered" >            match.cases.push(new naslTypes.MatchCase({</span>
               patterns: [],
               body: [],
             }));
           }
-          match.cases.forEach((case_: any) =&gt; {
-            if (case_.body.length &amp;&amp; (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-              case_.isMatchedTypeEnumable = true;
+<span class="cstat-no" title="statement not covered" >          match.cases.forEach(<span class="fstat-no" title="function not covered" >(c</span>ase_: any) =&gt; {</span>
+<span class="cstat-no" title="statement not covered" >            if (case_.body.length &amp;&amp; (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {</span>
+<span class="cstat-no" title="statement not covered" >              case_.isMatchedTypeEnumable = true;</span>
             }
-            if (case_.patterns.length &amp;&amp; case_.patterns[0].concept === 'MemberExpression') {
-              case_.isMatchedTypeEnumable = true;
-              case_.patterns[0] = new naslTypes.MemberExpression({
-<span class="cstat-no" title="statement not covered" >                object: </span>{
+<span class="cstat-no" title="statement not covered" >            if (case_.patterns.length &amp;&amp; case_.patterns[0].concept === 'MemberExpression') {</span>
+<span class="cstat-no" title="statement not covered" >              case_.isMatchedTypeEnumable = true;</span>
+<span class="cstat-no" title="statement not covered" >              case_.patterns[0] = new naslTypes.MemberExpression({</span>
+                object: {
                   concept: 'Identifier',
-<span class="cstat-no" title="statement not covered" >                  name: case_.patterns[0].object.property.name,</span>
-                  folded: false,<span class="cstat-no" title="statement not covered" ></span>
-<span class="cstat-no" title="statement not covered" >                  namespace: 'app.</span>enums'
+                  name: case_.patterns[0].object.property.name,
+                  folded: false,
+                  namespace: 'app.enums'
                 } as any,
-<span class="cstat-no" title="statement not covered" >                property: {</span>
-<span class="cstat-no" title="statement not covered" >                  concept: 'Identifier',</span>
-<span class="cstat-no" title="statement not covered" >                  name: case_.patterns[0].property.value,</span>
+                property: {
+                  concept: 'Identifier',
+                  name: case_.patterns[0].property.value,
                   folded: false,
                 } as any,
-<span class="cstat-no" title="statement not covered" >              });</span>
-<span class="cstat-no" title="statement not covered" >            }</span>
-<span class="cstat-no" title="statement not covered" >          });<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
-          return match;
+              });
+            }
+          });
+<span class="cstat-no" title="statement not covered" >          return match;</span>
         }
-        if <span class="cstat-no" title="statement not covered" >(newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {</span>
-<span class="cstat-no" title="statement not covered" >          const switchStatement = transformLogicNode(newCallee[0].body.body[0]);</span>
-          return switchStatement<span class="cstat-no" title="statement not covered" >;</span>
+<span class="cstat-no" title="statement not covered" >        if (newCallee[newCallee.length - 1].argument?.callee?.name === '__SwitchExpressionFuntion') {</span>
+          const switchStatement = <span class="cstat-no" title="statement not covered" >transformLogicNode(newCallee[0].body.body[0]);</span>
+<span class="cstat-no" title="statement not covered" >          return switchStatement;</span>
         }
-        console.error(node);
+<span class="cstat-no" title="statement not covered" >        console.error(node);</span>
 <span class="cstat-no" title="statement not covered" >        if (debug) {</span>
-<span class="cstat-no" title="statement not covered" >          throw new Error(`Unhan</span>dled ArrowFunctionExpression node ${node.type}`);
+<span class="cstat-no" title="statement not covered" >          throw new Error(`Unhandled ArrowFunctionExpression node ${node.type}`);</span>
         }
-<span class="cstat-no" title="statement not covered" >      } else {</span>
-        console.error(node);
-        if (debug) {<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ></span></span></span></span>
-          throw new Error(`Unhandled node ${callee.map((item: babelTypes.Identifier) =&gt; item.name<span class="fstat-no" title="function not covered" >).</span>join('.'<span class="cstat-no" title="statement not covered" >)} ${node.type}`);<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
+      } else {
+<span class="cstat-no" title="statement not covered" >        console.error(node);</span>
+<span class="cstat-no" title="statement not covered" >        if (debug) {</span>
+<span class="cstat-no" title="statement not covered" >          throw new Error(`Unhandled node ${callee.map(<span class="fstat-no" title="function not covered" >(i</span>tem: babelTypes.Identifier) =&gt; <span class="cstat-no" title="statement not covered" >item.name)</span>.join('.')} ${node.type}`);</span>
         }
-      }<span class="cstat-no" title="statement not covered" ></span>
-    } <span class="cstat-no" title="statement not covered" >else if (node.type === 'IfStatement') {</span>
-      if (node.alternate &amp;&amp; node.alternate.type === 'IfStatement') {
-        const switchStatement = new naslTypes.SwitchStatement({<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ><span class="fstat-no" title="function not covered" ></span></span></span></span>
+      }
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'IfStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      if (node.alternate &amp;&amp; node.alternate.type === 'IfStatement') {</span>
+        const switchStatement = <span class="cstat-no" title="statement not covered" >new naslTypes.SwitchStatement({</span>
           cases: [],
-        });<span class="cstat-no" title="statement not covered" ></span>
-        pushElseIf(n<span class="cstat-no" title="statement not covered" >ode, switchStatement);</span>
-        return switchStatement;
+        });
+<span class="cstat-no" title="statement not covered" >        pushElseIf(node, switchStatement);</span>
+<span class="cstat-no" title="statement not covered" >        return switchStatement;</span>
       }
-      return new naslTypes.IfS<span class="fstat-no" title="function not covered" >ta</span>tement({<span class="cstat-no" title="statement not covered" ></span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.IfStatement({</span>
         test: transformLogicNode(node.test),
-        consequent: !node.consequent ? [<span class="fstat-no" title="function not covered" >] </span>: (node.<span class="cstat-no" title="statement not covered" >consequent as babelTypes.BlockS</span>tatem<span class="fstat-no" title="function not covered" >en</span>t).body.<span class="cstat-no" title="statement not covered" >map((item) =&gt; transformLo</span>gicNode(<span class="fstat-no" title="function not covered" >it</span>em)).fil<span class="cstat-no" title="statement not covered" >ter((it</span>em) =&gt; !!item),
-        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) =&gt; transformLogicNode(item)).filter((item) =&gt; !!item),
+        consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
+        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
       });
-    } <span class="cstat-no" title="statement not covered" >else if (node.type === 'WhileStatement') {</span>
-      re<span class="cstat-no" title="statement not covered" >turn new naslTypes.WhileStatement({</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'WhileStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.WhileStatement({</span>
         test: transformLogicNode(node.test),
-        body: (node.body as babelTypes.BlockStatement).body.map((item) =&gt; transformLogicNode(item)).filter((item) =&gt; !!item),
+        body: (node.body as babelTypes.BlockStatement).body.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
       });
-    } else if (node.type === 'SwitchStatement') {
-<span class="cstat-no" title="statement not covered" >      const match = new na<span class="fstat-no" title="function not covered" >sl</span>Types.Match({</span>
-<span class="cstat-no" title="statement not covered" >        expression: transformLogicNode(node.discriminant),</span>
-        is<span class="cstat-no" title="statement not covered" >Expression: type === 'expression',</span>
-        cases: node.cases.map((_case) =&gt; new naslTypes.MatchCase({
-<span class="cstat-no" title="statement not covered" >          patterns: !_case.test ? [] : [transformLogicNode(_case.test)],</span>
-<span class="cstat-no" title="statement not covered" >          body: _case.consequent.filter((item)</span> =&gt; item.type !== 'BreakStatement').map((item) =&gt; transformLogicNode(item)).filter((item) =&gt; !!item),
-        })<span class="cstat-no" title="statement not covered" >),</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'SwitchStatement') {</span>
+      const match = <span class="cstat-no" title="statement not covered" >new naslTypes.Match({</span>
+        expression: transformLogicNode(node.discriminant),
+        isExpression: type === 'expression',
+        cases: node.cases.map(<span class="fstat-no" title="function not covered" >(_</span>case) =&gt; <span class="cstat-no" title="statement not covered" >new naslTypes.MatchCase({</span>
+          patterns: !_case.test ? [] : [transformLogicNode(_case.test)],
+          body: _case.consequent.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >item.type !== 'BreakStatement')</span>.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>.filter(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >!!item)</span>,
+        })),
       });
-      if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
-<span class="cstat-no" title="statement not covered" >        match.cases.</span>push(new naslTypes.MatchCase({
-          p<span class="cstat-no" title="statement not covered" >atterns: [],</span>
-<span class="cstat-no" title="statement not covered" >          body: [],</span>
-<span class="cstat-no" title="statement not covered" >        }));</span>
+<span class="cstat-no" title="statement not covered" >      if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {</span>
+<span class="cstat-no" title="statement not covered" >        match.cases.push(new naslTypes.MatchCase({</span>
+          patterns: [],
+          body: [],
+        }));
       }
-      match.cases.forEach((case_: any) =&gt; {
-        if (case_.body.length &amp;&amp; (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {
-          case_.isMatchedTypeEnumable = true;
+<span class="cstat-no" title="statement not covered" >      match.cases.forEach(<span class="fstat-no" title="function not covered" >(c</span>ase_: any) =&gt; {</span>
+<span class="cstat-no" title="statement not covered" >        if (case_.body.length &amp;&amp; (case_.body[0].concept === 'BooleanLiteral' || case_.body[0].concept === 'StringLiteral')) {</span>
+<span class="cstat-no" title="statement not covered" >          case_.isMatchedTypeEnumable = true;</span>
         }
-        if (case_.patterns.length &amp;&amp; case_.patterns[0].concept === 'MemberExpression') {
-          case_.isMatchedTypeEnumable = true;
-          case_.patterns[0].object.namespace = 'app.enums';
+<span class="cstat-no" title="statement not covered" >        if (case_.patterns.length &amp;&amp; case_.patterns[0].concept === 'MemberExpression') {</span>
+<span class="cstat-no" title="statement not covered" >          case_.isMatchedTypeEnumable = true;</span>
+<span class="cstat-no" title="statement not covered" >          case_.patterns[0].object.namespace = 'app.enums';</span>
         }
       });
-      return match;
-    } else if (node.type === 'MemberExpression') {
+<span class="cstat-no" title="statement not covered" >      return match;</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'MemberExpression') {</span>
 <span class="cstat-no" title="statement not covered" >      if (node.property.type === 'NumericLiteral') {</span>
-        return new naslTypes.CallFunction({
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.CallFunction({</span>
           calleeNamespace: 'nasl.util',
           calleeName: 'Get',
-          a<span class="cstat-no" title="statement not covered" >rguments: [</span>
-<span class="cstat-no" title="statement not covered" >            new naslTypes.Argument({</span>
+          arguments: [
+            new naslTypes.Argument({
               expression: transformLogicNode(node.object),
             }),
-<span class="cstat-no" title="statement not covered" >            new naslTypes.Argument({</span>
-<span class="cstat-no" title="statement not covered" >              expression: transformLogicNode(node.</span>property),
-<span class="cstat-no" title="statement not covered" >            }),</span>
-<span class="cstat-no" title="statement not covered" >          ],</span>
-<span class="cstat-no" title="statement not covered" >        });</span>
-      }<span class="cstat-no" title="statement not covered" ></span>
-      return new naslTypes.MemberExpression({
+            new naslTypes.Argument({
+              expression: transformLogicNode(node.property),
+            }),
+          ],
+        });
+      }
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.MemberExpression({</span>
         object: transformLogicNode(node.object),
         property: transformLogicNode(node.property),
       });
-    } else if (node.type === 'Identifier') {
-      re<span class="cstat-no" title="statement not covered" >turn new naslTypes.Identifier({</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'Identifier') {</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.Identifier({</span>
         name: node.name,
       });
-    } else if (node.type === 'ExpressionStatement') {
-      return transformLogicNode(node.expression);
-    } else if (node.type === 'AssignmentExpression') {
-      if (node.operator === '+=' || node.operator === '-=') {
-        if (type === 'expression') {
-          return new naslTypes.BinaryExpression({
-<span class="cstat-no" title="statement not covered" >            operator: node.operator[0] as '+' | '-',</span>
-<span class="cstat-no" title="statement not covered" >            left: transformLogicNode(node.left)</span>,
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'ExpressionStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      return transformLogicNode(node.expression);</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'AssignmentExpression') {</span>
+<span class="cstat-no" title="statement not covered" >      if (node.operator === '+=' || node.operator === '-=') {</span>
+<span class="cstat-no" title="statement not covered" >        if (type === 'expression') {</span>
+<span class="cstat-no" title="statement not covered" >          return new naslTypes.BinaryExpression({</span>
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.left),
             right: transformLogicNode(node.right),
-<span class="cstat-no" title="statement not covered" >          });</span>
+          });
         }
-        return new naslTypes.Assignment({
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.Assignment({</span>
           left: transformLogicNode(node.left),
-          r<span class="cstat-no" title="statement not covered" >ight: new naslTypes.BinaryExpression({</span>
-            operator: nod<span class="cstat-no" title="statement not covered" >e.operator[0] as '+' | '-',</span>
-<span class="cstat-no" title="statement not covered" >            left: transformLogicNode(node.left),</span>
-<span class="cstat-no" title="statement not covered" >            right: transformLogicNode(node.right),</span>
+          right: new naslTypes.BinaryExpression({
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.left),
+            right: transformLogicNode(node.right),
           }),
-<span class="cstat-no" title="statement not covered" >        });</span>
-<span class="cstat-no" title="statement not covered" >      }</span>
-      if<span class="cstat-no" title="statement not covered" > (type === 'expression') {</span>
-        return transformLogicNode(node.right);
-      }<span class="cstat-no" title="statement not covered" ></span>
+        });
+      }
+<span class="cstat-no" title="statement not covered" >      if (type === 'expression') {</span>
+<span class="cstat-no" title="statement not covered" >        return transformLogicNode(node.right);</span>
+      }
 <span class="cstat-no" title="statement not covered" >      return new naslTypes.Assignment({</span>
-        left: transformLogicNode<span class="fstat-no" title="function not covered" >(n</span>ode.left),<span class="cstat-no" title="statement not covered" ></span>
+        left: transformLogicNode(node.left),
         right: transformLogicNode(node.right),
       });
     } else <span class="cstat-no" title="statement not covered" >if (node.type === 'NewExpression') {</span>
-<span class="cstat-no" title="statement not covered" >      const calleeName = generate(node.callee as any).code;</span>
-      if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {
-        return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));
-      }<span class="cstat-no" title="statement not covered" ></span>
+      const calleeName = <span class="cstat-no" title="statement not covered" >generate(node.callee as any).code;</span>
+<span class="cstat-no" title="statement not covered" >      if (['Boolean', 'Integer', 'Double', 'Decimal', 'Long'].includes(calleeName)) {</span>
+<span class="cstat-no" title="statement not covered" >        return transformLogicNode(node.arguments[0], naslTypes.TypeAnnotation.createPrimitive(calleeName));</span>
+      }
 <span class="cstat-no" title="statement not covered" >      console.error(node);</span>
-      if (debug) {
-        throw new Error(`Unhandled node ${node.type}`);
-      }<span class="cstat-no" title="statement not covered" ></span>
-    } else if (node.ty<span class="cstat-no" title="statement not covered" >pe === 'ArrowFunctionExpression') {</span>
-      return new naslTypes.AnonymousFunction({
-        params: node.params.map((param: babelTypes.Identifier) =&gt; transformParam(param)),
+<span class="cstat-no" title="statement not covered" >      if (debug) {</span>
+<span class="cstat-no" title="statement not covered" >        throw new Error(`Unhandled node ${node.type}`);</span>
+      }
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'ArrowFunctionExpression') {</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.AnonymousFunction({</span>
+        params: node.params.map(<span class="fstat-no" title="function not covered" >(p</span>aram: babelTypes.Identifier) =&gt; <span class="cstat-no" title="statement not covered" >transformParam(param))</span>,
         body: transformLogicNode(node.body),
-<span class="cstat-no" title="statement not covered" >      }) as any as naslTypes.LogicItem;</span>
-    } <span class="cstat-no" title="statement not covered" >else if (node.ty</span>pe === 'BooleanLiteral') {
-      retur<span class="cstat-no" title="statement not covered" >n new naslTypes.BooleanLiteral({</span>
-<span class="cstat-no" title="statement not covered" >        value: String(node.value),</span>
-      });<span class="cstat-no" title="statement not covered" ></span>
-    } else if (node.type =<span class="cstat-no" title="statement not covered" >== 'StringLiteral') {<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
-      return new naslTypes.StringLiteral({
+      }) as any as naslTypes.LogicItem;
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'BooleanLiteral') {</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.BooleanLiteral({</span>
+        value: String(node.value),
+      });
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'StringLiteral') {</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.StringLiteral({</span>
         value: node.value,
       });
-    } else if (node.type === 'NumericLiteral') {
-      const literal = new naslTypes.NumericLiteral({
-<span class="cstat-no" title="statement not covered" >        value: String(n<span class="fstat-no" title="function not covered" >od</span>e.value)<span class="cstat-no" title="statement not covered" >,</span></span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'NumericLiteral') {</span>
+      const literal = <span class="cstat-no" title="statement not covered" >new naslTypes.NumericLiteral({</span>
+        value: String(node.value),
         typeAnnotation: typeAnnotation || naslTypes.TypeAnnotation.createPrimitive('Integer'),
-<span class="cstat-no" title="statement not covered" >      });</span>
-      literal.typeAnnotation.typeName<span class="fstat-no" title="function not covered" > =</span> literal<span class="cstat-no" title="statement not covered" >.changeType(String(node.v</span>alue));
-      return literal;
+      });
+<span class="cstat-no" title="statement not covered" >      literal.typeAnnotation.typeName = literal.changeType(String(node.value));</span>
+<span class="cstat-no" title="statement not covered" >      return literal;</span>
     } else <span class="cstat-no" title="statement not covered" >if (node.type === 'NullLiteral') {</span>
 <span class="cstat-no" title="statement not covered" >      return new naslTypes.NullLiteral();</span>
-    } el<span class="cstat-no" title="statement not covered" >se if (node.type === '</span>TemplateLiteral') {
-<span class="cstat-no" title="statement not covered" >      const expressions = [...node.expressions as babelTypes.Expression[], ...node.quasis.map((element) =&gt; ({</span>
-<span class="cstat-no" title="statement not covered" >        type: 'StringLiteral',</span>
-<span class="cstat-no" title="statement not covered" >        value: element.value.raw,</span>
-<span class="cstat-no" title="statement not covered" >        start: element.start,</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'TemplateLiteral') {</span>
+      const expressions = <span class="cstat-no" title="statement not covered" >[...node.expressions as babelTypes.Expression[], ...node.quasis.map(<span class="fstat-no" title="function not covered" >(e</span>lement) =&gt; (<span class="cstat-no" title="statement not covered" >{</span></span>
+        type: 'StringLiteral',
+        value: element.value.raw,
+        start: element.start,
         end: element.end,
       })) as babelTypes.StringLiteral[]];
-      expressions.sort((a, b) =&gt; a.start - b.start);
+<span class="cstat-no" title="statement not covered" >      expressions.sort(<span class="fstat-no" title="function not covered" >(a</span>, b) =&gt; <span class="cstat-no" title="statement not covered" >a.start - b.start)</span>;</span>
 &nbsp;
-      return new naslTypes.StringInterpolation({
-<span class="cstat-no" title="statement not covered" >        expressions: expres</span>sions.map((item) =&gt; transformLogicNode(item)),
-<span class="cstat-no" title="statement not covered" >      });</span>
-    } el<span class="cstat-no" title="statement not covered" >se if (node.type === 'BinaryExpression' || node.</span>type === 'LogicalExpression') {
-      if (node.operator === '===')
-        nod<span class="cstat-no" title="statement not covered" >e.operator = '==';</span>
+<span class="cstat-no" title="statement not covered" >      return new naslTypes.StringInterpolation({</span>
+        expressions: expressions.map(<span class="fstat-no" title="function not covered" >(i</span>tem) =&gt; <span class="cstat-no" title="statement not covered" >transformLogicNode(item))</span>,
+      });
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {</span>
+<span class="cstat-no" title="statement not covered" >      if (node.operator === '===')</span>
+<span class="cstat-no" title="statement not covered" >        node.operator = '==';</span>
 <span class="cstat-no" title="statement not covered" >      if (node.operator === '!==')</span>
 <span class="cstat-no" title="statement not covered" >        node.operator = '!=';</span>
-      if (['+', '-', '*', '/', '%', '==', '!=', '&gt;', '&lt;', '&gt;=', '&lt;=', '&amp;&amp;', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {
-        return new naslTypes.BinaryExpression({
+<span class="cstat-no" title="statement not covered" >      if (['+', '-', '*', '/', '%', '==', '!=', '&gt;', '&lt;', '&gt;=', '&lt;=', '&amp;&amp;', '||', 'startwith', 'endwith', 'like', 'in'].includes(node.operator)) {</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.BinaryExpression({</span>
           operator: node.operator as any,
           left: transformLogicNode(node.left),
-<span class="cstat-no" title="statement not covered" >          right: transformLogicNode(node.right),</span>
-<span class="cstat-no" title="statement not covered" >        });</span>
+          right: transformLogicNode(node.right),
+        });
+      }
+<span class="cstat-no" title="statement not covered" >      console.error(node);</span>
+<span class="cstat-no" title="statement not covered" >      if (debug) {</span>
+<span class="cstat-no" title="statement not covered" >        throw new Error(`Unhandled node ${node.type}`);</span>
       }
-      console.error(node);
-      if (debug) {
-        throw new Error(`Unhandled node ${node.type}`);
-<span class="cstat-no" title="statement not covered" >      }</span>
-    } <span class="cstat-no" title="statement not covered" >else if (node.type === 'UnaryExpression') {</span>
-      if<span class="cstat-no" title="statement not covered" > (['!'].includes(node.operator)) {</span>
-        return new naslTypes.UnaryExpression({
-          o<span class="cstat-no" title="statement not covered" >perator: node.operator as any,</span>
-<span class="cstat-no" title="statement not covered" >          argument: transformLogicNode(node.argument),</span>
-<span class="cstat-no" title="statement not covered" >        });</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'UnaryExpression') {</span>
+<span class="cstat-no" title="statement not covered" >      if (['!'].includes(node.operator)) {</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.UnaryExpression({</span>
+          operator: node.operator as any,
+          argument: transformLogicNode(node.argument),
+        });
       }
-      if (['-'].includes(node.operator) &amp;&amp; node.argument.type === 'NumericLiteral') {
-        return transformLogicNode({
+<span class="cstat-no" title="statement not covered" >      if (['-'].includes(node.operator) &amp;&amp; node.argument.type === 'NumericLiteral') {</span>
+<span class="cstat-no" title="statement not covered" >        return transformLogicNode({</span>
           type: 'NumericLiteral',
           value: -node.argument.value,
         } as babelTypes.NumericLiteral);
       }
-      console.error(node);
-      if (debug) {
-        throw new Error(`Unhandled node ${node.type}`);
+<span class="cstat-no" title="statement not covered" >      console.error(node);</span>
+<span class="cstat-no" title="statement not covered" >      if (debug) {</span>
+<span class="cstat-no" title="statement not covered" >        throw new Error(`Unhandled node ${node.type}`);</span>
       }
     } else <span class="cstat-no" title="statement not covered" >if (node.type === 'UpdateExpression') {</span>
 <span class="cstat-no" title="statement not covered" >      if (node.operator === '++' || node.operator === '--') {</span>
 <span class="cstat-no" title="statement not covered" >        return new naslTypes.Assignment({</span>
-<span class="cstat-no" title="statement not covered" >          left: transformLogicNode(node.argument),</span>
+          left: transformLogicNode(node.argument),
           right: new naslTypes.BinaryExpression({
-<span class="cstat-no" title="statement not covered" >            operator: node.operator[0] as '+' | '-',</span>
-<span class="cstat-no" title="statement not covered" >            left: transformLogicNode(node.argument),</span>
+            operator: node.operator[0] as '+' | '-',
+            left: transformLogicNode(node.argument),
             right: new naslTypes.NumericLiteral({
               value: '1',
               typeAnnotation: naslTypes.TypeAnnotation.createPrimitive('Integer'),
-<span class="cstat-no" title="statement not covered" >            }),</span>
+            }),
           }),
         });
       }
-    } else if (node.type === 'ReturnStatement') {
-      if (node.argument) {
-        if (type === 'expression') {
-          r<span class="cstat-no" title="statement not covered" >eturn transformLogicNode(node.argument);</span>
-<span class="cstat-no" title="statement not covered" >        }</span>
-        if (!logic.returns.length) {
-          logic.returns.push(new naslTypes.Return({
-<span class="cstat-no" title="statement not covered" >            name: 'result',</span>
-<span class="cstat-no" title="statement not covered" >          }));</span>
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'ReturnStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      if (node.argument) {</span>
+<span class="cstat-no" title="statement not covered" >        if (type === 'expression') {</span>
+<span class="cstat-no" title="statement not covered" >          return transformLogicNode(node.argument);</span>
+        }
+<span class="cstat-no" title="statement not covered" >        if (!logic.returns.length) {</span>
+<span class="cstat-no" title="statement not covered" >          logic.returns.push(new naslTypes.Return({</span>
+            name: 'result',
+          }));
         }
-<span class="cstat-no" title="statement not covered" >        return new naslType</span>s.Assignment({
-<span class="cstat-no" title="statement not covered" >          left: new naslTypes.Identifier({</span>
-<span class="cstat-no" title="statement not covered" >            name: logic.returns[0].name,</span>
+<span class="cstat-no" title="statement not covered" >        return new naslTypes.Assignment({</span>
+          left: new naslTypes.Identifier({
+            name: logic.returns[0].name,
           }),
           right: transformLogicNode(node.argument),
         });
       }
-    } else if (<span class="cstat-no" title="statement not covered" >node.type === 'EmptyStatement') {</span>
-      return node.leadingComments &amp;&amp; new naslTypes.Comment({
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'EmptyStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      return node.leadingComments &amp;&amp; new naslTypes.Comment({</span>
         value: String(node.leadingComments[0].value),
       });
-    } else if (node.type === 'BlockStatement') {
-      return transformLogicNode(node?.body?.<span class="cstat-no" title="statement not covered" >[0]</span>);
-    } else {<span class="cstat-no" title="statement not covered" ></span>
-      console.error(node);
-      if (debug) {
+    } else <span class="cstat-no" title="statement not covered" >if (node.type === 'BlockStatement') {</span>
+<span class="cstat-no" title="statement not covered" >      return transformLogicNode(node?.body?.[0]);</span>
+    } else {
+<span class="cstat-no" title="statement not covered" >      console.error(node);</span>
+<span class="cstat-no" title="statement not covered" >      if (debug) {</span>
 <span class="cstat-no" title="statement not covered" >        throw new Error(`Unhandled node ${node.type}`);</span>
-<span class="cstat-no" title="statement not covered" >      }</span>
+      }
     }
-<span class="cstat-no" title="statement not covered" >  }</span>
-<span class="cstat-no" title="statement not covered" ></span>
-  const root = babel.parseSync(tsCode, {
+  }
+&nbsp;
+  const root = <span class="cstat-no" title="statement not covered" >babel.parseSync(tsCode, {</span>
     filename: 'result.ts',
     presets: [require('@babel/preset-typescript')],
   }) as babelTypes.File;
 &nbsp;
-  let parameters: babelTypes.Identifier[] = [];
-  let statements: babelTypes.Stat<span class="cstat-no" title="statement not covered" >ement[] = [];<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
-<span class="cstat-no" title="statement not covered" ></span>
-  le<span class="cstat-no" title="statement not covered" >t func: babelTypes.FunctionDecl<span class="fstat-no" title="function not covered" >ar</span>ation;<span class="cstat-no" title="statement not covered" ></span></span>
-  if (root.program.body[0].type === 'ExportNamedDeclaration') {
-    func = root.program.body[0].declaration as babelTypes.FunctionDeclaration;
+  let parameters: babelTypes.Identifier[] = <span class="cstat-no" title="statement not covered" >[];</span>
+  let statements: babelTypes.Statement[] = <span class="cstat-no" title="statement not covered" >[];</span>
+&nbsp;
+  let func: babelTypes.FunctionDeclaration;
+<span class="cstat-no" title="statement not covered" >  if (root.program.body[0].type === 'ExportNamedDeclaration') {</span>
+<span class="cstat-no" title="statement not covered" >    func = root.program.body[0].declaration as babelTypes.FunctionDeclaration;</span>
   }
-  parameters = func.params as babelTypes.Identifier[];
-  statements = func.body.body;
+<span class="cstat-no" title="statement not covered" >  parameters = func.params as babelTypes.Identifier[];</span>
+<span class="cstat-no" title="statement not covered" >  statements = func.body.body;</span>
   // traverse&lt;babelTypes.Node&gt;((current) =&gt; {
   //     if (current.node.type === 'FunctionDeclaration' &amp;&amp; (current.node.id.name === contextLogicName || type === 'expression')) {
   //         return true;
   //     }
   // }, { node: root.program }, { mode: 'anyObject' });
 &nbsp;
-  const currentPositionComment = root.comments.find((comment) =&gt; comment.type === 'CommentLine' &amp;&amp; comment.value === ' 当前位置');
-  if (currentPositionComment) {
-    statements = statements.filter((stat) =&gt; stat.start &gt; currentPositionComment.start);
+  const currentPositionComment = <span class="cstat-no" title="statement not covered" >root.comments.find(<span class="fstat-no" title="function not covered" >(c</span>omment) =&gt; <span class="cstat-no" title="statement not covered" >comment.type === 'CommentLine' &amp;&amp; comment.value === ' 当前位置')</span>;</span>
+<span class="cstat-no" title="statement not covered" >  if (currentPositionComment) {</span>
+<span class="cstat-no" title="statement not covered" >    statements = statements.filter(<span class="fstat-no" title="function not covered" >(s</span>tat) =&gt; <span class="cstat-no" title="statement not covered" >stat.start &gt; currentPositionComment.start)</span>;</span>
   }
-<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
-  // traverse&lt;babe<span class="cstat-no" title="statement not covered" >lTypes.Node&gt;((current</span>) =&gt; {
-  //<span class="cstat-no" title="statement not covered" >     if (!current.node.type)</span>
+&nbsp;
+  // traverse&lt;babelTypes.Node&gt;((current) =&gt; {
+  //     if (!current.node.type)
   //         console.log(current.key, current.node);
-<span class="cstat-no" title="statement not covered" >  //     // console.l<span class="fstat-no" title="function not covered" >og</span>(current.node.type);</span>
-  // }, { node: {<span class="cstat-no" title="statement not covered" ></span>
-  //<span class="cstat-no" title="statement not covered" >     type: 'BlockStatement',</span>
+  //     // console.log(current.node.type);
+  // }, { node: {
+  //     type: 'BlockStatement',
   //     body: statements,
   // } as babelTypes.BlockStatement }, {
   //     mode: 'anyObject',
@@ -2555,75 +2555,75 @@ export function <span class="fstat-no" title="function not covered" >transformTS
   //     excludedKeySet: new Set(['loc']),
   // });
 &nbsp;
-  parameters.forEach((node) =&gt; {
-    const param = transformParam(node);
-<span class="cstat-no" title="statement not covered" >    param &amp;&amp; log</span>ic.params.push(param);
+<span class="cstat-no" title="statement not covered" >  parameters.forEach(<span class="fstat-no" title="function not covered" >(n</span>ode) =&gt; {</span>
+    const param = <span class="cstat-no" title="statement not covered" >transformParam(node);</span>
+<span class="cstat-no" title="statement not covered" >    param &amp;&amp; logic.params.push(param);</span>
   });
-  statements.forEach((node) =&gt; {
-    const item =<span class="fstat-no" title="function not covered" > transformLogicNode</span>(node);
+<span class="cstat-no" title="statement not covered" >  statements.forEach(<span class="fstat-no" title="function not covered" >(n</span>ode) =&gt; {</span>
+    const item = <span class="cstat-no" title="statement not covered" >transformLogicNode(node);</span>
 <span class="cstat-no" title="statement not covered" >    item &amp;&amp; logic.body.push(item);</span>
-  });<span class="cstat-no" title="statement not covered" ></span>
-<span class="cstat-no" title="statement not covered" ></span>
-  // c<span class="cstat-no" title="statement not covered" >onsole.log(JSON.stringif</span>y(logic));
+  });
+&nbsp;
+  // console.log(JSON.stringify(logic));
   // try {
   //     console.log(logic.toNaturalTS());
-<span class="cstat-no" title="statement not covered" >  // } catch (e) {</span>
+  // } catch (e) {
   //     console.error(e);
   // }
-<span class="fstat-no" title="function not covered" ></span>
-  return logic;<span class="cstat-no" title="statement not covered" ></span>
-}<span class="cstat-no" title="statement not covered" ></span>
-<span class="cstat-no" title="statement not covered" ></span>
-expo<span class="cstat-no" title="statement not covered" >rt function tryTransformTSCode(tsCode: string</span>, contextLogicName: string, type?: string): naslTypes.Logic {
-  if (tsC<span class="cstat-no" title="statement not covered" >ode.includes('```')) {</span>
-<span class="cstat-no" title="statement not covered" >    const cap = tsCode.match(/```.*\n([\s\S]+?)```/);</span>
-    if (cap)
+&nbsp;
+<span class="cstat-no" title="statement not covered" >  return logic;</span>
+}
+&nbsp;
+export function <span class="fstat-no" title="function not covered" >tryTransformTSCode(</span>tsCode: string, contextLogicName: string, type?: string): naslTypes.Logic {
+<span class="cstat-no" title="statement not covered" >  if (tsCode.includes('```')) {</span>
+    const cap = <span class="cstat-no" title="statement not covered" >tsCode.match(/```.*\n([\s\S]+?)```/);</span>
+<span class="cstat-no" title="statement not covered" >    if (cap)</span>
 <span class="cstat-no" title="statement not covered" >      tsCode = cap[1].trim();</span>
   }
 &nbsp;
-  return transfo<span class="cstat-no" title="statement not covered" >rmTSCode(tsCode, contextLogicName, typ</span>e);
-}<span class="cstat-no" title="statement not covered" ></span>
-<span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span>
-expo<span class="cstat-no" title="statement not covered" >rt function transformTSCodeEx<span class="fstat-no" title="function not covered" >(a</span>nswer: any<span class="cstat-no" title="statement not covered" >, activeLogic: any, co</span>ntext: any) {</span>
-  let <span class="cstat-no" title="statement not covered" >logicName = activeLogic.name;</span>
-  const { app, nasl } = context;
-<span class="cstat-no" title="statement not covered" >  if (activeLogic.parentNo<span class="fstat-no" title="function not covered" >de</span> instanceof nasl.BindEvent &amp;&amp; activeLogic.parentNode.parentNode instanceof nasl.View) {</span>
-<span class="cstat-no" title="statement not covered" >    logicName = `viewLogic_${activeL<span class="fstat-no" title="function not covered" >og</span>ic.name}`;<span class="cstat-no" title="statement not covered" ></span></span>
-  } el<span class="cstat-no" title="statement not covered" >se if (activeLogic.parentNode instanceof nas</span>l.BindEvent &amp;&amp; activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
-    logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
-<span class="cstat-no" title="statement not covered" >  } else {</span>
+<span class="cstat-no" title="statement not covered" >  return transformTSCode(tsCode, contextLogicName, type);</span>
+}
+&nbsp;
+export function <span class="fstat-no" title="function not covered" >transformTSCodeEx(</span>answer: any, activeLogic: any, context: any) {
+  let logicName = <span class="cstat-no" title="statement not covered" >activeLogic.name;</span>
+  const { app, nasl } = <span class="cstat-no" title="statement not covered" >context;</span>
+<span class="cstat-no" title="statement not covered" >  if (activeLogic.parentNode instanceof nasl.BindEvent &amp;&amp; activeLogic.parentNode.parentNode instanceof nasl.View) {</span>
+<span class="cstat-no" title="statement not covered" >    logicName = `viewLogic_${activeLogic.name}`;</span>
+  } else <span class="cstat-no" title="statement not covered" >if (activeLogic.parentNode instanceof nasl.BindEvent &amp;&amp; activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {</span>
+<span class="cstat-no" title="statement not covered" >    logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;</span>
+  } else {
 <span class="cstat-no" title="statement not covered" >    logicName = activeLogic.name;</span>
   }
-<span class="cstat-no" title="statement not covered" ><span class="cstat-no" title="statement not covered" ><span class="fstat-no" title="function not covered" ></span></span></span>
-<span class="cstat-no" title="statement not covered" >  const logic = tryTransfor</span>mTSCode(answer, logicName);
-  app.emit('collect:start', { actionMsg: '自然语言生成代码' });
-  logic.params.forEach((param: any) =&gt; {
-    if (!activeL<span class="fstat-no" title="function not covered" >ogic.params.find((_: any) =&gt;</span> _.name === param.name))
-      activeLogic.addParam(param.toJSON());
-<span class="cstat-no" title="statement not covered" >  });</span>
-  lo<span class="cstat-no" title="statement not covered" >gic.variables.forEach((variable: any) =&gt; {</span>
-    if (!activeLogic.variables.find((_: any) =&gt; _.name === variable.name))
-<span class="cstat-no" title="statement not covered" >      activeLogic.addVariabl</span>e(variable.toJSON());
+&nbsp;
+  const logic = <span class="cstat-no" title="statement not covered" >tryTransformTSCode(answer, logicName);</span>
+<span class="cstat-no" title="statement not covered" >  app.emit('collect:start', { actionMsg: '自然语言生成代码' });</span>
+<span class="cstat-no" title="statement not covered" >  logic.params.forEach(<span class="fstat-no" title="function not covered" >(p</span>aram: any) =&gt; {</span>
+<span class="cstat-no" title="statement not covered" >    if (!activeLogic.params.find(<span class="fstat-no" title="function not covered" >(_</span>: any) =&gt; <span class="cstat-no" title="statement not covered" >_.name === param.name)</span>)</span>
+<span class="cstat-no" title="statement not covered" >      activeLogic.addParam(param.toJSON());</span>
   });
-  if (logic.return<span class="cstat-no" title="statement not covered" >s.length</span> &amp;&amp; !activeLogic.returns.length) {
+<span class="cstat-no" title="statement not covered" >  logic.variables.forEach(<span class="fstat-no" title="function not covered" >(v</span>ariable: any) =&gt; {</span>
+<span class="cstat-no" title="statement not covered" >    if (!activeLogic.variables.find(<span class="fstat-no" title="function not covered" >(_</span>: any) =&gt; <span class="cstat-no" title="statement not covered" >_.name === variable.name)</span>)</span>
+<span class="cstat-no" title="statement not covered" >      activeLogic.addVariable(variable.toJSON());</span>
+  });
+<span class="cstat-no" title="statement not covered" >  if (logic.returns.length &amp;&amp; !activeLogic.returns.length) {</span>
 <span class="cstat-no" title="statement not covered" >    activeLogic.addReturn(logic.returns[0].toJSON());</span>
-  }<span class="cstat-no" title="statement not covered" ></span>
-<span class="cstat-no" title="statement not covered" >  logic.body.forEach((item:</span> any) =&gt; activeLogic.insertItemInBodyAt(item.toJSON(), activeLogic.body.length - 1));
-<span class="cstat-no" title="statement not covered" >  app.emit('col</span>lect:end');
+  }
+<span class="cstat-no" title="statement not covered" >  logic.body.forEach(<span class="fstat-no" title="function not covered" >(i</span>tem: any) =&gt; <span class="cstat-no" title="statement not covered" >activeLogic.insertItemInBodyAt(item.toJSON(), activeLogic.body.length - 1))</span>;</span>
+<span class="cstat-no" title="statement not covered" >  app.emit('collect:end');</span>
 }
 &nbsp;
-export function transformTSCodeToExpression(answer: any, context: any) {
+export function <span class="fstat-no" title="function not covered" >transformTSCodeToExpression(</span>answer: any, context: any) {
   let logic;
-  try {
-    logic = tryTransformTSCode(answer, '', 'expression');
+<span class="cstat-no" title="statement not covered" >  try {</span>
+<span class="cstat-no" title="statement not covered" >    logic = tryTransformTSCode(answer, '', 'expression');</span>
   } catch (error) {
-    throw new Error(error);
+<span class="cstat-no" title="statement not covered" >    throw new Error(error);</span>
   }
-  const { app } = context;
-  app.emit('collect:start', { actionMsg: '自然语言生成代码' });
-  const { body } = logic;
-  app.emit('collect:end');
-  return body;
+  const { app } = <span class="cstat-no" title="statement not covered" >context;</span>
+<span class="cstat-no" title="statement not covered" >  app.emit('collect:start', { actionMsg: '自然语言生成代码' });</span>
+  const { body } = <span class="cstat-no" title="statement not covered" >logic;</span>
+<span class="cstat-no" title="statement not covered" >  app.emit('collect:end');</span>
+<span class="cstat-no" title="statement not covered" >  return body;</span>
 }
 &nbsp;</pre></td></tr></table></pre>
 
@@ -2632,7 +2632,7 @@ export function transformTSCodeToExpression(answer: any, context: any) {
             <div class='footer quiet pad2 space-top1 center small'>
                 Code coverage generated by
                 <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
-                at 2023-10-18T11:24:07.411Z
+                at 2023-10-18T11:36:07.885Z
             </div>
         <script src="../../prettify.js"></script>
         <script>