@lcap/nasl 3.4.0-beta.3 → 3.4.0-beta.4

package/out/breakpoint/generator/BreakpointNode.js

@@ -1,284 +1,284 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const concepts_1 = require("../../concepts");
-const utils_1 = require("../shared/utils");
-const MATCH_CONCEPT = 'Match';
-const MATCH_CASE_CONCEPT = 'MatchCase';
-const ASSIGNMENT_CONCEPT = 'Assignment';
-const CALL_LOGIC_CONCEPT = 'CallLogic';
-const CALL_FUNCTION_CONCEPT = 'CallFunction';
-const CALL_INTERFACE_CONCEPT = 'CallInterface';
-const WHILE_STATEMENT_CONCEPT = 'WhileStatement';
-const DESTINATION_CONCPETS = ['ExternalDestination', 'Destination'];
-const LOG_CALLER_NAMES = ['showMessage', 'consoleLog'];
-const BEFORE_LOGIC_CONCEPTS = [
-    MATCH_CONCEPT,
-    'JSBlock',
-    'New',
-    'NewMap',
-    'NewList',
-    'NewComposite',
-    'ForEachStatement',
-    'SwitchStatement',
-    'IfStatement',
-];
-const attribute = '[Symbol.for(\'breakpoint\')]';
-const parse = '(code) => eval(code)';
-const assemble = (instance) => (code) => {
-    if (!instance || !code) {
-        return code;
-    }
-    const { _nodePath } = instance;
-    if (!_nodePath) {
-        return code;
-    }
-    return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
-};
-const callLogicGenerator = (instance) => (breaker) => {
-    const { _nodePath, logic, variable } = instance;
-    const node = logic || variable;
-    if (!node) {
-        return breaker;
-    }
-    const source = node;
-    const { concept, calleeName, isViewLogic } = source;
-    if (concept !== CALL_LOGIC_CONCEPT) {
-        return;
-    }
-    if (LOG_CALLER_NAMES.includes(calleeName)) {
-        return;
-    }
-    const { arguments: args } = source;
-    const wrapper = (callback) => {
-        if (isViewLogic) {
-            return callback();
-        }
-        const callNode = source.getCallNode() || {};
-        const { params: callNodeParams } = callNode;
-        const callNodeBase = callNodeParams || [];
-        callNode.params = callNodeBase.concat({ name: attribute });
-        const result = callback();
-        callNode.params = callNodeParams;
-        return result;
-    };
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const breakpointExpression = new BreakpointNode();
-    const breakpointArgument = new concepts_1.Argument();
-    const base = args || [];
-    breakpointArgument.name = attribute;
-    breakpointArgument.keyword = attribute;
-    breakpointArgument.expression = breakpointExpression;
-    breakpointExpression._nodePath = _nodePath;
-    source.arguments = base.concat(breakpointArgument);
-    const callback = () => source.toJS();
-    const code = wrapper(callback);
-    source.arguments = args;
-    return assemble(instance)(code);
-};
-const callFunctionGenerator = (instance) => (breaker) => {
-    const { _nodePath, logic, variable } = instance;
-    const node = logic || variable;
-    if (!node) {
-        return breaker;
-    }
-    const source = node;
-    const { concept } = source;
-    if (concept !== CALL_FUNCTION_CONCEPT) {
-        return;
-    }
-    const { arguments: sourceArguments, typeArguments: sourceTypeArguments, } = source;
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const breakpointExpression = new BreakpointNode();
-    const breakpointArgument = new concepts_1.Argument();
-    const baseArguments = sourceArguments || [];
-    const baseTypeArguments = sourceTypeArguments || [];
-    const addToTypeArguments = baseTypeArguments?.length;
-    breakpointArgument.name = attribute;
-    breakpointArgument.keyword = attribute;
-    breakpointArgument.expression = breakpointExpression;
-    breakpointExpression._nodePath = _nodePath;
-    if (addToTypeArguments) {
-        source.typeArguments = baseTypeArguments.concat(breakpointArgument);
-    }
-    else {
-        const { length } = baseArguments;
-        if (length) {
-            const lastBaseArgument = baseArguments[length - 1];
-            const beforeBaseArguments = baseArguments.slice(0, -1);
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            const combinedLastBaseArgument = new BreakpointNode();
-            combinedLastBaseArgument.variable = lastBaseArgument;
-            combinedLastBaseArgument._nodePath = _nodePath;
-            source.arguments = beforeBaseArguments.concat(combinedLastBaseArgument);
-        }
-        else {
-            source.arguments = baseArguments.concat(breakpointArgument);
-        }
-    }
-    const code = source.toJS();
-    source.arguments = sourceArguments;
-    source.typeArguments = sourceTypeArguments;
-    return assemble(instance)(code);
-};
-const callInterfaceGenerator = (instance) => (breaker) => {
-    const { logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const source = logic;
-    const { concept } = source;
-    if (concept !== CALL_INTERFACE_CONCEPT) {
-        return;
-    }
-    const code = source.toJS();
-    const assembled = assemble(instance)(code);
-    return `${assembled}\n${breaker}`;
-};
-const variableGenerator = (instance) => () => {
-    const { _nodePath, variable } = instance;
-    if (!variable) {
-        return;
-    }
-    const promise = variable?.toJS() || '';
-    return `await $breaker.generateBreakpoint('${_nodePath}', ${parse})(${promise})`;
-};
-const assignmentGenerator = (instance) => () => {
-    const { _nodePath, logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const source = logic;
-    const { concept, right } = source;
-    if (concept !== ASSIGNMENT_CONCEPT) {
-        return;
-    }
-    const options = { variable: right };
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const breakpointRight = new BreakpointNode(options);
-    breakpointRight._nodePath = _nodePath;
-    source.right = breakpointRight;
-    const code = source.toJS();
-    source.right = right;
-    return code;
-};
-const whileStatementGenerator = (instance) => (breaker) => {
-    const { _nodePath, logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const source = logic;
-    const { concept, body = [] } = source;
-    if (concept !== WHILE_STATEMENT_CONCEPT) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const item = new BreakpointNode();
-    item._nodePath = _nodePath;
-    source.body = body.concat(item);
-    const code = source.toJS();
-    source.body = body;
-    return `${breaker}\n${code}`;
-};
-const matchCaseLogicGenerator = (instance) => () => {
-    const { _nodePath, logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const source = logic;
-    const parentConcept = source?.parentNode?.concept;
-    const underMatch = parentConcept === MATCH_CASE_CONCEPT;
-    const ancestor = source.getAncestor(MATCH_CONCEPT) || {};
-    const { isExpression } = ancestor;
-    if (!underMatch || !isExpression) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const breakpoint = new BreakpointNode({ variable: source });
-    breakpoint._nodePath = _nodePath;
-    return breakpoint.toJS();
-};
-const destinationLogicGenerator = (instance) => () => {
-    const { _nodePath, logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const source = logic;
-    const { anchor, concept } = source;
-    if (!DESTINATION_CONCPETS.includes(concept)) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    const breakpoint = new BreakpointNode({ variable: anchor });
-    breakpoint._nodePath = _nodePath;
-    source.anchor = breakpoint;
-    const code = source.toJS();
-    source.anchor = anchor;
-    return code;
-};
-const logicGenerator = (instance) => (breaker) => {
-    const { logic } = instance;
-    if (!logic) {
-        return;
-    }
-    const promise = logic?.toJS() || '';
-    const { concept } = logic;
-    const shouldSetBefore = BEFORE_LOGIC_CONCEPTS.includes(concept);
-    const code = shouldSetBefore ? [breaker, promise] : [promise, breaker];
-    return code.join('\n');
-};
-// 不要更换顺序
-const generators = [
-    callLogicGenerator,
-    callFunctionGenerator,
-    callInterfaceGenerator,
-    variableGenerator,
-    assignmentGenerator,
-    whileStatementGenerator,
-    matchCaseLogicGenerator,
-    destinationLogicGenerator,
-    logicGenerator,
-];
-const failsafes = [
-    variableGenerator,
-    logicGenerator,
-];
-class BreakpointNode extends concepts_1.BaseNode {
-    _nodePath = '';
-    variable = undefined;
-    logic = undefined;
-    constructor(options = {}) {
-        super();
-        this.logic = options.logic;
-        this.variable = options.variable;
-        this.init();
-    }
-    get node() {
-        return this.logic || this.variable;
-    }
-    init() {
-        const source = this.logic || this.variable;
-        const node = (0, utils_1.getRealNode)(source);
-        if (!node) {
-            return;
-        }
-        this._nodePath = (0, utils_1.getUniqueIdFromNode)(node);
-    }
-    toJS() {
-        const node = this.logic || this.variable;
-        const id = this._nodePath;
-        const keyword = `generateBreakpoint('${id}'`;
-        const breaker = id && `await $breaker.generateBreakpoint('${id}', ${parse})()`;
-        if (!node) {
-            return breaker;
-        }
-        let result;
-        result = generators.reduce((code, generator) => code || generator(this)(breaker), '');
-        result = failsafes.reduce((code, generator) => {
-            const useful = code && code.includes(keyword);
-            return useful ? code : generator(this)(breaker);
-        }, result);
-        return result || breaker;
-    }
-}
-exports.default = BreakpointNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const concepts_1 = require("../../concepts");
+const utils_1 = require("../shared/utils");
+const MATCH_CONCEPT = 'Match';
+const MATCH_CASE_CONCEPT = 'MatchCase';
+const ASSIGNMENT_CONCEPT = 'Assignment';
+const CALL_LOGIC_CONCEPT = 'CallLogic';
+const CALL_FUNCTION_CONCEPT = 'CallFunction';
+const CALL_INTERFACE_CONCEPT = 'CallInterface';
+const WHILE_STATEMENT_CONCEPT = 'WhileStatement';
+const DESTINATION_CONCPETS = ['ExternalDestination', 'Destination'];
+const LOG_CALLER_NAMES = ['showMessage', 'consoleLog'];
+const BEFORE_LOGIC_CONCEPTS = [
+    MATCH_CONCEPT,
+    'JSBlock',
+    'New',
+    'NewMap',
+    'NewList',
+    'NewComposite',
+    'ForEachStatement',
+    'SwitchStatement',
+    'IfStatement',
+];
+const attribute = '[Symbol.for(\'breakpoint\')]';
+const parse = '(code) => eval(code)';
+const assemble = (instance) => (code) => {
+    if (!instance || !code) {
+        return code;
+    }
+    const { _nodePath } = instance;
+    if (!_nodePath) {
+        return code;
+    }
+    return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
+};
+const callLogicGenerator = (instance) => (breaker) => {
+    const { _nodePath, logic, variable } = instance;
+    const node = logic || variable;
+    if (!node) {
+        return breaker;
+    }
+    const source = node;
+    const { concept, calleeName, isViewLogic } = source;
+    if (concept !== CALL_LOGIC_CONCEPT) {
+        return;
+    }
+    if (LOG_CALLER_NAMES.includes(calleeName)) {
+        return;
+    }
+    const { arguments: args } = source;
+    const wrapper = (callback) => {
+        if (isViewLogic) {
+            return callback();
+        }
+        const callNode = source.getCallNode() || {};
+        const { params: callNodeParams } = callNode;
+        const callNodeBase = callNodeParams || [];
+        callNode.params = callNodeBase.concat({ name: attribute });
+        const result = callback();
+        callNode.params = callNodeParams;
+        return result;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const breakpointExpression = new BreakpointNode();
+    const breakpointArgument = new concepts_1.Argument();
+    const base = args || [];
+    breakpointArgument.name = attribute;
+    breakpointArgument.keyword = attribute;
+    breakpointArgument.expression = breakpointExpression;
+    breakpointExpression._nodePath = _nodePath;
+    source.arguments = base.concat(breakpointArgument);
+    const callback = () => source.toJS();
+    const code = wrapper(callback);
+    source.arguments = args;
+    return assemble(instance)(code);
+};
+const callFunctionGenerator = (instance) => (breaker) => {
+    const { _nodePath, logic, variable } = instance;
+    const node = logic || variable;
+    if (!node) {
+        return breaker;
+    }
+    const source = node;
+    const { concept } = source;
+    if (concept !== CALL_FUNCTION_CONCEPT) {
+        return;
+    }
+    const { arguments: sourceArguments, typeArguments: sourceTypeArguments, } = source;
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const breakpointExpression = new BreakpointNode();
+    const breakpointArgument = new concepts_1.Argument();
+    const baseArguments = sourceArguments || [];
+    const baseTypeArguments = sourceTypeArguments || [];
+    const addToTypeArguments = baseTypeArguments?.length;
+    breakpointArgument.name = attribute;
+    breakpointArgument.keyword = attribute;
+    breakpointArgument.expression = breakpointExpression;
+    breakpointExpression._nodePath = _nodePath;
+    if (addToTypeArguments) {
+        source.typeArguments = baseTypeArguments.concat(breakpointArgument);
+    }
+    else {
+        const { length } = baseArguments;
+        if (length) {
+            const lastBaseArgument = baseArguments[length - 1];
+            const beforeBaseArguments = baseArguments.slice(0, -1);
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            const combinedLastBaseArgument = new BreakpointNode();
+            combinedLastBaseArgument.variable = lastBaseArgument;
+            combinedLastBaseArgument._nodePath = _nodePath;
+            source.arguments = beforeBaseArguments.concat(combinedLastBaseArgument);
+        }
+        else {
+            source.arguments = baseArguments.concat(breakpointArgument);
+        }
+    }
+    const code = source.toJS();
+    source.arguments = sourceArguments;
+    source.typeArguments = sourceTypeArguments;
+    return assemble(instance)(code);
+};
+const callInterfaceGenerator = (instance) => (breaker) => {
+    const { logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const source = logic;
+    const { concept } = source;
+    if (concept !== CALL_INTERFACE_CONCEPT) {
+        return;
+    }
+    const code = source.toJS();
+    const assembled = assemble(instance)(code);
+    return `${assembled}\n${breaker}`;
+};
+const variableGenerator = (instance) => () => {
+    const { _nodePath, variable } = instance;
+    if (!variable) {
+        return;
+    }
+    const promise = variable?.toJS() || '';
+    return `await $breaker.generateBreakpoint('${_nodePath}', ${parse})(${promise})`;
+};
+const assignmentGenerator = (instance) => () => {
+    const { _nodePath, logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const source = logic;
+    const { concept, right } = source;
+    if (concept !== ASSIGNMENT_CONCEPT) {
+        return;
+    }
+    const options = { variable: right };
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const breakpointRight = new BreakpointNode(options);
+    breakpointRight._nodePath = _nodePath;
+    source.right = breakpointRight;
+    const code = source.toJS();
+    source.right = right;
+    return code;
+};
+const whileStatementGenerator = (instance) => (breaker) => {
+    const { _nodePath, logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const source = logic;
+    const { concept, body = [] } = source;
+    if (concept !== WHILE_STATEMENT_CONCEPT) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const item = new BreakpointNode();
+    item._nodePath = _nodePath;
+    source.body = body.concat(item);
+    const code = source.toJS();
+    source.body = body;
+    return `${breaker}\n${code}`;
+};
+const matchCaseLogicGenerator = (instance) => () => {
+    const { _nodePath, logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const source = logic;
+    const parentConcept = source?.parentNode?.concept;
+    const underMatch = parentConcept === MATCH_CASE_CONCEPT;
+    const ancestor = source.getAncestor(MATCH_CONCEPT) || {};
+    const { isExpression } = ancestor;
+    if (!underMatch || !isExpression) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const breakpoint = new BreakpointNode({ variable: source });
+    breakpoint._nodePath = _nodePath;
+    return breakpoint.toJS();
+};
+const destinationLogicGenerator = (instance) => () => {
+    const { _nodePath, logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const source = logic;
+    const { anchor, concept } = source;
+    if (!DESTINATION_CONCPETS.includes(concept)) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const breakpoint = new BreakpointNode({ variable: anchor });
+    breakpoint._nodePath = _nodePath;
+    source.anchor = breakpoint;
+    const code = source.toJS();
+    source.anchor = anchor;
+    return code;
+};
+const logicGenerator = (instance) => (breaker) => {
+    const { logic } = instance;
+    if (!logic) {
+        return;
+    }
+    const promise = logic?.toJS() || '';
+    const { concept } = logic;
+    const shouldSetBefore = BEFORE_LOGIC_CONCEPTS.includes(concept);
+    const code = shouldSetBefore ? [breaker, promise] : [promise, breaker];
+    return code.join('\n');
+};
+// 不要更换顺序
+const generators = [
+    callLogicGenerator,
+    callFunctionGenerator,
+    callInterfaceGenerator,
+    variableGenerator,
+    assignmentGenerator,
+    whileStatementGenerator,
+    matchCaseLogicGenerator,
+    destinationLogicGenerator,
+    logicGenerator,
+];
+const failsafes = [
+    variableGenerator,
+    logicGenerator,
+];
+class BreakpointNode extends concepts_1.BaseNode {
+    _nodePath = '';
+    variable = undefined;
+    logic = undefined;
+    constructor(options = {}) {
+        super();
+        this.logic = options.logic;
+        this.variable = options.variable;
+        this.init();
+    }
+    get node() {
+        return this.logic || this.variable;
+    }
+    init() {
+        const source = this.logic || this.variable;
+        const node = (0, utils_1.getRealNode)(source);
+        if (!node) {
+            return;
+        }
+        this._nodePath = (0, utils_1.getUniqueIdFromNode)(node);
+    }
+    toJS() {
+        const node = this.logic || this.variable;
+        const id = this._nodePath;
+        const keyword = `generateBreakpoint('${id}'`;
+        const breaker = id && `await $breaker.generateBreakpoint('${id}', ${parse})()`;
+        if (!node) {
+            return breaker;
+        }
+        let result;
+        result = generators.reduce((code, generator) => code || generator(this)(breaker), '');
+        result = failsafes.reduce((code, generator) => {
+            const useful = code && code.includes(keyword);
+            return useful ? code : generator(this)(breaker);
+        }, result);
+        return result || breaker;
+    }
+}
+exports.default = BreakpointNode;
 //# sourceMappingURL=BreakpointNode.js.map

package/out/breakpoint/generator/CallbackNode.d.ts

@@ -1,4 +1,4 @@
-import BreakpointNode from './BreakpointNode';
-export default class CallbackNode extends BreakpointNode {
-    toJS(): any;
-}
+import BreakpointNode from './BreakpointNode';
+export default class CallbackNode extends BreakpointNode {
+    toJS(): any;
+}

package/out/breakpoint/generator/CallbackNode.js

@@ -1,22 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BreakpointNode_1 = __importDefault(require("./BreakpointNode"));
-class CallbackNode extends BreakpointNode_1.default {
-    toJS() {
-        const { logic, variable } = this;
-        const node = (logic || variable);
-        if (!node) {
-            return '';
-        }
-        const code = node.toJS();
-        if (!code) {
-            return code;
-        }
-        return `$breaker.transfer(($breaker) => ${code})`;
-    }
-}
-exports.default = CallbackNode;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BreakpointNode_1 = __importDefault(require("./BreakpointNode"));
+class CallbackNode extends BreakpointNode_1.default {
+    toJS() {
+        const { logic, variable } = this;
+        const node = (logic || variable);
+        if (!node) {
+            return '';
+        }
+        const code = node.toJS();
+        if (!code) {
+            return code;
+        }
+        return `$breaker.transfer(($breaker) => ${code})`;
+    }
+}
+exports.default = CallbackNode;
 //# sourceMappingURL=CallbackNode.js.map

package/out/breakpoint/generator/FragmentNode.d.ts

@@ -1,4 +1,4 @@
-import BreakpointNode from './BreakpointNode';
-export default class FragmentNode extends BreakpointNode {
-    toJS(): any;
-}
+import BreakpointNode from './BreakpointNode';
+export default class FragmentNode extends BreakpointNode {
+    toJS(): any;
+}

package/out/breakpoint/generator/FragmentNode.js

@@ -1,18 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const BreakpointNode_1 = __importDefault(require("./BreakpointNode"));
-class FragmentNode extends BreakpointNode_1.default {
-    toJS() {
-        const { variable, _nodePath } = this;
-        const code = variable ? variable.toJS() : '';
-        if (_nodePath) {
-            return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
-        }
-        return code;
-    }
-}
-exports.default = FragmentNode;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BreakpointNode_1 = __importDefault(require("./BreakpointNode"));
+class FragmentNode extends BreakpointNode_1.default {
+    toJS() {
+        const { variable, _nodePath } = this;
+        const code = variable ? variable.toJS() : '';
+        if (_nodePath) {
+            return `await $breaker.assembleFragment('${_nodePath}')(${code})`;
+        }
+        return code;
+    }
+}
+exports.default = FragmentNode;
 //# sourceMappingURL=FragmentNode.js.map