@lcap/nasl-concepts 3.9.0-beta.1

package/out/common/BaseNode.js

@@ -0,0 +1,1721 @@
+"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 BaseNode_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNode = void 0;
+const lodash_1 = require("lodash");
+const nasl_translator_1 = require("@lcap/nasl-translator");
+const nasl_sentry_1 = require("@lcap/nasl-sentry");
+const utils = __importStar(require("../utils"));
+const EventEmitter_1 = require("./EventEmitter");
+const breakpoint_1 = require("../breakpoint");
+const actionable_1 = require("../service/actionable");
+const store_1 = require("../store");
+const decorators_1 = require("../decorators");
+const concepts_1 = require("../concepts");
+const patchCompose = (node, type = 'add') => {
+    if (node?.composedBy) {
+        const app = node?.app;
+        if (type === 'add') {
+            app && app.addComposeNodes(node.composedBy, node); // undo 操作是临时判断，无法准确判断到触发点
+        }
+        else if (type == 'delete') {
+            app && app.deleteComposeNode(node.composedBy, node);
+        }
+    }
+};
+/**
+ * 顶点类
+ * 属性均为只读，仅在初始化和 load 的情况下可以修改
+ */
+let BaseNode = class BaseNode extends EventEmitter_1.EventEmitter {
+    static { BaseNode_1 = this; }
+    static { this.ConceptName = 'BaseNode'; }
+    static { this.inheritanceChain = []; }
+    /**
+     * 概念
+     */
+    get concept() {
+        return this._concept ?? this.constructor.ConceptName;
+    }
+    /**
+     * @param source 需要合并的部分参数
+     */
+    constructor(source) {
+        super();
+        /**
+         * 可修改标志，内部属性
+         * 标记在构造函数结束后是否可修改
+         */
+        this._mutable = true;
+        /**
+         * 唯一 Id
+         */
+        this.id = utils.uuidv4().replace(/-/g, '');
+        /**
+         * 父节点
+         */
+        this.parentNode = null;
+        this.parentKey = '';
+        if (this.hasOwnProperty('JSON_EXCLUDED_KEYS') && this.JSON_EXCLUDED_KEYS === undefined)
+            delete this.JSON_EXCLUDED_KEYS;
+        /**
+         * 监听action，delete，update事件
+         */
+        this.on('create', this.genActionListener);
+        this.on('delete', this.genActionListener);
+        this.on('update', this.genActionListener);
+        this.on('node:Editing', this.nodeEditing);
+        /**
+         * 监听action，delete，update事件
+         */
+        this.on('create', () => breakpoint_1.operators.create(this));
+        this.on('delete', () => breakpoint_1.operators.delete(this));
+        this.on('update', () => breakpoint_1.operators.update(this));
+    }
+    subConstructor(source) {
+        const concept = this.concept || this.constructor.name;
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(concept);
+        const whitePropertyMap = (0, decorators_1.getConceptWhitePropertyMap)(concept);
+        const properties = Array.from(new Set([...Object.keys(this), ...Object.keys(source)])).filter((key) => propertyMap.has(key) || whitePropertyMap.has(key));
+        // 测试时用的标记属性
+        if (process.env.NODE_ENV === 'testing') {
+            properties.push('__$Selected', '__TypeAnnotation');
+        }
+        properties.forEach((key) => {
+            if (key === 'concept') {
+                return;
+            }
+            const sourceItem = source[key] !== undefined ? source[key] : this[key];
+            let property = propertyMap.get(key);
+            let objectRefCtor;
+            // 测试环境下，类型节点由外部注入，所以需要在初始化的时候必须带上类型节点
+            if (process.env.NODE_ENV === 'testing' && key === '__TypeAnnotation' && sourceItem) {
+                property = { objectRef: 'TypeAnnotation' };
+            }
+            try {
+                if (property?.objectRef) {
+                    const arr = property.objectRef.split(' | ');
+                    for (let i = 0; i < arr.length; i++) {
+                        objectRefCtor = (0, decorators_1.getConceptConstructor)(arr[i]);
+                        if (sourceItem instanceof objectRefCtor) {
+                            sourceItem.parentNode = this;
+                            sourceItem.parentKey = key;
+                            break;
+                        }
+                    }
+                }
+                // 数组的情况也在这里做掉了
+                const val = objectRefCtor && sourceItem && !(sourceItem instanceof objectRefCtor) ? this.instantiateSub(sourceItem, key) : sourceItem;
+                if (val !== undefined) {
+                    this[key] = val;
+                }
+            }
+            catch (e) {
+                // Function has non-object prototype 'undefined' in instanceof check
+                if (!e.message.includes('Function has non-object prototype'))
+                    throw e;
+            }
+        });
+        breakpoint_1.operators.create(this);
+        // node 环境下需要删除当前节点的 concept 属性
+        if (utils.isNode && ('concept' in this) && !this.concept) {
+            Reflect.deleteProperty(this, 'concept');
+        }
+        if (this?.composedBy) {
+            const app = this?.app;
+            app && app?._action !== 'undo' && app.addComposeNodes(this.composedBy, this); // undo 操作是临时判断，无法准确判断到触发点
+        }
+        if (0 && ['Entity', 'Logic', "ViewElement"].includes(source.concept)) {
+            const app = this?.app;
+            if (app) {
+                app?.getDefaultOnAnno()?.[source.concept]?.map((anno) => {
+                    if (this?.applyAnnotations?.length > 0) {
+                        // (this as any)?._addApplyAnnotation(anno?.transToApplyAnno())
+                        let aanno = anno?.transToApplyAnno();
+                        if (!this?.applyAnnotations?.find((aa) => aa.annotationName === aanno.annotationName)) {
+                            this?.applyAnnotations.push(aanno);
+                        }
+                    }
+                    else {
+                        this.applyAnnotations = [anno?.transToApplyAnno()];
+                        // this.update({
+                        //   applyAnnotations:[anno?.transToApplyAnno()]
+                        // })
+                    }
+                });
+                // this.applyAnnotations
+            }
+        }
+    }
+    fixInstantiate() {
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(this.concept ?? this.constructor.name);
+        const properties = Object.keys(this).filter((key) => propertyMap.has(key));
+        properties.forEach((key) => {
+            const property = propertyMap.get(key);
+            const sourceItem = this[key];
+            const objectRefCtor = property.objectRef && (0, decorators_1.getConceptConstructor)(property.objectRef);
+            if (objectRefCtor) {
+                if (Array.isArray(sourceItem)) {
+                    sourceItem.forEach((item, index) => {
+                        if (item instanceof objectRefCtor) {
+                            item.parentNode = this;
+                            item.parentKey = key;
+                            item.fixInstantiate();
+                        }
+                        else {
+                            sourceItem[index] = this.instantiateSub(item instanceof BaseNode_1 ? item.toJSON() : item, key);
+                        }
+                    });
+                }
+                else if (sourceItem instanceof objectRefCtor) {
+                    sourceItem.parentNode = this;
+                    sourceItem.parentKey = key;
+                    sourceItem.fixInstantiate();
+                }
+                else {
+                    this[key] = this.instantiateSub(sourceItem instanceof BaseNode_1 ? sourceItem.toJSON() : sourceItem, key);
+                }
+            }
+        });
+    }
+    getIndexOfParent() {
+        let index = -1;
+        const { parentNode } = this;
+        if (parentNode) {
+            const { parentKey } = this;
+            const parentProperty = parentNode[parentKey];
+            if (Array.isArray(parentProperty)) {
+                index = parentProperty.indexOf(this);
+            }
+        }
+        return index;
+    }
+    /**
+     * 为存储点生成行为监听器
+     * @param action
+     * @returns
+     */
+    genActionListener($event) {
+        // eventList是要被发送给后端的数据
+        if (!$event.eventList) {
+            $event.eventList = [];
+        }
+        if (!$event.eventStop) {
+            $event.eventList.push($event);
+        }
+        $event.originEvent = $event.originEvent || $event;
+        this.onChange($event);
+        if (this.concept === 'App') {
+            this.emit('storage', $event);
+        }
+        else if (this.parentNode && this.parentNode.emit) {
+            const event = {
+                action: 'update',
+                path: this.parentNode?.getNodePath(false),
+                object: {},
+                oldObject: {},
+                originEvent: $event.originEvent,
+                eventList: $event.eventList,
+                // eventStop为true后，数据不再存入eventList，就不再会将冒泡数据发送给后端
+                eventStop: true,
+            };
+            this.parentNode?.emit?.('update', event);
+        }
+    }
+    nodeEditing($event) {
+        this.parentNode?.emit?.('node:Editing', $event);
+    }
+    createNode({ parentNode, parentKey, index }) {
+        if (!actionable_1.actionable) {
+            (0, store_1.getEventBus)().emit?.('NotActionable');
+            return;
+        }
+        if (parentNode) {
+            const property = parentNode[parentKey];
+            if (Array.isArray(property) && index !== -1) {
+                property.splice(index, 0, this);
+            }
+            else {
+                parentNode[parentKey] = this;
+            }
+            this.parentNode = parentNode;
+            this.parentKey = parentKey;
+            this.create({
+                index,
+                parentKey,
+            });
+        }
+    }
+    toTemplateJSON() {
+        return this._toJSON((source) => {
+            delete source.id;
+            delete source.i18nKey;
+            return source;
+        });
+    }
+    /**
+     * 创建节点
+     */
+    create(parentParams) {
+        if (!actionable_1.actionable) {
+            this._delete();
+            (0, store_1.getEventBus)().emit('NotActionable');
+            return;
+        }
+        patchCompose(this, 'add');
+        this.emit('create', {
+            action: 'create',
+            path: this.getNodePath(true),
+            object: this.toJSON(),
+            ...parentParams,
+            oldObject: null,
+        });
+    }
+    /**
+     * 如果有父节点，则删除节点，在添加时调用
+     */
+    ensureDelete() {
+        if (!actionable_1.actionable) {
+            (0, store_1.getEventBus)().emit('NotActionable');
+            return;
+        }
+        // 批量赋值因为连线的问题需要特殊处理一下.
+        if (this.parentNode?.concept === 'SelectMembers') {
+            this.parentNode.ensureDelete();
+            return;
+        }
+        if (this.concept === 'SelectMembers' && this.parentNode) {
+            const node = this.parentNode;
+            node.changeLinesLocation(this);
+        }
+        if (this.parentNode && this.parentKey) {
+            const path = this.getNodePath(false);
+            const parentParams = this._delete();
+            if (parentParams && parentParams.index !== -1) {
+                if (Array.isArray(this.parentNode[this.parentKey])) {
+                    this.emit('delete', {
+                        action: 'delete',
+                        path,
+                        object: null,
+                        ...parentParams,
+                    });
+                }
+                else {
+                    const parentPath = this.parentNode.getNodePath(false);
+                    this.parentNode.emit('update', {
+                        action: 'update',
+                        path: parentPath,
+                        object: {
+                            [this.parentKey]: null,
+                        },
+                        oldObject: {
+                            [this.parentKey]: this.toJSON(),
+                        },
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * 删除节点
+     */
+    delete() {
+        patchCompose(this, 'delete');
+        if (!actionable_1.actionable) {
+            (0, store_1.getEventBus)().emit('NotActionable');
+            return;
+        }
+        if (this.parentNode?.concept === 'Match' && this.parentKey === 'expression') {
+            this.parentNode.setExpressionWitchCase(null);
+            return;
+        }
+        // 批量赋值因为连线的问题需要特殊处理一下.
+        if (this.parentNode?.concept === 'SelectMembers') {
+            const node = this.parentNode;
+            node.delete();
+            return;
+        }
+        if (this.concept === 'SelectMembers') {
+            const node = this.parentNode;
+            node.changeLinesLocation(this);
+        }
+        // 自定义连接器下的namespace删除的时候需要同时删除对应的logic
+        if (this.concept === 'Namespace' && this.parentNode.concept === 'Connector') {
+            while (this.logics.length > 0) {
+                const curLogic = this.logics?.shift();
+                if (curLogic) {
+                    curLogic?.delete();
+                }
+            }
+        }
+        const useIndex = ['Identifier'].includes(this.concept);
+        const path = this.getNodePath(useIndex);
+        const parentParams = this._delete();
+        if (parentParams && parentParams.index !== -1) {
+            if (Array.isArray(this.parentNode[this.parentKey])) {
+                if (process.env.NODE_ENV === 'development') {
+                    console.log('[删除节点]', this?.name, this);
+                }
+                this.emit('delete', {
+                    action: 'delete',
+                    path,
+                    object: null,
+                    ...parentParams,
+                });
+            }
+            else {
+                const parentPath = this.parentNode.getNodePath(false);
+                this.parentNode.emit('update', {
+                    action: 'update',
+                    path: parentPath,
+                    object: {
+                        [this.parentKey]: null,
+                    },
+                    oldObject: {
+                        [this.parentKey]: this.toJSON(),
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * 更新节点
+     */
+    update({ field, ...object }) {
+        if (!actionable_1.actionable) {
+            (0, store_1.getEventBus)().emit('NotActionable');
+            return;
+        }
+        const path = this.getNodePath(false);
+        // 更新前的旧的对象
+        const oldObject = {};
+        // 更新后的新对象
+        const newObject = {};
+        const riskList = [];
+        for (const key in object) {
+            if (key === 'concept') {
+                continue;
+            }
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                // 旧对象收集
+                this.collectOldObject({
+                    oldObject,
+                    key
+                });
+                // 新对象收集
+                this.collectNewObject({
+                    newObject,
+                    object,
+                    key,
+                    riskList
+                });
+            }
+        }
+        // 更新实例上的属性
+        // 有时候需要把实例对象挂载上去，如：
+        // 批量赋值-把这个变量往这个clone里边拖的时候报内部出错 http://projectmanage.netease-official.lcap.163yun.com/dashboard/BugDetail?id=2766199685126400
+        this.updateInstance(object);
+        if (process.env.NODE_ENV === 'development') {
+            console.log('[更新节点]', 'path:', path, 'oldObject:', oldObject, 'newObject:', newObject);
+        }
+        if (newObject?.composedBy && !oldObject?.composedBy) {
+            patchCompose(this, 'add');
+        }
+        else if (!newObject?.composedBy && oldObject?.composedBy) {
+            patchCompose(this, 'delete');
+        }
+        this.emit('update', {
+            action: 'update',
+            path,
+            object: newObject,
+            oldObject,
+            field,
+            riskList,
+        });
+    }
+    // 旧对象收集
+    collectOldObject(params) {
+        const { oldObject, key } = params || {};
+        const oldProperty = this[key] ?? null;
+        oldObject[key] = oldProperty;
+        if (Array.isArray(oldProperty)) {
+            oldObject[key] = oldProperty.map((item) => {
+                let propertyItem = item ?? null;
+                if (item instanceof BaseNode_1) {
+                    propertyItem = item.toJSON();
+                }
+                return propertyItem;
+            });
+        }
+        else if (oldProperty instanceof BaseNode_1) {
+            oldObject[key] = oldProperty.toJSON();
+        }
+    }
+    // 新对象收集
+    collectNewObject(params) {
+        const { newObject, object, key, riskList } = params || {};
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(this.concept ?? this.constructor.name);
+        const property = propertyMap.get(key);
+        if (property) {
+            const objProperty = object[key] ?? null;
+            const propertyConcept = property?.objectRef;
+            // 在定义中该属性是否为数组
+            const propertyIsArray = property?.isArray;
+            const propertyDefaultValue = property?.defaultValue;
+            if (propertyIsArray && (!Array.isArray(objProperty) && objProperty != propertyDefaultValue)) {
+                riskList?.push(`将Nasl节点“${this.concept}”上声明为数组的属性“${key}”赋值为“${objProperty}”`);
+            }
+            if (propertyConcept) {
+                if (Array.isArray(objProperty)) {
+                    newObject[key] = objProperty.map((objItem) => {
+                        return this.ensureDefined({
+                            object: objItem,
+                            concept: propertyConcept,
+                            riskList
+                        });
+                    });
+                }
+                else {
+                    newObject[key] = this.ensureDefined({
+                        object: objProperty,
+                        concept: propertyConcept,
+                        riskList
+                    });
+                }
+            }
+            else {
+                newObject[key] = objProperty;
+            }
+        }
+    }
+    // 确保属性都是定义过的
+    ensureDefined(params) {
+        const { object, concept, riskList } = params || {};
+        if (!object) {
+            return object;
+        }
+        const newObject = {};
+        const actualConcept = object?.concept || concept;
+        if (actualConcept) {
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(actualConcept);
+            for (const key in object) {
+                const property = propertyMap.get(key);
+                if (property) {
+                    const objProperty = object[key] ?? null;
+                    const propertyConcept = property?.objectRef;
+                    // 在定义中该属性是否为数组
+                    const propertyIsArray = property?.isArray;
+                    const propertyDefaultValue = property?.defaultValue;
+                    if (propertyIsArray && (!Array.isArray(objProperty) && objProperty != propertyDefaultValue)) {
+                        riskList?.push(`将Nasl节点“${actualConcept}”上声明为数组的属性“${key}”赋值为“${objProperty}”`);
+                    }
+                    if (propertyConcept) {
+                        if (Array.isArray(objProperty)) {
+                            newObject[key] = objProperty.map((objItem) => {
+                                return this.ensureDefined({
+                                    object: objItem,
+                                    concept: propertyConcept,
+                                    riskList,
+                                });
+                            });
+                        }
+                        else {
+                            newObject[key] = this.ensureDefined({
+                                object: objProperty,
+                                concept: propertyConcept,
+                                riskList
+                            });
+                        }
+                    }
+                    else {
+                        newObject[key] = objProperty;
+                    }
+                }
+            }
+            newObject.concept = actualConcept;
+        }
+        return newObject;
+    }
+    // 更新实例上的属性
+    updateInstance(object) {
+        for (const key in object) {
+            if (key === 'concept') {
+                continue;
+            }
+            const property = object[key] ?? null;
+            this[key] = property;
+            const objectRefCtor = (0, decorators_1.getConceptConstructor)(property?.concept);
+            if (Array.isArray(property)) {
+                this[key] = property.map((item) => {
+                    let propertyItem = item ?? null;
+                    const propertyObjectRefCtor = (0, decorators_1.getConceptConstructor)(item?.concept);
+                    if (propertyObjectRefCtor?.from) {
+                        propertyItem = propertyObjectRefCtor.from(item, this, key);
+                    }
+                    return propertyItem;
+                });
+            }
+            else if (objectRefCtor?.from) {
+                this[key] = objectRefCtor.from(property, this, key);
+            }
+        }
+    }
+    _delete() {
+        /* override */
+        const params = {
+            parentNode: this.parentNode,
+            parentKey: this.parentKey,
+            index: -1,
+            object: null,
+            oldObject: this,
+        };
+        if (params.parentNode && params.parentKey) {
+            // @ts-ignore
+            const parentNode = params.parentNode.__v_raw || params.parentNode;
+            const parentKey = params.parentKey;
+            // @ts-ignore
+            const node = this.__v_raw || this;
+            if (Array.isArray(parentNode[parentKey])) {
+                // @ts-ignore
+                const index = parentNode[parentKey].findIndex(child => ((child?.__v_raw) || child) === node);
+                ~index && params.parentNode[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else {
+                const oldNode = parentNode[parentKey];
+                if ((oldNode?.__v_raw || oldNode) === node) {
+                    params.index = 0;
+                    params.parentNode[parentKey] = undefined;
+                }
+            }
+        }
+        return params;
+    }
+    static from(source, parentNode, parentKey) {
+        // 有一些继承的情况
+        const Ctor = (0, decorators_1.getConceptConstructor)(source?.concept) || this;
+        if (Ctor && source instanceof Ctor) {
+            if (utils.isDebugMode) {
+                console.warn('传入的对象已经是一个实例，请确认逻辑是否存在问题！');
+            }
+            if (parentNode) {
+                source.parentNode = parentNode;
+            }
+            if (parentKey) {
+                source.parentKey = parentKey;
+            }
+            return source;
+        }
+        if (Ctor) {
+            const instance = new Ctor();
+            if (parentNode) {
+                instance.parentNode = parentNode;
+            }
+            if (parentKey) {
+                instance.parentKey = parentKey;
+            }
+            let concept;
+            if (source?.concept)
+                concept = source?.concept;
+            else if (!Ctor.isAbstract) {
+                concept = this?.prototype?.concept ?? Ctor.ConceptName ?? Ctor.name;
+            }
+            else {
+                throw new Error('抽象类需要补充 concept！');
+            }
+            instance.subConstructor({
+                ...source,
+                concept,
+                parentNode,
+            });
+            return instance;
+        }
+    }
+    get nodePath() {
+        return this.getNodePath(false);
+    }
+    getTokenKeyWithNamespace() {
+        /**
+         * 本来想在 BaseNode 上加个 getNamespace 方法作为默认的类型的
+         * 但是没想到上层有逻辑依赖了判断节点是否有这个方法，加上这个默认方法之后有些功能挂了，所以这里不得不使用 as any
+         */
+        return `${this.getNamespace()}.${this.name}`;
+    }
+    getNodePath(useIndex) {
+        let node = this;
+        let useIndexKeys = [];
+        let option = {};
+        if (Array.isArray(useIndex)) {
+            useIndexKeys = useIndex;
+            useIndex = false;
+        }
+        else if (useIndex && typeof useIndex === 'object') {
+            option = useIndex;
+        }
+        let isNodeSelf = true;
+        const pathArr = [];
+        while (node) {
+            let path = '';
+            const { parentNode } = node;
+            if (parentNode) {
+                const { parentKey } = node;
+                path = parentKey;
+                const parentProperty = parentNode[parentKey];
+                if (Array.isArray(parentProperty)) {
+                    const { name } = node;
+                    // 如果存在同名节点，使用下标来表示NodePath
+                    const siblingNode = name
+                        ? parentProperty.find((child) => {
+                            // 因为proxy的关系，导致两边的引用不相同，所以这里需要判断id
+                            return child?.name === name && child !== node && child?.id !== node?.id;
+                        })
+                        : null;
+                    if (!(option.useName && name) && (siblingNode || !name || (useIndex && isNodeSelf) || useIndexKeys.includes(node.concept))) {
+                        const index = parentProperty.findIndex((item) => {
+                            if (item === node) {
+                                return true;
+                            }
+                            return item?.id && item?.id === node?.id;
+                        });
+                        path += `[${index}]`;
+                    }
+                    else {
+                        path += `[name=${name}]`;
+                    }
+                }
+                pathArr.unshift(path);
+            }
+            node = parentNode;
+            isNodeSelf = false;
+        }
+        pathArr.unshift('app');
+        return pathArr.join('.');
+    }
+    /**
+     * 上层节点
+     */
+    get upperNode() {
+        // eslint-disable-next-line consistent-this
+        let _upperNode = this;
+        while (!!_upperNode && _upperNode.concept === this.concept) {
+            _upperNode = _upperNode.parentNode;
+        }
+        return _upperNode;
+    }
+    /**
+     * 根节点
+     */
+    get rootNode() {
+        return this.getAncestor('App');
+    }
+    getAncestor(concept) {
+        let { parentNode } = this;
+        while (parentNode && parentNode.concept && ((parentNode.concept !== concept)
+            && (!parentNode.constructor.inheritanceChain?.includes(concept)))) {
+            parentNode = parentNode.parentNode;
+        }
+        return parentNode;
+    }
+    get app() {
+        return this.getAncestor('App');
+    }
+    /**
+     *
+     * @param source
+     * @param Ctor
+     * @param completeList
+     * @param idsList
+     */
+    handleSource(source, completeList) {
+        completeList.push(source);
+        // const { id, concept } = source || {};
+        // const actualSource = source instanceof BaseNode ? source : getSourceFromMap(id, concept);
+        // completeList.push(actualSource || source);
+    }
+    /**
+     * 获取当前的TsName
+     */
+    get tsName() {
+        if (this.name) {
+            let tsName = this.name;
+            // 匹配所有特殊字符都转为_
+            tsName = tsName.replace(/\W/g, '_');
+            if (/^\d/.test(tsName)) {
+                tsName = `$${tsName}`;
+            }
+            return tsName;
+        }
+        return '';
+    }
+    get editing() {
+        return this.__editing;
+    }
+    // 修改节点编辑状态的时候需要抛个事件出去
+    set editing(value) {
+        this.__editing = value;
+        this.emit('node:Editing', {
+            value
+        });
+    }
+    /**
+     * 生成json
+     * @param instance
+     * @param Ctor
+     */
+    genSources(instance, filerFn) {
+        if (!instance) {
+            return instance;
+        }
+        if (Array.isArray(instance)) {
+            return instance.map((item) => (item && item._toJSON ? item._toJSON(filerFn) : item));
+        }
+        return instance && instance._toJSON ? instance._toJSON(filerFn) : instance;
+    }
+    /**
+     * 实例化一个 JSON
+     * 由于有 from，只能先实例化父级，再实例化子级
+     * @param obj
+     * @param parentNode
+     * @returns
+     */
+    instantiate(source, parentNode, parentKey) {
+        if (source instanceof BaseNode_1) {
+            if (!source.parentNode || !source.parentKey) {
+                source.parentNode = parentNode;
+                source.parentKey = parentKey;
+            }
+            return source;
+        }
+        if (source && source.concept) {
+            const Ctor = (0, decorators_1.getConceptConstructor)(source.concept);
+            if (!Ctor.from) {
+                return source;
+            }
+            const instance = Ctor.from(source, parentNode, parentKey);
+            if (instance && instance.toStorageJSON)
+                instance.storageJSON = instance.toStorageJSON();
+            return instance;
+        }
+        return source;
+    }
+    /**
+     * 激活 JSON 内部实例
+     * @param source
+     */
+    instantiateSub(source, parentKey) {
+        if (!source) {
+            return;
+        }
+        const completeList = [];
+        let isArray;
+        // 暂时通过是否有name判断数据是否全
+        if (Array.isArray(source)) {
+            isArray = true;
+            source.forEach((sourceItem) => {
+                this.handleSource(sourceItem, completeList);
+            });
+        }
+        else {
+            this.handleSource(source, completeList);
+        }
+        const instanceList = completeList.map((item) => this.instantiate(item, this, parentKey));
+        if (isArray) {
+            return instanceList;
+        }
+        if (Array.isArray(instanceList) && instanceList.length) {
+            return instanceList[0];
+        }
+    }
+    plainAssign(source) {
+        this._mutable = true;
+        const oldId = this.id;
+        Object.keys(source).forEach((key) => {
+            const value = source[key];
+            if (typeof value !== 'object' && typeof value !== 'function')
+                this[key] = value;
+        });
+        this._mutable = false;
+    }
+    pick(source, keys = []) {
+        const obj = {};
+        keys.forEach((key) => (obj[key] = source[key]));
+        // 这里统一用 assign，集中处理 id 的问题
+        // this.assign(obj);
+    }
+    /**
+     * 从对象中深度获取
+     * @param source
+     * @param keys
+     * @example 比如一般后端返回只是添加了个 id
+     * ```
+     * this.deepPick(result, ['id'])
+     */
+    deepPick(source, keys = []) {
+        utils.traverse((current) => {
+            const subSource = current.jsonPath ? (0, lodash_1.at)(source, [current.jsonPath])[0] : source;
+            const target = current.jsonPath ? (0, lodash_1.at)(this, [current.jsonPath])[0] : this;
+            if (!target)
+                return;
+            const obj = {};
+            keys.forEach((key) => {
+                if (subSource.hasOwnProperty(key)) {
+                    obj[key] = subSource[key];
+                }
+            });
+            // 这里统一用 assign，集中处理 id 的问题
+            target.assign ? target.assign(obj) : Object.assign(target, obj);
+        }, { node: source }, { mode: 'anyObject' });
+    }
+    /**
+     * 去除循环依赖，转为纯 JSON
+     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+     * @param excludedKeys 需要额外排除的 keys
+     */
+    toJSON() {
+        return this._toJSON();
+    }
+    _toJSON(filerFn) {
+        const propertyMap = (0, decorators_1.getConceptPropertyMap)(this.concept || this.constructor.name);
+        const source = {};
+        propertyMap.forEach((property, key) => {
+            if (property) {
+                const { objectRef: propertyObjectRef } = property;
+                if (!propertyObjectRef) {
+                    source[key] = this[key];
+                }
+                else {
+                    const sources = this.genSources(this[key], filerFn);
+                    source[key] = sources;
+                }
+            }
+        });
+        // @ts-ignore
+        source.concept = this.concept;
+        return filerFn ? filerFn(source, this) : source;
+    }
+    /**
+     * 转为单层的 JSON
+     * @param parentKey 外面的 key，提供给 JSON.stringify 使用
+     * @param excludedKeys 需要额外排除的 keys
+     */
+    toPlainJSON(parentKey, excludedKeys = []) {
+        const JSON_EXCLUDED_KEYS = new Set(this.JSON_EXCLUDED_KEYS || []); // Object.getPrototypeOf(this).constructor.JSON_EXCLUDED_KEYS || [];
+        excludedKeys.forEach((key) => JSON_EXCLUDED_KEYS.add(key));
+        const temp = {};
+        Object.keys(this).forEach((key) => {
+            const value = this[key];
+            if (!JSON_EXCLUDED_KEYS.has(key) && typeof value !== 'object' && typeof value !== 'function')
+                temp[key] = value;
+        });
+        return JSON.parse(JSON.stringify(temp));
+    }
+    // 给国际化展示用
+    getNodeChinesePath(useIndex) {
+        let node = this;
+        const pathArr = [];
+        while (node && node.concept) {
+            let pathText = '';
+            const { parentNode } = node;
+            if (parentNode) {
+                const { name, title, label } = parentNode;
+                pathText = `${parentNode.constructor?.nodeTitle || ''}${name || ''}`;
+                const labelValue = label?.value || label;
+                if (title && label) {
+                    pathText += `(${title} | ${labelValue})`;
+                }
+                else if (title || label) {
+                    pathText += `(${title || labelValue})`;
+                }
+                pathArr.unshift(pathText);
+            }
+            node = parentNode;
+        }
+        return pathArr.join('/');
+    }
+    /**
+     * 查找引用
+     */
+    async findUsage() {
+        /* override */
+    }
+    /**
+     * 通过当前节点，查找被引用的节点
+     */
+    async nodeFindRefNodes() {
+        /* override */
+    }
+    async findReadOnlyLogicUsage() {
+        /* override */
+    }
+    /**
+     * 重命名
+     */
+    async changeName(newValue, updateAll = false) {
+        /* override */
+    }
+    /**
+     * 移除绑定实体元素的页面元素
+     */
+    async removeBindEntityPropertyViewEelment() {
+        /* override */
+    }
+    /**
+     * 准备删除
+     */
+    async prepareDelete(cb) {
+        /* override */
+    }
+    /**
+     * 添加参数准备
+     */
+    async addParamsPrepare() {
+        /* override */
+    }
+    /**
+     * 获取当前节点类型
+     */
+    async getCurrentTypeAnnotation(outTime) {
+        /* override */
+    }
+    /**
+     * 获取当前节点的下一级内容
+     */
+    getSelectRef(newTypeAnnotation, needNewStructure = false) {
+        /* override */
+    }
+    /**
+     * 销毁
+     * 从 Map 中删除点和子节点
+     */
+    destroy() {
+        // utils.traverse((current) => , { node: this }, {
+        //     mode: 'anyObject',
+        //     excludedKeySet: this.JSON_EXCLUDED_KEYS,
+        // });
+    }
+    onChange($event) {
+        this.emit('change', $event);
+    }
+    onCreate($event) {
+        /* override */
+    }
+    onDelete($event) {
+        /* override */
+    }
+    /**
+     * 移动节点
+     * @param sourceNode
+     * @param position
+     */
+    moveNode(options) {
+        if (!actionable_1.actionable) {
+            (0, store_1.getEventBus)().emit('NotActionable');
+            return;
+        }
+        const { sourceNode, position } = options;
+        if (this.concept === 'App') {
+            return;
+        }
+        let actionMsg = `移动${this.constructor.nodeTitle}`;
+        if (this.name) {
+            actionMsg += `“${this.name}”`;
+        }
+        sourceNode.app.emit('collect:start', {
+            actionMsg,
+        });
+        // 如果是兄弟节点之前的移动
+        if (position !== 'append' && this.concept !== sourceNode.concept) {
+            return;
+        }
+        // 先删
+        this.delete();
+        if (position === 'append') {
+            let { action } = options;
+            if (!action)
+                action = `add${this.concept}`;
+            const parentNode = sourceNode;
+            parentNode[action](this);
+        }
+        else {
+            const parentNode = sourceNode?.parentNode;
+            const parentKey = sourceNode?.parentKey || '';
+            const list = parentNode[parentKey];
+            if (Array.isArray(list)) {
+                let index = list.indexOf(sourceNode);
+                if (position === 'insertAfter') {
+                    index += 1;
+                }
+                Object.assign(this, {
+                    parentNode,
+                    parentKey,
+                });
+                // 和原开发沟通过，可注释掉这行，否则拖拽的时候会更新name
+                // if (this.concept === 'ViewElement') this.name = (this as unknown as ViewElement).getViewElementUniqueName(this.name);
+                list.splice(index, 0, this);
+                this.create({
+                    index,
+                    parentNode,
+                    parentKey,
+                });
+            }
+        }
+        sourceNode.app.emit('collect:end');
+    }
+    // 其他节点替换本nasl节点
+    replaceNode(newNode) {
+        const oldNode = this;
+        const { parentNode, parentKey, offsetX, offsetY, app } = oldNode;
+        const { logic } = oldNode;
+        if (!Array.isArray(parentNode[parentKey])) {
+            /**
+             * match切换分支，需要调用setExpressionWitchCase，补全分支的信息
+             */
+            if (parentNode.concept === 'Match' && parentKey === 'expression') {
+                parentNode.setExpressionWitchCase(newNode);
+                return;
+            }
+            parentNode.update({
+                [parentKey]: newNode,
+            });
+        }
+        else {
+            app?.emit?.('collect:start', {
+                actionMsg: '删除属性变量',
+            });
+            if (parentNode.concept === 'Logic') {
+                if (parentKey === 'body') {
+                    const expIndex = logic.body.findIndex((item) => item === oldNode);
+                    logic.insertItemInBodyAt(newNode, expIndex);
+                }
+                else {
+                    const expIndex = logic.playground.findIndex((item) => item === oldNode);
+                    Object.assign(newNode, { offsetX, offsetY });
+                    logic.insertItemInPlaygroundAt(newNode, expIndex);
+                }
+            }
+            else {
+                const expIndex = parentNode[parentKey].findIndex((item) => item === oldNode);
+                const firstUpperText = parentKey[0].toUpperCase() + parentKey.slice(1, parentKey.length);
+                Object.assign(newNode, { offsetX, offsetY });
+                if (parentNode.concept === 'MatchCase') {
+                    parentKey === 'body' ? parentNode.insertItemInBodyAt(newNode, expIndex) : parentNode.insertLogicItemInPatternsAt(newNode, expIndex);
+                }
+                else if (parentNode[`insertItemIn${firstUpperText}At`])
+                    parentNode[`insertItemIn${firstUpperText}At`](newNode, expIndex);
+                else
+                    parentNode.insertItemAt(newNode, expIndex);
+            }
+            oldNode.delete();
+            app.emit('collect:end');
+        }
+    }
+    // 查找当前节点所有引用并进行同步更新
+    async updateRelyFileNode(app) {
+        let relyfileNode = [];
+        try {
+            // 获取old接口的依赖放到一起更新,可以让使用方重新生成内容
+            relyfileNode = await app.naslServer.findCallLogicFileRef(this.parentNode);
+        }
+        catch (err) {
+            console.log('更新对应引用方失败', err);
+        }
+        // 如果依赖项有值，只要是为了触发更新，为了重新取到引用生成代码
+        if (relyfileNode.length) {
+            relyfileNode.forEach((fileNode) => {
+                app.naslServer?.embeddedTSEmitter.emit('change', {
+                    value: [
+                        {
+                            originEvent: {
+                                action: 'update',
+                                target: fileNode,
+                            }
+                        }
+                    ]
+                });
+            });
+        }
+    }
+    /**
+     * 获取添加时的默认选项
+     * @returns
+     */
+    static getDefaultOptions() {
+        return {};
+    }
+    /**
+     * 迭代所有属性
+     *
+     * @description 是所有属性！！不是所有子节点！！
+     * @deprecated 请使用`traverseStrictChildren`方法
+     */
+    traverseChildren(cb, whitelist) {
+        function traverse(node) {
+            cb(node);
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap)
+                return;
+            const propertyKeys = [...propertyMap.keys()];
+            if (Array.isArray(whitelist) && whitelist.length) {
+                propertyKeys.push(...whitelist);
+            }
+            for (const property of propertyKeys) {
+                const child = node[property];
+                if (!child)
+                    continue;
+                else if (Array.isArray(child))
+                    child?.forEach?.((node) => traverse(node));
+                else
+                    traverse(child);
+            }
+        }
+        traverse(this);
+    }
+    /**
+     * 生成器中序遍历节点
+     *
+     * @description 与`traverseChildren`不同，此方法会过滤掉非节点值
+     */
+    *traverseChildrenGenerator(cb) {
+        const isNode = (node) => {
+            return Boolean(node) && typeof node === 'object' && ('concept' in node) && typeof node.concept === 'string';
+        };
+        function* traverse(node) {
+            if (isNode(node)) {
+                const result = cb(node);
+                if (utils.isGenerator(result)) {
+                    yield* result;
+                }
+                else {
+                    yield;
+                }
+            }
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap) {
+                yield;
+                return;
+            }
+            for (const property of propertyMap.keys()) {
+                const prop = node[property];
+                if (!prop) {
+                    continue;
+                }
+                else if (Array.isArray(prop)) {
+                    for (const child of prop) {
+                        yield* traverse(child);
+                    }
+                }
+                else {
+                    yield* traverse(prop);
+                }
+            }
+            yield;
+        }
+        yield* traverse(this);
+    }
+    /**
+     * 迭代所有子节点
+     *
+     * @description 严格迭代所有子节点！排除属性！
+     */
+    traverseStrictChildren(cb, whitelist) {
+        this.traverseChildren((el) => {
+            if (concepts_1.asserts.isBaseNode(el)) {
+                cb(el);
+            }
+        }, whitelist);
+    }
+    /**
+     * 迭代所有子节点
+     *
+     * @description 严格迭代所有子节点！排除属性！条件满足时可提前终止！
+     */
+    traverseStrictChildrenStopWhen(cb, setStopFlag, whitelist) {
+        let shouldStop = false;
+        // if ((node instanceof View || node instanceof ViewElement) && node.auth) flag = true;
+        function traverse(node) {
+            if (concepts_1.asserts.isBaseNode(node)) {
+                cb(node);
+            }
+            shouldStop = shouldStop || setStopFlag(node);
+            if (shouldStop) {
+                return;
+            }
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap)
+                return;
+            const propertyKeys = [...propertyMap.keys()];
+            if (Array.isArray(whitelist) && whitelist.length) {
+                propertyKeys.push(...whitelist);
+            }
+            for (const property of propertyKeys) {
+                const child = node[property];
+                if (!child)
+                    continue;
+                else if (Array.isArray(child))
+                    child?.forEach?.((node) => traverse(node));
+                else
+                    traverse(child);
+            }
+        }
+        traverse(this);
+    }
+    /**
+     * 带剪枝的迭先序遍历
+     *
+     * @description 严格迭代所有子节点！排除属性！
+     * @description 回调返回`true`时将不会继续迭代子树
+     * @description 注意：这里只是不会继续递归子树，而不是终止整个迭代流程
+     */
+    traverseStrictChildrenWithPruning(cb) {
+        function traverse(node) {
+            const result = cb(node);
+            if (result) {
+                return;
+            }
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap) {
+                return;
+            }
+            const propertyKeys = [...propertyMap.keys()];
+            for (const property of propertyKeys) {
+                const child = node[property];
+                if (!child) {
+                    continue;
+                }
+                else if (Array.isArray(child)) {
+                    child.forEach((node) => {
+                        if (concepts_1.asserts.isBaseNode(node)) {
+                            traverse(node);
+                        }
+                    });
+                }
+                else {
+                    if (concepts_1.asserts.isBaseNode(node)) {
+                        traverse(child);
+                    }
+                }
+            }
+        }
+        traverse(this);
+    }
+    /**
+     *  获取当前节点在nasl标注节点上的节点
+     */
+    getCurrentAnnotatedJSON() {
+        return this.__TypeAnnotation;
+    }
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    getCurrentSource() {
+        const node = this;
+        let { sourceMap } = node;
+        let fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap && fileNode && !(fileNode?.parentNode?.concept === 'App')) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode?.sourceMap;
+        }
+        const currentSource = sourceMap && sourceMap.get(node);
+        if (currentSource) {
+            return { currentSource, fileNode };
+        }
+        return { fileNode };
+    }
+    /**
+     *  获取
+     *  当前this上下文 的Source 和 父级文件级别的节点
+     */
+    getFileConceptNode(concept) {
+        const node = this;
+        let { sourceMap } = node;
+        let fileNode = node;
+        // 如果没有sourceMap,就继续向上找 ,或者到module结束
+        // 如果 节点找到 app 或者module 停止 或者entity找到DataSource为止
+        // 如果当前节点是view就不要向上查找了
+        while (!sourceMap && fileNode && !(fileNode.parentNode.concept === 'App')) {
+            fileNode = fileNode.parentNode;
+            sourceMap = fileNode?.sourceMap;
+        }
+        const arr = [];
+        sourceMap &&
+            sourceMap.forEach((value, key) => {
+                if (key.concept === concept)
+                    arr.push({ key, value });
+            });
+        return arr;
+    }
+    get isTreeLeaf() {
+        if (this.concept === 'EntityProperty' ||
+            this.concept === 'InterfaceParam' ||
+            this.concept === 'Param' ||
+            this.concept === 'Return' ||
+            this.concept === 'StructureProperty' ||
+            this.concept === 'Variable' ||
+            this.concept === 'FrontendVariable') {
+            if (this.typeAnnotation || (this.__TypeAnnotation && this.parentKey === 'virtualParams')) {
+                return !this.hasChildren;
+            }
+            return true;
+        }
+        return false;
+    }
+    get hasChildren() {
+        const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
+        if (typeAnnotation) {
+            const { typeKind, typeNamespace, typeName, properties } = typeAnnotation;
+            if (typeKind === 'reference' || typeKind === 'generic') {
+                if (typeNamespace?.endsWith('.enums'))
+                    return null;
+                return [{}];
+            }
+            if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
+                return [{}];
+            }
+            if (typeKind === 'anonymousStructure' && properties?.length) {
+                return [{}];
+            }
+            return null;
+        }
+        return null;
+    }
+    collectNodes(input) {
+        const pre = typeof input === 'undefined'
+            ? (node) => concepts_1.asserts.isBaseNode(node)
+            : typeof input === 'string'
+                ? (node) => concepts_1.asserts[`isStrict${input}`]?.(node) ?? false
+                : input;
+        const nodes = [];
+        const self = this;
+        if (pre(self)) {
+            nodes.push(self);
+        }
+        this.traverseStrictChildren((current) => {
+            if (pre(current)) {
+                nodes.push(current);
+            }
+        });
+        return nodes;
+    }
+    findNode(input) {
+        const pre = typeof input === 'undefined'
+            ? (node) => concepts_1.asserts.isBaseNode(node)
+            : typeof input === 'string'
+                ? (node) => concepts_1.asserts[`isStrict${input}`]?.(node) ?? false
+                : input;
+        function traverse(node) {
+            const result = Boolean(node) && pre(node);
+            if (result) {
+                return node;
+            }
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap) {
+                return;
+            }
+            for (const property of propertyMap.keys()) {
+                const child = node[property];
+                let result = undefined;
+                if (!child) {
+                    continue;
+                }
+                else if (Array.isArray(child)) {
+                    for (const item of child) {
+                        result = traverse(item);
+                        if (result) {
+                            break;
+                        }
+                    }
+                }
+                else {
+                    result = traverse(child);
+                }
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return traverse(this);
+    }
+    /**
+     * 广度遍历子节点，如果当前节点满足pre 函数，将不会再向下遍历
+     * @param input 搜索条件
+     * @param containsSelf: 是否包含自身
+     * @returns 搜索到的节点
+     */
+    findNaslNodeByBFS(input, containsSelf = false) {
+        const pre = typeof input === 'undefined'
+            ? (node) => concepts_1.asserts.isBaseNode(node)
+            : typeof input === 'string'
+                ? (node) => concepts_1.asserts[`isStrict${input}`]?.(node) ?? false
+                : input;
+        const queue = []; // 创建一个队列存储待遍历的节点
+        const results = []; // 创建一个数组存储匹配的结果
+        queue.push(this); // 将初始节点加入队列
+        while (queue.length > 0) {
+            const node = queue.shift(); // 从队列中取出一个节点
+            if (node) {
+                let result = false;
+                if (!containsSelf) {
+                    result = node !== this && Boolean(node) && pre(node);
+                }
+                else {
+                    result = Boolean(node) && pre(node);
+                }
+                if (result) {
+                    results.push(node); // 如果pre函数返回true，则将节点添加到结果数组
+                    continue; // 继续下一次循环，继续遍历同层级的其他节点
+                }
+                const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+                if (!propertyMap) {
+                    continue; // 如果没有属性映射，则继续下一次循环
+                }
+                for (const property of propertyMap.keys()) {
+                    const child = node[property];
+                    // 如果子节点不存在，则继续下一次循环
+                    if (!child) {
+                        continue; // 如果子节点不存在，则继续下一次循环
+                    }
+                    else if (Array.isArray(child)) {
+                        for (const item of child) {
+                            const itemResult = Boolean(item) && pre(item);
+                            if (itemResult) {
+                                results.push(item); // 如果pre函数返回true，则将节点添加到结果数组
+                                continue; // 继续下一次循环，继续遍历同层级的其他节点；
+                            }
+                            // 只有节点是一个 NaslNode 才会继续遍历
+                            if (concepts_1.asserts.isBaseNode(item)) {
+                                queue.push(item); // 将子节点加入队列
+                            }
+                        }
+                    }
+                    else {
+                        const childResult = Boolean(child) && pre(child);
+                        if (childResult) {
+                            results.push(child); // 如果pre函数返回true，则将节点添加到结果数组
+                            continue;
+                        }
+                        if (concepts_1.asserts.isBaseNode(child)) {
+                            queue.push(child); // 将子节点加入队列
+                        }
+                    }
+                }
+            }
+        }
+        return results; // 返回匹配的结果数组
+    }
+    *toEmbeddedTS() {
+        throw new Error('方法未实现');
+    }
+    *toEmbeddedTSFile() {
+        throw new Error('方法未实现');
+    }
+    toEmbeddedDeclarationTSFile() {
+        throw new Error('方法未实现');
+    }
+    /**
+     * 生成自然语言 TS
+     * @param state 编译状态
+     * @returns 生成的代码
+     */
+    // @withSourceMap()
+    toNaturalTS(state = (0, nasl_translator_1.createCompilerState)()) {
+        return '[编译方法未实现]';
+    }
+    /**
+     * 生成文本化代码
+     * @param state 编译状态
+     * @returns 生成的代码
+     */
+    // @withSourceMap()
+    toTextualNASL(state = (0, nasl_translator_1.createCompilerState)()) {
+        return '[编译方法未实现]';
+    }
+    /**
+     * 调试用的 ToTS 接口
+     */
+    toDebugTs() {
+        utils.runGeneratorAsync(this.toEmbeddedTS()).then((data) => {
+            console.dir(data);
+        });
+    }
+    /**
+     * 判断目标节点是否为当前节点的祖先节点
+     */
+    isAncestor(node) {
+        let { parentNode } = this;
+        while (parentNode) {
+            if (parentNode === node) {
+                return true;
+            }
+            parentNode = parentNode.parentNode;
+        }
+        return false;
+    }
+    /**
+     * 迭代所有属性
+     */
+    traverseChildrenWithContext(cb) {
+        function traverse(node, context) {
+            if (concepts_1.asserts.isBaseNode(node)) {
+                cb(node, context);
+            }
+            const propertyMap = (0, decorators_1.getConceptPropertyMap)(node?.concept);
+            if (!propertyMap) {
+                return;
+            }
+            for (const property of propertyMap.keys()) {
+                const child = node[property];
+                if (!child) {
+                    continue;
+                }
+                else if (Array.isArray(child)) {
+                    child?.forEach?.((node) => {
+                        traverse(node, {
+                            ...context
+                        });
+                    });
+                }
+                else {
+                    traverse(child, {
+                        ...context
+                    });
+                }
+            }
+        }
+        traverse(this, {});
+    }
+};
+exports.BaseNode = BaseNode;
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "_mutable", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "_concept", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "concept", null);
+__decorate([
+    (0, decorators_1.whiteProperty)()
+], BaseNode.prototype, "workingCopy", void 0);
+__decorate([
+    (0, decorators_1.whiteProperty)()
+], BaseNode.prototype, "branch", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "breakpoint", void 0);
+__decorate([
+    (0, decorators_1.circular)()
+], BaseNode.prototype, "parentNode", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "editable", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "removable", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "loading", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "expanded", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "hidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "pageTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "logicTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "dataTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "processTreeNodeHidden", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "logicTreeNodeExpanded", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "sourceMap", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "isLeaf", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "storageJSON", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "name", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], BaseNode.prototype, "composedBy", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "__TypeAnnotation", void 0);
+__decorate([
+    (0, decorators_1.excludedInJSON)()
+], BaseNode.prototype, "__isCorrectTypeAnnotation", void 0);
+__decorate([
+    (0, decorators_1.action)('查找引用')
+], BaseNode.prototype, "findUsage", null);
+__decorate([
+    (0, decorators_1.action)('通过当前节点，查找被引用的节点')
+], BaseNode.prototype, "nodeFindRefNodes", null);
+__decorate([
+    (0, decorators_1.action)('重命名')
+], BaseNode.prototype, "changeName", null);
+__decorate([
+    (0, decorators_1.action)('移除绑定实体元素的页面元素')
+], BaseNode.prototype, "removeBindEntityPropertyViewEelment", null);
+__decorate([
+    (0, decorators_1.action)('准备删除')
+], BaseNode.prototype, "prepareDelete", null);
+__decorate([
+    (0, decorators_1.action)('添加参数准备')
+], BaseNode.prototype, "addParamsPrepare", null);
+__decorate([
+    (0, decorators_1.action)('获取当前节点类型')
+], BaseNode.prototype, "getCurrentTypeAnnotation", null);
+__decorate([
+    (0, decorators_1.action)('获取当前节点的下一级内容')
+], BaseNode.prototype, "getSelectRef", null);
+exports.BaseNode = BaseNode = BaseNode_1 = __decorate([
+    nasl_sentry_1.sentryMonitorNaslNode
+], BaseNode);
+exports.default = BaseNode;
+//# sourceMappingURL=BaseNode.js.map