@lcap/nasl 2.20.1-beta.2 → 2.21.0-beta.2

package/src/concepts/Logic__.ts

@@ -166,6 +166,9 @@ export class Logic extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Logic';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Logic {
         return super.from(source, parentNode, parentKey) as Logic;
@@ -246,7 +249,7 @@ export class Logic extends BaseNode {
         });
     }
 
-    getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
+        getTypeParamExistingNames(excludedList: Array<TypeParam> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.typeParams as TypeParam[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -387,6 +390,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getParamUniqueName(name = 'param1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -524,6 +528,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -661,6 +666,7 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, false);
     }
@@ -798,6 +804,11 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
+
+
+    
+
     /**
     * 插入逻辑项
     * @internal
@@ -830,6 +841,8 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
+    
+
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -852,6 +865,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加逻辑项
      * @internal
@@ -871,6 +886,8 @@ export class Logic extends BaseNode {
         return this._insertItemInBodyAt(options as any, index);
     }
 
+    
+
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -894,6 +911,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
     * 插入逻辑项
     * @internal
@@ -926,6 +945,8 @@ export class Logic extends BaseNode {
         return logicItem;
     }
 
+    
+
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -948,6 +969,8 @@ export class Logic extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加逻辑项
      * @internal
@@ -967,6 +990,8 @@ export class Logic extends BaseNode {
         return this._insertItemInPlaygroundAt(options as any, index);
     }
 
+    
+
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -990,6 +1015,9 @@ export class Logic extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
     * 删除事务
     * @param name 事务名称
@@ -1038,6 +1066,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除类型参数
     * @param name 类型参数名称
@@ -1086,6 +1116,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除输入参数
     * @param name 输入参数名称
@@ -1134,6 +1166,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除输出参数
     * @param name 输出参数名称
@@ -1182,6 +1216,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除变量
     * @param name 变量名称
@@ -1230,6 +1266,8 @@ export class Logic extends BaseNode {
         return params;
     }
 
+
+
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1237,10 +1275,12 @@ export class Logic extends BaseNode {
     removeItemInBody(logicItem: LogicItem): void;
 
     removeItemInBody(options: LogicItem) {
-        const logicItem: LogicItem = options;
+        let logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
+    
+
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -1248,7 +1288,7 @@ export class Logic extends BaseNode {
     removeItemInPlayground(logicItem: LogicItem): void;
 
     removeItemInPlayground(options: LogicItem) {
-        const logicItem: LogicItem = options;
+        let logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
@@ -1648,14 +1688,12 @@ export class Logic extends BaseNode {
             Promise.all(needGetSourceMapOqlList).then(() => {
                 // 触发一下更新重新生成代码
                 (this.app as any)?.naslServer?.embeddedTSEmitter.emit('change', {
-                    value: [
-                        {
-                            originEvent: {
-                                action: 'update',
-                                target: this,
-                            },
+                    value: [{
+                        originEvent: {
+                            action: 'update',
+                            target: this,
                         },
-                    ],
+                    }],
                 });
             });
         }
@@ -1667,13 +1705,11 @@ export class Logic extends BaseNode {
         code += '{\n';
 
         // 用于虚拟节点的查找引用
-        this.virtualParams
-            && Array.isArray(this.virtualParams)
-            && this.virtualParams.forEach((param) => {
-                code += indent((state?.tabSize || 0) + 1);
-                code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
-                code += '\n';
-            });
+        this.virtualParams && Array.isArray(this.virtualParams) && this.virtualParams.forEach((param) => {
+            code += indent((state?.tabSize || 0) + 1);
+            code += param.toEmbeddedNameTS(shiftState(state, code, { inline: true }));
+            code += '\n';
+        });
 
         this.variables.forEach((variable) => {
             if (!advanceMap.get(variable)) {
@@ -1697,12 +1733,12 @@ export class Logic extends BaseNode {
             code += node.toEmbeddedTS(shiftState(state, code, { inline: true }));
             if (assignment instanceof BatchAssignment) {
                 assignment.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
-                    const leftCode
-                        = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                    const leftCode = leftIndex.length === 1 ? assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true })) : assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true }));
                     if (leftCode === node.name) {
                         const rightNode: any = rightIndex.length === 1 ? assignment.rights[rightIndex[0]]?.expression : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
                         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-                        if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                        if (rightNode?.typeAnnotation
+                            && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                             code += ': ';
                             code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                         } else {
@@ -1723,7 +1759,8 @@ export class Logic extends BaseNode {
             } else {
                 const rightNode: any = assignment.right;
                 // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-                if (rightNode?.typeAnnotation && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
+                if (rightNode?.typeAnnotation
+                    && !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')) {
                     code += ': ';
                     code += rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) || 'null';
                 } else {
@@ -1733,7 +1770,7 @@ export class Logic extends BaseNode {
                     if (rightNode && rightNode instanceof Identifier && rightNode.namespace && rightNode.namespace.endsWith('enums')) {
                         rightCode += 'new ';
                     }
-                    rightCode += rightNode && rightNode.toEmbeddedTS ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
+                    rightCode += (rightNode && rightNode.toEmbeddedTS) ? rightNode.toEmbeddedTS(shiftState(state, code, { inline: true })) : '__RIGHT__';
                     code += this.getRightCode(rightCode, assignment, rightNode);
                 }
             }
@@ -1834,7 +1871,7 @@ export class Logic extends BaseNode {
             code = this.handleReplaceCode(code, item.name, eachTSCode === '__IDENTIFIER__' ? eachTSCode : `${eachTSCode}.__get(0)`);
         }
         if (code.includes(index.name))
-            code = this.handleReplaceCode(code, index.name, 'new nasl.core.Integer(0)');
+            code = this.handleReplaceCode(code, index.name, 'new nasl.core.Long(0)');
 
         const parentForEachStatement = forEachStatement.getAncestor('ForEachStatement') as ForEachStatement;
         if (parentForEachStatement) {
@@ -1878,10 +1915,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (
-                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
-                && !namespace.includes('.logics')
-            ) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -1898,10 +1932,7 @@ export class Logic extends BaseNode {
                 arr.push(parentName);
             }
             let namespace = arr.join('.');
-            if (
-                !['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace)
-                && !namespace.includes('.logics')
-            ) {
+            if (!['nasl.ui', 'nasl.utils', 'nasl.util', 'nasl.browser', 'nasl.auth', 'nasl.configuration', 'nasl.process', 'nasl.logging', 'nasl.io'].includes(namespace) && !namespace.includes('.logics')) {
                 namespace = `${namespace}.logics`;
             }
             return namespace;
@@ -2044,9 +2075,55 @@ export class Logic extends BaseNode {
     // 虚拟输入参数列表
     virtualParams: Array<Param> = [];
 
-    get getLogicBelongTo() {
-        const [, belongTo] = this.calleewholeKey.split('.');
-        return belongTo;
+    /* 零时用  需要删除*/
+    addParamsFunction() {
+        this.addParam({
+            name: 'param5',
+            typeAnnotation: TypeAnnotation.from({
+                typeKind: 'function',
+                typeName: 'String',
+                typeNamespace: 'nasl.core',
+                returnType: [TypeAnnotation.from({
+                    typeKind: 'primitive',
+                    typeName: 'Boolean',
+                    typeNamespace: 'nasl.core',
+                })],
+                typeArguments: [
+                    TypeAnnotation.from({
+                        typeKind: 'primitive',
+                        typeName: 'String',
+                        typeNamespace: 'nasl.core',
+                    }),
+                    TypeAnnotation.from({
+                        typeKind: 'primitive',
+                        typeName: 'Boolean',
+                        typeNamespace: 'nasl.core',
+                    }),
+                ],
+            }),
+
+        });
+    }
+
+    // 校验logic的返回值是不是有error类型
+    static checkLogicReturnTypeHasError(logic: Logic) {
+        let findHasError = false;
+        if (!logic) {
+            return findHasError;
+        }
+        if (logic.returns?.length && logic.returns[0]?.typeAnnotation) {
+            // 如果新导入的logic还有Error类型
+            const logicType = logic.returns[0].typeAnnotation;
+            if (logicType.typeNamespace === 'nasl.ui' && logicType.typeName === 'Error') {
+                findHasError = true;
+            } else if (logicType.typeNamespace === 'nasl.core' && logicType.typeKind === 'union') {
+                // 如果 logic 有 returns 而且，也有typeArguments的长度
+                findHasError = Boolean(logicType.typeArguments?.find((item) => (
+                    item?.typeNamespace === 'nasl.ui' && item?.typeName === 'Error'
+                )));
+            }
+        }
+        return findHasError;
     }
 
     //================================================================================

package/src/concepts/MatchCase__.ts

@@ -58,6 +58,9 @@ export class MatchCase extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'MatchCase';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): MatchCase {
         return super.from(source, parentNode, parentKey) as MatchCase;

package/src/concepts/Match__.ts

@@ -59,6 +59,9 @@ export class Match extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Match';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Match {
         return super.from(source, parentNode, parentKey) as Match;
@@ -352,17 +355,89 @@ export class Match extends LogicItem {
 
     // 设置 expression ，如果 expression 是可枚举类型，加上默认匹配条件
     async setExpressionWitchCase(expression: LogicItem) {
+        const oldExpression = this.expression;
         this.app.emit('collect:start', {
             actionMsg: `修改${this?.name || this?.label || (this?.constructor as any)?.nodeTitle}`,
         });
         this.setExpression(expression);
         // expression切换并且自动生成分支
-        await this.autoGenCases();
+        await this.autoGenCases(oldExpression);
         this.app.emit('collect:end');
     }
 
     // 自动生成分支
-    async autoGenCases() {
+    async autoGenCases(oldExpression: LogicItem) {
+        const expression = this.expression;
+        // 没有新的expression要保留分支不去更新
+        if (!expression) {
+            return;
+        }
+        // 如果没有旧的oldExpression， 但是已有就分支了，就不去更新了
+        if (!oldExpression && this.cases.length) {
+            // 而且case的 patterns 有长度，就说明里面是有值的，就不去更新了，其余就去更新
+            if (this.cases.some((item) => item.patterns.length)) {
+                return;
+            }
+        }
+        // 如果新旧nasl一样，就算类型变了也不重新计算
+        if (JSON.stringify(oldExpression?.toJSON()) === JSON.stringify(expression?.toJSON())) {
+            return;
+        }
+        const oldTypeAnnotation = oldExpression?.__TypeAnnotation;
+        const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
+
+        // 如果nasl变了，但是新旧类型都是union就return
+        if (currTypeAnnotation?.typeKind === 'union' && oldTypeAnnotation?.typeKind === 'union') {
+            return;
+        }
+
+        // 如果不可枚举 变 不可枚举，都会保留分支
+        // 原来不是 布尔类型 也不是枚举类型， 现在 也不是布尔类型 也不是枚举类型
+        // 就满足了
+        if (expression && oldExpression && currTypeAnnotation && oldTypeAnnotation) {
+            const { typeName: oldTypeName, typeNamespace: oldTypeNamespace, typeKind: oldTypeKind } = oldTypeAnnotation;
+            const { typeName, typeNamespace, typeKind } = currTypeAnnotation;
+            // 类型的 name 和 namespace都有值，而且都不是 可枚举
+            if (oldTypeName && oldTypeNamespace && typeName && typeNamespace && oldTypeName !== 'Boolean' && !oldTypeNamespace.endsWith('enums') && oldTypeKind !== 'union' && typeName !== 'Boolean' && !typeNamespace.endsWith('enums') && typeKind !== 'union') {
+                return;
+            } else if (oldTypeName && oldTypeNamespace && oldTypeName !== 'Boolean' && !oldTypeNamespace.endsWith('enums') && oldTypeKind !== 'union' && typeKind === 'anonymousStructure') {
+                /**
+                 * 新旧都是匿名数据结构
+                 * 匿名到 可枚举 动
+                 * 可枚举到匿名 动
+                 * 匿名到 不可枚举 不动
+                 * 不可枚举到匿名 不动
+                 * 匿名到匿名 不动
+                 * 因为不能在match上不能直接 匿名数据结构替换匿名数据结构
+                 * 而且 匿名数据结构不能 直接换别的分支，所以下面的直留 不可枚举到匿名数据结构的情况
+                 *  */
+                // 不可枚举到匿名 不动
+                return;
+            } else if ((typeKind === 'anonymousStructure' && oldTypeKind === typeKind)) {
+                // 匿名到匿名 不动
+                return;
+            }
+            //  else if (currTypeName && typeNamespace && currTypeName !== 'Boolean' && !typeNamespace.endsWith('enums') && oldTypeKind === 'anonymousStructure') {
+            //     // 匿名到 不可枚举 不动
+            //     return;
+            // }
+        }
+
+        // 修改分支
+        await this.changeGenCases();
+    }
+    // jflow缓存模式下的传过来参数
+    async autoGenCasesAST({ oldAst, cacheType }: any) {
+        let obj;
+        try {
+            obj = JSON.parse(oldAst);
+        } catch (err) {
+        }
+        const oldExpression = LogicItem.from(obj);
+        oldExpression.__TypeAnnotation = cacheType;
+        await this.autoGenCases(oldExpression);
+    }
+    async changeGenCases() {
         const expression = this.expression;
         const currTypeAnnotation = await expression?.getCurrentTypeAnnotation();
         let cases: MatchCase[] = [];

package/src/concepts/MemberExpression__.ts

@@ -54,6 +54,9 @@ export class MemberExpression extends LogicItem {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'MemberExpression';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): MemberExpression {
         return super.from(source, parentNode, parentKey) as MemberExpression;

package/src/concepts/Module__.ts

@@ -25,7 +25,6 @@ import View from './View__';
 import Variable from './Variable__';
 import Process from './Process__';
 import FrontendLibrary from './FrontendLibrary__';
-import ViewComponent from './ViewComponent__';
 import Configuration from './Configuration__';
 import App from './App__';
 
@@ -82,6 +81,12 @@ export class Module extends BaseNode {
     @property()
     externalDependencyMap: { maven?: Array<{ groupId: string, artifactId: string, version: string }> } = undefined;
 
+    /**
+     * 外部语言依赖
+     */
+    @property()
+    compilerInfoMap: { java?: Array<{ packageName: string,className:string,naslName: string, type: string,javaTypes:any }> } = undefined;
+
     /**
      * 数据源列表
      */
@@ -157,6 +162,9 @@ export class Module extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Module';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Module {
         return super.from(source, parentNode, parentKey) as Module;
@@ -173,8 +181,9 @@ export class Module extends BaseNode {
         }
         return params;
     }
+    
 
-    getDataSourceExistingNames(excludedList: Array<DataSource> = []) {
+        getDataSourceExistingNames(excludedList: Array<DataSource> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.dataSources as DataSource[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -315,6 +324,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getStructureExistingNames(excludedList: Array<Structure> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -456,6 +466,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getEnumExistingNames(excludedList: Array<Enum> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.enums as Enum[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -597,6 +608,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getLogicExistingNames(excludedList: Array<Logic> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -738,6 +750,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getInterfaceExistingNames(excludedList: Array<Interface> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.interfaces as Interface[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -879,6 +892,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getViewExistingNames(excludedList: Array<View> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.views as View[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1020,6 +1034,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getVarExistingNames(excludedList: Array<Variable> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.frontendVariables as Variable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1161,6 +1176,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getProcessExistingNames(excludedList: Array<Process> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.processes as Process[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1302,6 +1318,7 @@ export class Module extends BaseNode {
         return node;
     }
 
+
     getFrontendLibraryExistingNames(excludedList: Array<FrontendLibrary> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.frontends as FrontendLibrary[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -1443,6 +1460,9 @@ export class Module extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
     * 删除数据源
     * @param name 数据源名称
@@ -1491,6 +1511,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除数据结构
     * @param name 数据结构名称
@@ -1539,6 +1561,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除枚举
     * @param name 枚举名称
@@ -1587,6 +1611,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除逻辑
     * @param name 逻辑名称
@@ -1635,6 +1661,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除接口
     * @param name 接口名称
@@ -1683,6 +1711,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除页面
     * @param name 页面名称
@@ -1731,6 +1761,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除变量
     * @param name 变量名称
@@ -1779,6 +1811,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除流程
     * @param name 流程名称
@@ -1827,6 +1861,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除端包
     * @param name 端包名称
@@ -1875,6 +1911,8 @@ export class Module extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除配置管理
     * @param name 配置管理名称

package/src/concepts/Namespace__.ts

@@ -137,6 +137,9 @@ export class Namespace extends BaseNode {
         super(source);
         super.subConstructor(source);
     }
+    getClassName() {
+        return 'Namespace';
+    }
 
     static from(source: any, parentNode?: any, parentKey?: string): Namespace {
         return super.from(source, parentNode, parentKey) as Namespace;