@lcap/nasl-concepts 3.9.0-beta.1

package/out/concepts/Module__.js

@@ -0,0 +1,1580 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var Module_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const nasl_translator_1 = require("@lcap/nasl-translator");
+const moduleNameSpace = {
+    dependencies: 'extensions',
+    interfaceDependencies: 'apis',
+    componentDependencies: 'components',
+    connectorDependencies: 'connector',
+};
+const typeNameSpace = {
+    extension: 'extensions',
+    interface: 'apis',
+    component: 'components',
+    connector: 'connector',
+    customInterface: 'apis',
+};
+const decorators_1 = require("../decorators");
+const utils = __importStar(require("../utils"));
+const asserts = __importStar(require("./utils/asserts"));
+const BaseNode_1 = __importDefault(require("../common/BaseNode"));
+/**
+ * 模块
+ */
+let Module = class Module extends BaseNode_1.default {
+    static { Module_1 = this; }
+    /** 类名 */
+    static { this.ConceptName = 'Module'; }
+    /**
+     * 是否为抽象类
+     * 抽象类不能产生 concept: string
+     */
+    static { this.isAbstract = false; }
+    /** 继承链 */
+    static { this.inheritanceChain = ['BaseNode']; }
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        source = Object.assign({}, Module_1.getDefaultOptions(), source);
+        super(source);
+        /**
+         * 模块名称
+         */
+        this.name = '';
+        /**
+         * 数据源列表
+         */
+        this.dataSources = [];
+        /**
+         * 数据结构列表
+         */
+        this.structures = [];
+        /**
+         * 枚举列表
+         */
+        this.enums = [];
+        /**
+         * 逻辑列表
+         */
+        this.logics = [];
+        /**
+         * 接口列表
+         */
+        this.interfaces = [];
+        /**
+         * 页面列表
+         */
+        this.views = [];
+        /**
+         * 流程列表
+         */
+        this.processes = [];
+        /**
+         * 流程列表
+         */
+        this.processV2s = [];
+        /**
+         * 前端库列表
+         */
+        this.frontends = [];
+        /**
+         * 注解列表
+         */
+        this.annotations = [];
+        this.dependencies = [];
+        super.subConstructor(source);
+    }
+    static from(source, parentNode, parentKey) {
+        return super.from(source, parentNode, parentKey);
+    }
+    /**
+     * 设置模块名称
+     */
+    setName(name) {
+        const object = {
+            name,
+        };
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
+    /**
+     * 设置模块标题
+     */
+    setTitle(title) {
+        const object = {
+            title,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    /**
+     * 设置模块描述
+     */
+    setDescription(description) {
+        const object = {
+            description,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    getDataSourceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.dataSources || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getDataSourceUniqueName(name = 'dataSource1') {
+        return utils.unique(name, this.getDataSourceExistingNames(), undefined, false);
+    }
+    _insertDataSourceAt(options, index) {
+        const dataSourceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'dataSources' };
+        const DataSource = (0, decorators_1.getConceptConstructor)('DataSource');
+        let dataSource;
+        if (!options) {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                name: this.getDataSourceUniqueName(),
+            }, this, 'dataSources');
+        }
+        else if (typeof options === 'string') {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                name: options,
+            }, this, 'dataSources');
+        }
+        else if (asserts.isDataSource(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            dataSource = options;
+            Object.assign(dataSource, relationOptions);
+        }
+        else {
+            dataSource = DataSource.from({
+                ...dataSourceOptions,
+                ...options,
+            }, this, 'dataSources');
+        }
+        this.dataSources.splice(index, 0, dataSource);
+        return dataSource;
+    }
+    insertDataSourceAt(options, index) {
+        const node = this._insertDataSourceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dataSources',
+        });
+        return node;
+    }
+    _addDataSource(options) {
+        const index = 0;
+        return this._insertDataSourceAt(options, index);
+    }
+    addDataSource(options) {
+        const node = this._addDataSource(options);
+        const index = this.dataSources.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'dataSources',
+        });
+        return node;
+    }
+    getStructureExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getStructureUniqueName(name = 'Structure1') {
+        return utils.unique(name, this.getStructureExistingNames(), undefined, false);
+    }
+    _insertStructureAt(options, index) {
+        const structureOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'structures' };
+        const Structure = (0, decorators_1.getConceptConstructor)('Structure');
+        let structure;
+        if (!options) {
+            structure = Structure.from({
+                ...structureOptions,
+                name: this.getStructureUniqueName(),
+            }, this, 'structures');
+        }
+        else if (typeof options === 'string') {
+            structure = Structure.from({
+                ...structureOptions,
+                name: options,
+            }, this, 'structures');
+        }
+        else if (asserts.isStructure(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            structure = options;
+            Object.assign(structure, relationOptions);
+        }
+        else {
+            structure = Structure.from({
+                ...structureOptions,
+                ...options,
+            }, this, 'structures');
+        }
+        this.structures.splice(index, 0, structure);
+        return structure;
+    }
+    insertStructureAt(options, index) {
+        const node = this._insertStructureAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+    _addStructure(options) {
+        const index = 0;
+        return this._insertStructureAt(options, index);
+    }
+    addStructure(options) {
+        const node = this._addStructure(options);
+        const index = this.structures.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'structures',
+        });
+        return node;
+    }
+    getEnumExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.enums || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getEnumUniqueName(name = 'Enum1') {
+        return utils.unique(name, this.getEnumExistingNames(), undefined, false);
+    }
+    _insertEnumAt(options, index) {
+        const enumerationOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'enums' };
+        const Enum = (0, decorators_1.getConceptConstructor)('Enum');
+        let enumeration;
+        if (!options) {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                name: this.getEnumUniqueName(),
+            }, this, 'enums');
+        }
+        else if (typeof options === 'string') {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                name: options,
+            }, this, 'enums');
+        }
+        else if (asserts.isEnum(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            enumeration = options;
+            Object.assign(enumeration, relationOptions);
+        }
+        else {
+            enumeration = Enum.from({
+                ...enumerationOptions,
+                ...options,
+            }, this, 'enums');
+        }
+        this.enums.splice(index, 0, enumeration);
+        return enumeration;
+    }
+    insertEnumAt(options, index) {
+        const node = this._insertEnumAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+    _addEnum(options) {
+        const index = 0;
+        return this._insertEnumAt(options, index);
+    }
+    addEnum(options) {
+        const node = this._addEnum(options);
+        const index = this.enums.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'enums',
+        });
+        return node;
+    }
+    getLogicExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getLogicUniqueName(name = 'logic1') {
+        return utils.unique(name, this.getLogicExistingNames(), undefined, false);
+    }
+    _insertLogicAt(options, index) {
+        const logicOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'logics' };
+        const Logic = (0, decorators_1.getConceptConstructor)('Logic');
+        let logic;
+        if (!options) {
+            logic = Logic.from({
+                ...logicOptions,
+                name: this.getLogicUniqueName(),
+            }, this, 'logics');
+        }
+        else if (typeof options === 'string') {
+            logic = Logic.from({
+                ...logicOptions,
+                name: options,
+            }, this, 'logics');
+        }
+        else if (asserts.isLogic(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            logic = options;
+            Object.assign(logic, relationOptions);
+        }
+        else {
+            logic = Logic.from({
+                ...logicOptions,
+                ...options,
+            }, this, 'logics');
+        }
+        this.logics.splice(index, 0, logic);
+        return logic;
+    }
+    insertLogicAt(options, index) {
+        const node = this._insertLogicAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+    _addLogic(options) {
+        const index = 0;
+        return this._insertLogicAt(options, index);
+    }
+    addLogic(options) {
+        const node = this._addLogic(options);
+        const index = this.logics.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'logics',
+        });
+        return node;
+    }
+    getInterfaceExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.interfaces || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getInterfaceUniqueName(name = 'Interface1') {
+        return utils.unique(name, this.getInterfaceExistingNames(), undefined, false);
+    }
+    _insertInterfaceAt(options, index) {
+        const itfaceOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'interfaces' };
+        const AbstractInterface = (0, decorators_1.getConceptConstructor)('AbstractInterface');
+        let itface;
+        if (!options) {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                name: this.getInterfaceUniqueName(),
+            }, this, 'interfaces');
+        }
+        else if (typeof options === 'string') {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                name: options,
+            }, this, 'interfaces');
+        }
+        else if (asserts.isAbstractInterface(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            itface = options;
+            Object.assign(itface, relationOptions);
+        }
+        else {
+            itface = AbstractInterface.from({
+                ...itfaceOptions,
+                ...options,
+            }, this, 'interfaces');
+        }
+        this.interfaces.splice(index, 0, itface);
+        return itface;
+    }
+    insertInterfaceAt(options, index) {
+        const node = this._insertInterfaceAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    _addInterface(options) {
+        const index = 0;
+        return this._insertInterfaceAt(options, index);
+    }
+    addInterface(options) {
+        const node = this._addInterface(options);
+        const index = this.interfaces.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'interfaces',
+        });
+        return node;
+    }
+    getViewExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.views || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getViewUniqueName(name = 'view1') {
+        return utils.unique(name, this.getViewExistingNames(), undefined, false);
+    }
+    _insertViewAt(options, index) {
+        const viewOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'views' };
+        const View = (0, decorators_1.getConceptConstructor)('View');
+        let view;
+        if (!options) {
+            view = View.from({
+                ...viewOptions,
+                name: this.getViewUniqueName(),
+            }, this, 'views');
+        }
+        else if (typeof options === 'string') {
+            view = View.from({
+                ...viewOptions,
+                name: options,
+            }, this, 'views');
+        }
+        else if (asserts.isView(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            view = options;
+            Object.assign(view, relationOptions);
+        }
+        else {
+            view = View.from({
+                ...viewOptions,
+                ...options,
+            }, this, 'views');
+        }
+        this.views.splice(index, 0, view);
+        return view;
+    }
+    insertViewAt(options, index) {
+        const node = this._insertViewAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+    _addView(options) {
+        const index = this.views.length;
+        return this._insertViewAt(options, index);
+    }
+    addView(options) {
+        const node = this._addView(options);
+        const index = this.views.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'views',
+        });
+        return node;
+    }
+    getVarExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.frontendVariables || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getVariableUniqueName(name = 'variable1') {
+        return utils.unique(name, this.getVarExistingNames(), undefined, true);
+    }
+    _insertVariableAt(options, index) {
+        const variableOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'frontendVariables' };
+        const Variable = (0, decorators_1.getConceptConstructor)('Variable');
+        let variable;
+        if (!options) {
+            variable = Variable.from({
+                ...variableOptions,
+                name: this.getVariableUniqueName(),
+            }, this, 'frontendVariables');
+        }
+        else if (typeof options === 'string') {
+            variable = Variable.from({
+                ...variableOptions,
+                name: options,
+            }, this, 'frontendVariables');
+        }
+        else if (asserts.isVariable(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            variable = options;
+            Object.assign(variable, relationOptions);
+        }
+        else {
+            variable = Variable.from({
+                ...variableOptions,
+                ...options,
+            }, this, 'frontendVariables');
+        }
+        this.frontendVariables.splice(index, 0, variable);
+        return variable;
+    }
+    insertVariableAt(options, index) {
+        const node = this._insertVariableAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontendVariables',
+        });
+        return node;
+    }
+    _addVariable(options) {
+        const index = this.frontendVariables.length;
+        return this._insertVariableAt(options, index);
+    }
+    addVariable(options) {
+        const node = this._addVariable(options);
+        const index = this.frontendVariables.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontendVariables',
+        });
+        return node;
+    }
+    getProcessExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.processes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessUniqueName(name = 'Process1') {
+        return utils.unique(name, this.getProcessExistingNames(), undefined, false);
+    }
+    _insertProcessAt(options, index) {
+        const processOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'processes' };
+        const Process = (0, decorators_1.getConceptConstructor)('Process');
+        let process;
+        if (!options) {
+            process = Process.from({
+                ...processOptions,
+                name: this.getProcessUniqueName(),
+            }, this, 'processes');
+        }
+        else if (typeof options === 'string') {
+            process = Process.from({
+                ...processOptions,
+                name: options,
+            }, this, 'processes');
+        }
+        else if (asserts.isProcess(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            process = options;
+            Object.assign(process, relationOptions);
+        }
+        else {
+            process = Process.from({
+                ...processOptions,
+                ...options,
+            }, this, 'processes');
+        }
+        this.processes.splice(index, 0, process);
+        return process;
+    }
+    insertProcessAt(options, index) {
+        const node = this._insertProcessAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+    _addProcess(options) {
+        const index = 0;
+        return this._insertProcessAt(options, index);
+    }
+    addProcess(options) {
+        const node = this._addProcess(options);
+        const index = this.processes.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processes',
+        });
+        return node;
+    }
+    getProcessV2ExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.processV2s || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getProcessV2UniqueName(name = 'Process1') {
+        return utils.unique(name, this.getProcessV2ExistingNames(), undefined, false);
+    }
+    _insertProcessV2At(options, index) {
+        const processV2Options = {};
+        const relationOptions = { parentNode: this, parentKey: 'processV2s' };
+        const ProcessV2 = (0, decorators_1.getConceptConstructor)('ProcessV2');
+        let processV2;
+        if (!options) {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                name: this.getProcessV2UniqueName(),
+            }, this, 'processV2s');
+        }
+        else if (typeof options === 'string') {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                name: options,
+            }, this, 'processV2s');
+        }
+        else if (asserts.isProcessV2(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            processV2 = options;
+            Object.assign(processV2, relationOptions);
+        }
+        else {
+            processV2 = ProcessV2.from({
+                ...processV2Options,
+                ...options,
+            }, this, 'processV2s');
+        }
+        this.processV2s.splice(index, 0, processV2);
+        return processV2;
+    }
+    insertProcessV2At(options, index) {
+        const node = this._insertProcessV2At(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processV2s',
+        });
+        return node;
+    }
+    _addProcessV2(options) {
+        const index = 0;
+        return this._insertProcessV2At(options, index);
+    }
+    addProcessV2(options) {
+        const node = this._addProcessV2(options);
+        const index = this.processV2s.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'processV2s',
+        });
+        return node;
+    }
+    getFrontendLibraryExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.frontends || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getFrontendLibraryUniqueName(name = 'frontendLibrary1') {
+        return utils.unique(name, this.getFrontendLibraryExistingNames(), undefined, false);
+    }
+    _insertFrontendLibraryAt(options, index) {
+        const frontendLibraryOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'frontends' };
+        const FrontendLibrary = (0, decorators_1.getConceptConstructor)('FrontendLibrary');
+        let frontendLibrary;
+        if (!options) {
+            frontendLibrary = FrontendLibrary.from({
+                ...frontendLibraryOptions,
+                name: this.getFrontendLibraryUniqueName(),
+            }, this, 'frontends');
+        }
+        else if (typeof options === 'string') {
+            frontendLibrary = FrontendLibrary.from({
+                ...frontendLibraryOptions,
+                name: options,
+            }, this, 'frontends');
+        }
+        else if (asserts.isFrontendLibrary(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            frontendLibrary = options;
+            Object.assign(frontendLibrary, relationOptions);
+        }
+        else {
+            frontendLibrary = FrontendLibrary.from({
+                ...frontendLibraryOptions,
+                ...options,
+            }, this, 'frontends');
+        }
+        this.frontends.splice(index, 0, frontendLibrary);
+        return frontendLibrary;
+    }
+    insertFrontendLibraryAt(options, index) {
+        const node = this._insertFrontendLibraryAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontends',
+        });
+        return node;
+    }
+    _addFrontendLibrary(options) {
+        const index = this.frontends.length;
+        return this._insertFrontendLibraryAt(options, index);
+    }
+    addFrontendLibrary(options) {
+        const node = this._addFrontendLibrary(options);
+        const index = this.frontends.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'frontends',
+        });
+        return node;
+    }
+    getTriggerLauncherExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.triggerLaunchers || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getTriggerLauncherUniqueName(name = 'triggerLauncher1') {
+        return utils.unique(name, this.getTriggerLauncherExistingNames(), undefined, false);
+    }
+    _insertTriggerLauncherAt(options, index) {
+        const triggerLauncherOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'triggerLaunchers' };
+        const TriggerLauncher = (0, decorators_1.getConceptConstructor)('TriggerLauncher');
+        let triggerLauncher;
+        if (!options) {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                name: this.getTriggerLauncherUniqueName(),
+            }, this, 'triggerLaunchers');
+        }
+        else if (typeof options === 'string') {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                name: options,
+            }, this, 'triggerLaunchers');
+        }
+        else if (asserts.isTriggerLauncher(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            triggerLauncher = options;
+            Object.assign(triggerLauncher, relationOptions);
+        }
+        else {
+            triggerLauncher = TriggerLauncher.from({
+                ...triggerLauncherOptions,
+                ...options,
+            }, this, 'triggerLaunchers');
+        }
+        this.triggerLaunchers.splice(index, 0, triggerLauncher);
+        return triggerLauncher;
+    }
+    insertTriggerLauncherAt(options, index) {
+        const node = this._insertTriggerLauncherAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    _addTriggerLauncher(options) {
+        const index = 0;
+        return this._insertTriggerLauncherAt(options, index);
+    }
+    addTriggerLauncher(options) {
+        const node = this._addTriggerLauncher(options);
+        const index = this.triggerLaunchers.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'triggerLaunchers',
+        });
+        return node;
+    }
+    getConnectionExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.connections || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getConnectionUniqueName(name = 'connection1') {
+        return utils.unique(name, this.getConnectionExistingNames(), undefined, false);
+    }
+    _insertConnectionAt(options, index) {
+        const connectionOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'connections' };
+        const Connection = (0, decorators_1.getConceptConstructor)('Connection');
+        let connection;
+        if (!options) {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: this.getConnectionUniqueName(),
+            }, this, 'connections');
+        }
+        else if (typeof options === 'string') {
+            connection = Connection.from({
+                ...connectionOptions,
+                name: options,
+            }, this, 'connections');
+        }
+        else if (asserts.isConnection(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            connection = options;
+            Object.assign(connection, relationOptions);
+        }
+        else {
+            connection = Connection.from({
+                ...connectionOptions,
+                ...options,
+            }, this, 'connections');
+        }
+        this.connections.splice(index, 0, connection);
+        return connection;
+    }
+    insertConnectionAt(options, index) {
+        const node = this._insertConnectionAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
+    _addConnection(options) {
+        const index = 0;
+        return this._insertConnectionAt(options, index);
+    }
+    addConnection(options) {
+        const node = this._addConnection(options);
+        const index = this.connections.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'connections',
+        });
+        return node;
+    }
+    getMetadataTypeExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.metadataTypes || [])
+            .filter((item) => !excludedSet.has(item))
+            .map((item) => item.name);
+    }
+    getMetadataTypeUniqueName(name = 'MetadataType1') {
+        return utils.unique(name, this.getMetadataTypeExistingNames(), undefined, true);
+    }
+    _insertMetadataTypeAt(options, index) {
+        const metadataTypeOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'metadataTypes' };
+        const MetadataType = (0, decorators_1.getConceptConstructor)('MetadataType');
+        let metadataType;
+        if (!options) {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                name: this.getMetadataTypeUniqueName(),
+            }, this, 'metadataTypes');
+        }
+        else if (typeof options === 'string') {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                name: options,
+            }, this, 'metadataTypes');
+        }
+        else if (asserts.isMetadataType(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            metadataType = options;
+            Object.assign(metadataType, relationOptions);
+        }
+        else {
+            metadataType = MetadataType.from({
+                ...metadataTypeOptions,
+                ...options,
+            }, this, 'metadataTypes');
+        }
+        this.metadataTypes.splice(index, 0, metadataType);
+        return metadataType;
+    }
+    insertMetadataTypeAt(options, index) {
+        const node = this._insertMetadataTypeAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'metadataTypes',
+        });
+        return node;
+    }
+    _addMetadataType(options) {
+        const index = 0;
+        return this._insertMetadataTypeAt(options, index);
+    }
+    addMetadataType(options) {
+        const node = this._addMetadataType(options);
+        const index = this.metadataTypes.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'metadataTypes',
+        });
+        return node;
+    }
+    getAnnotationExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.annotations || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getAnnotationUniqueName(name = 'annotation1') {
+        return utils.unique(name, this.getAnnotationExistingNames(), undefined, false);
+    }
+    _insertAnnotationAt(options, index) {
+        const annotationOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'annotations' };
+        const Annotation = (0, decorators_1.getConceptConstructor)('Annotation');
+        let annotation;
+        if (!options) {
+            annotation = Annotation.from({
+                ...annotationOptions,
+                name: this.getAnnotationUniqueName(),
+            }, this, 'annotations');
+        }
+        else if (typeof options === 'string') {
+            annotation = Annotation.from({
+                ...annotationOptions,
+                name: options,
+            }, this, 'annotations');
+        }
+        else if (asserts.isAnnotation(options)) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            annotation = options;
+            Object.assign(annotation, relationOptions);
+        }
+        else {
+            annotation = Annotation.from({
+                ...annotationOptions,
+                ...options,
+            }, this, 'annotations');
+        }
+        this.annotations.splice(index, 0, annotation);
+        return annotation;
+    }
+    insertAnnotationAt(options, index) {
+        const node = this._insertAnnotationAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'annotations',
+        });
+        return node;
+    }
+    _addAnnotation(options) {
+        const index = this.annotations.length;
+        return this._insertAnnotationAt(options, index);
+    }
+    addAnnotation(options) {
+        const node = this._addAnnotation(options);
+        const index = this.annotations.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'annotations',
+        });
+        return node;
+    }
+    removeDataSource(options) {
+        let dataSource;
+        if (typeof options === 'string') {
+            dataSource = this.dataSources.find((item) => item.name === options);
+            if (!dataSource) {
+                throw new Error('找不到数据源 ' + options);
+            }
+        }
+        else {
+            dataSource = options;
+        }
+        return dataSource.delete();
+    }
+    removeStructure(options) {
+        let structure;
+        if (typeof options === 'string') {
+            structure = this.structures.find((item) => item.name === options);
+            if (!structure) {
+                throw new Error('找不到数据结构 ' + options);
+            }
+        }
+        else {
+            structure = options;
+        }
+        return structure.delete();
+    }
+    removeEnum(options) {
+        let enumeration;
+        if (typeof options === 'string') {
+            enumeration = this.enums.find((item) => item.name === options);
+            if (!enumeration) {
+                throw new Error('找不到枚举 ' + options);
+            }
+        }
+        else {
+            enumeration = options;
+        }
+        return enumeration.delete();
+    }
+    removeLogic(options) {
+        let logic;
+        if (typeof options === 'string') {
+            logic = this.logics.find((item) => item.name === options);
+            if (!logic) {
+                throw new Error('找不到逻辑 ' + options);
+            }
+        }
+        else {
+            logic = options;
+        }
+        return logic.delete();
+    }
+    removeInterface(options) {
+        let itface;
+        if (typeof options === 'string') {
+            itface = this.interfaces.find((item) => item.name === options);
+            if (!itface) {
+                throw new Error('找不到接口 ' + options);
+            }
+        }
+        else {
+            itface = options;
+        }
+        return itface.delete();
+    }
+    removeView(options) {
+        let view;
+        if (typeof options === 'string') {
+            view = this.views.find((item) => item.name === options);
+            if (!view) {
+                throw new Error('找不到页面 ' + options);
+            }
+        }
+        else {
+            view = options;
+        }
+        return view.delete();
+    }
+    removeVariable(options) {
+        let variable;
+        if (typeof options === 'string') {
+            variable = this.frontendVariables.find((item) => item.name === options);
+            if (!variable) {
+                throw new Error('找不到变量 ' + options);
+            }
+        }
+        else {
+            variable = options;
+        }
+        return variable.delete();
+    }
+    removeProcess(options) {
+        let process;
+        if (typeof options === 'string') {
+            process = this.processes.find((item) => item.name === options);
+            if (!process) {
+                throw new Error('找不到流程 ' + options);
+            }
+        }
+        else {
+            process = options;
+        }
+        return process.delete();
+    }
+    removeProcessV2(options) {
+        let processV2;
+        if (typeof options === 'string') {
+            processV2 = this.processV2s.find((item) => item.name === options);
+            if (!processV2) {
+                throw new Error('找不到流程 ' + options);
+            }
+        }
+        else {
+            processV2 = options;
+        }
+        return processV2.delete();
+    }
+    removeFrontendLibrary(options) {
+        let frontendLibrary;
+        if (typeof options === 'string') {
+            frontendLibrary = this.frontends.find((item) => item.name === options);
+            if (!frontendLibrary) {
+                throw new Error('找不到前端库 ' + options);
+            }
+        }
+        else {
+            frontendLibrary = options;
+        }
+        return frontendLibrary.delete();
+    }
+    removeTriggerLauncher(options) {
+        let triggerLauncher;
+        if (typeof options === 'string') {
+            triggerLauncher = this.triggerLaunchers.find((item) => item.name === options);
+            if (!triggerLauncher) {
+                throw new Error('找不到触发器启动器 ' + options);
+            }
+        }
+        else {
+            triggerLauncher = options;
+        }
+        return triggerLauncher.delete();
+    }
+    removeConnection(options) {
+        let connection;
+        if (typeof options === 'string') {
+            connection = this.connections.find((item) => item.name === options);
+            if (!connection) {
+                throw new Error('找不到连接 ' + options);
+            }
+        }
+        else {
+            connection = options;
+        }
+        return connection.delete();
+    }
+    removeMetadataType(options) {
+        let metadataType;
+        if (typeof options === 'string') {
+            metadataType = this.metadataTypes.find((item) => item.name === options);
+            if (!metadataType) {
+                throw new Error('找不到元数据类型 ' + options);
+            }
+        }
+        else {
+            metadataType = options;
+        }
+        return metadataType.delete();
+    }
+    removeAnnotation(options) {
+        let annotation;
+        if (typeof options === 'string') {
+            annotation = this.annotations.find((item) => item.name === options);
+            if (!annotation) {
+                throw new Error('找不到注解 ' + options);
+            }
+        }
+        else {
+            annotation = options;
+        }
+        return annotation.delete();
+    }
+    setIsAdd(isAdd) {
+        const object = {
+            isAdd,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    /**
+     * 生成宿主语言的文件路径
+     * @param name 一般不用传，用于 rename
+     */
+    getEmbeddedFilePath(name = this.name) {
+        return `/embedded/${this.app.name}/${this.parentKey}/${this.name}`;
+    }
+    /**
+     * 获取命名空间和
+     * 暂时不考虑 Module 嵌套的情况
+     */
+    getNamespace() {
+        // connector namespace 为 connector + connectorName
+        if (this.type === 'connector') {
+            return `connector.${this.name}`;
+        }
+        return `${moduleNameSpace[this.parentKey]}`;
+    }
+    getTsNamespace() {
+        if (this.type === 'connector') {
+            return 'connector';
+        }
+        return `${moduleNameSpace[this.parentKey]}`;
+    }
+    getTsNamespaceAndName() {
+        if (this.type === 'connector') {
+            return 'connector';
+        }
+        return `${moduleNameSpace[this.parentKey]}.${this.name}`;
+    }
+    findEnumByName(name) {
+        return this.enums.find((enumItem) => enumItem.name === name);
+    }
+    getFEManifest() {
+        if (!this.compilerInfoMap || !this.compilerInfoMap.manifest) {
+            return null;
+        }
+        try {
+            return JSON.parse(this.compilerInfoMap.manifest);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    checkFileInManifest(fileName) {
+        const manifest = this.getFEManifest();
+        if (!manifest) {
+            return false;
+        }
+        const manifestFiles = [];
+        Object.keys(manifest).forEach((k) => {
+            if (!k || !manifest[k]) {
+                return;
+            }
+            const fileList = Array.isArray(manifest[k]) ? manifest[k] : [manifest[k]];
+            if (fileList.length > 0) {
+                manifestFiles.push(...fileList);
+            }
+        });
+        return manifestFiles.includes(fileName);
+    }
+    /**
+     *  获取属性节点是否存在
+     */
+    findProperty(name, propertyType) {
+        return this[propertyType].find((item) => item.name === name);
+    }
+    delete() {
+        this.parentNode?.emit('collect:start', {
+            actionMsg: '移除依赖库',
+        });
+        super.delete();
+        this._delete();
+        // if (this.dependencies) {
+        //     // 删除依赖链中的依赖
+        //     this.dependencies.forEach((tag) => {
+        //         const [name, version] = tag.split('-');
+        //         const existNode = this.app.dependencies.find((m) => m.name === name && m.version === version);
+        //         existNode?.delete();
+        //     });
+        // }
+        // 处理同名依赖 重新生成文件
+        // if (this.enable) {
+        // 删[数据源]
+        const dataSourceGroup = this.parentNode?.configuration?.getGroup('dataSource');
+        if (this.dataSources && dataSourceGroup) {
+            this.dataSources.forEach((datasource) => {
+                this.parentNode?.emit('clear:datasourceError', datasource);
+                try {
+                    dataSourceGroup.removeConfigProperty(datasource.name);
+                }
+                catch (e) { }
+            });
+        }
+        // // 已启用的依赖库被删除时，将后续被禁用的同名依赖库 切换为启用
+        // const index = this.app.dependencies.findIndex((m) => m.enable === false && m.name === this.name);
+        // if (index >= 0) {
+        //     const nextMainModule = this.app.dependencies[index];
+        //     // 更新[禁用的依赖]enable:true
+        //     nextMainModule.update({ enable: true });
+        //     nextMainModule.softDelete({ index });
+        // }
+        // }
+        this.parentNode?.emit('collect:end');
+    }
+    // 删除再添加 触发文件生成
+    softDelete(options) {
+        // 删[禁用的依赖]
+        super.delete();
+        // 创建[禁用的依赖]
+        this.app.insertModuleInDependenciesAt(this, options.index);
+        // 创建[禁用的依赖]的数据源
+        const dataSourceGroup = this.parentNode?.configuration?.getGroup('dataSource');
+        const ConfigProperty = (0, decorators_1.getConceptConstructor)('ConfigProperty');
+        if (this.dataSources && dataSourceGroup) {
+            this.dataSources.forEach((datasource) => {
+                const body = ConfigProperty.from({
+                    name: datasource.name,
+                    description: '',
+                    isPrivate: false,
+                    values: [
+                        { env: 'dev', value: '', concept: 'ConfigPropertyValue' },
+                        { env: 'online', value: '', concept: 'ConfigPropertyValue' },
+                    ],
+                });
+                dataSourceGroup.addConfigProperty(body);
+            });
+        }
+    }
+    setInterfaces(interfaces) {
+        this.update({
+            interfaces,
+        });
+    }
+    // 获取数据结构被接口的引用关系
+    getInterfaceStructureMap() {
+        const structureMap = new Map();
+        this.interfaces.forEach((itf) => {
+            const stashItf = itf;
+            const structures = stashItf.getRefStructures(this.structures);
+            structures.forEach((s) => {
+                if (structureMap.has(s)) {
+                    structureMap.get(s).add(stashItf);
+                }
+                else {
+                    structureMap.set(s, new Set([stashItf]));
+                }
+            });
+        });
+        return structureMap;
+    }
+    /**
+     * 设置版本号
+     */
+    setVersion(version) {
+        this.update({
+            version,
+        });
+    }
+    toNaturalTS(state = (0, nasl_translator_1.createCompilerState)()) {
+        let code = '';
+        code += `namespace ${typeNameSpace[this.type]}.${this.name} {\n`;
+        this.dataSources?.forEach((dataSource) => {
+            code += dataSource.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.structures?.forEach((structure) => {
+            code += structure.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.enums?.forEach((enumeration) => {
+            code += enumeration.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.metadataTypes?.forEach((metadataType) => {
+            code += metadataType.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        if (this.metadataTypes.length)
+            code += '\n';
+        this.logics?.forEach((logic) => {
+            code += logic.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1, declaration: true })) + '\n\n';
+        });
+        this.interfaces?.forEach((inter) => {
+            code += inter.toNaturalTS((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        return code;
+    }
+    toTextualNASL(state = (0, nasl_translator_1.createCompilerState)()) {
+        let code = '';
+        code += (0, nasl_translator_1.createDecoratorCode)(state, this, [
+            'type',
+            'version',
+            'title',
+            'description',
+            'provider',
+            'externalDependencyMap',
+            'compilerInfoMap',
+        ]);
+        code += `module ${this.name} {\n`;
+        this.dataSources?.forEach((dataSource) => {
+            code += dataSource.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.structures?.forEach((structure) => {
+            code += structure.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.enums?.forEach((enumeration) => {
+            code += enumeration.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.metadataTypes?.forEach((metadataType) => {
+            code += metadataType.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        this.logics?.forEach((logic) => {
+            code += logic.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1, declaration: true })) + '\n\n';
+        });
+        this.interfaces?.forEach((inter) => {
+            code += inter.toTextualNASL((0, nasl_translator_1.shiftState)(state, code, { tabSize: state.tabSize + 1 })) + '\n';
+        });
+        code += `${(0, nasl_translator_1.indent)(state.tabSize)}}`;
+        return code;
+    }
+};
+exports.Module = Module;
+__decorate([
+    (0, decorators_1.property)()
+    // @ts-ignore
+], Module.prototype, "concept", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "type", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "version", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "name", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "title", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "description", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "provider", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "externalDependencyMap", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "compilerInfoMap", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'DataSource',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "dataSources", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Structure',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "structures", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Enum',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "enums", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Logic',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "logics", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'AbstractInterface',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "interfaces", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'View',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "views", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Variable',
+        isArray: true,
+        defaultValue: null,
+    })
+], Module.prototype, "frontendVariables", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Process',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "processes", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'ProcessV2',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "processV2s", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'FrontendLibrary',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "frontends", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Configuration',
+    })
+], Module.prototype, "configuration", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'TriggerLauncher',
+        isArray: true,
+        defaultValue: null,
+    })
+], Module.prototype, "triggerLaunchers", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Connection',
+        isArray: true,
+        defaultValue: null,
+    })
+], Module.prototype, "connections", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'MetadataType',
+        isArray: true,
+        defaultValue: null,
+    })
+], Module.prototype, "metadataTypes", void 0);
+__decorate([
+    (0, decorators_1.property)({
+        objectRef: 'Annotation',
+        isArray: true,
+        defaultValue: [],
+    })
+], Module.prototype, "annotations", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Module.prototype, "isAdd", void 0);
+__decorate([
+    (0, nasl_translator_1.withSourceMap)()
+], Module.prototype, "toNaturalTS", null);
+__decorate([
+    (0, nasl_translator_1.withSourceMap)()
+], Module.prototype, "toTextualNASL", null);
+exports.Module = Module = Module_1 = __decorate([
+    (0, decorators_1.concept)('模块')
+], Module);
+exports.default = Module;
+//================================================================================
+// ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
+// 自动生成的代码已结束。下面可以手动编写。
+//================================================================================
+//# sourceMappingURL=Module__.js.map