@lcap/nasl 1.0.0-alpha.7 → 1.0.0

package/src/concepts/Configuration__.ts

@@ -107,7 +107,7 @@ export class Configuration extends BaseNode {
                 name: options,
             }, this, 'groups');
         } else if (options instanceof ConfigGroup) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             configGroup = options;
             Object.assign(configGroup, relationOptions);
         } else {
@@ -195,7 +195,7 @@ export class Configuration extends BaseNode {
 
     addConfigGroup(options?: string | Partial<ConfigGroup> | ConfigGroup) {
         const node = this._addConfigGroup(options as any);
-        const index = this.groups.length;
+        const index = this.groups.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Constant__.ts

@@ -235,6 +235,18 @@ export class Constant extends BaseNode {
         }
         return code;
     }
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        }
+        if (this.defaultValue) {
+            code += ` : ${this.defaultValue}`;
+        }
+        return code;
+    }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Destination__.ts

@@ -1,6 +1,8 @@
 import View from './View__';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
+import { BindAttribute } from '..';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -113,7 +115,7 @@ export class Destination extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -187,7 +189,7 @@ export class Destination extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -247,19 +249,19 @@ export class Destination extends LogicItem {
         }
         return '';
     }
+
     get tsName() {
         if (this.viewName) {
             let tsName = this.viewName;
+            // 匹配所有特殊字符都转为_
+            tsName = tsName.replace(/\W/g, '_');
             if (/^\d/.test(tsName)) {
                 tsName = '$' + tsName;
             }
-            // 匹配所有特殊字符都转为_
-            tsName = tsName.replace(/\W/g, '_');
             return tsName;
         }
         return '';
     }
-
     genViewArr() {
         const viewArr = this.viewNamespace?.split('.').splice(1).filter((item, index) => index % 2 === 1) || [];
         if (this.viewName) {
@@ -272,10 +274,10 @@ export class Destination extends LogicItem {
         let url = '';
         const viewArr = this.genViewArr();
         if (Array.isArray(viewArr) && viewArr.length) {
-            url += ':href="`';
+            url += ':destination="`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toVue()}` + '}');
+                const args = this.arguments?.map((arg) => `${arg?.keyword}=` + '${' + `${arg?.toVue(options)}` + '}');
                 url += `?${args.join('&')}`;
             }
             url += '`"';
@@ -290,7 +292,7 @@ export class Destination extends LogicItem {
             url += '`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toUI()}` + '}');
+                const args = this.arguments?.map((arg) => `${arg?.keyword}=` + '${' + `${arg?.toUI()}` + '}');
                 url += `?${args.join('&')}`;
             }
             url += '`';
@@ -335,6 +337,38 @@ export class Destination extends LogicItem {
         });
     }
 
+    /**
+     * 设置view的argument
+     */
+    setViewArgument(view: View) {
+        const params = view.params;
+        const argument = this.arguments;
+        if (params.length > argument.length) {
+            params.forEach((item) => {
+                const arg = argument.find((arg) => arg.keyword === item.name);
+                if (!arg) {
+                    this.addArgument({
+                        keyword: item.name,
+                    });
+                }
+            });
+        } else {
+            argument.forEach((item) => {
+                const param = params.find((param) => param.name === item.keyword);
+                if (!param) {
+                    item.delete();
+                }
+            });
+        }
+    }
+    /**
+     * 设置Arguments的KeyWord
+     */
+    setArgumentsKeyWord(options: {findArgument: Argument, newKeyword: string}) {
+        const { findArgument, newKeyword } = options;
+        findArgument.setKeyword(newKeyword);
+    }
+
     get viewPath() {
         if (!this.viewNamespace) {
             return '';
@@ -350,23 +384,61 @@ export class Destination extends LogicItem {
         }
         return `${viewNameAttr.join('/')}/`;
     }
-
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = `${utils.firstLowerCase(this.concept)}: () => {\n`;
-        code += indent(state.tabSize + 2);
+    toEmbeddedTSInProcess(state: TranslatorState, prependCode: string): string {
+        // const tab = indent(state.tabSize);
         if (this.tsCalleeNamespace && this.tsName) {
-            code += `${this.tsCalleeNamespace}.${this.tsName}.$destination(`;
-            if (Array.isArray(this.arguments)) {
-                this.arguments.forEach((argument: Argument) => {
-                    code += argument.toEmbeddedTS(shiftState(state, code)) + ', ';
-                });
+            let code = `destination: function() {\n`;
+            code += prependCode;
+            code += '\n';
+            if (this.tsCalleeNamespace && this.viewName) {
+                code += `${this.tsCalleeNamespace}.${this.viewName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
             }
-            code += `);\n`;
+            code += indent(state.tabSize + 1) + `}\n`;
+            return code;
+        } else {
+            return '__IDENTIFIER__';
         }
+    }
 
-        code += indent(state.tabSize + 1) + `},\n`;
-        return code;
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+
+        if (this.parentNode instanceof BindAttribute) {
+            code = `${utils.firstLowerCase(this.concept)}: () => {\n`;
+            code += indent(state.tabSize + 2);
+            if (this.tsCalleeNamespace && this.tsName) {
+                code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
+            }
+            code += indent(state.tabSize + 1) + `},\n`;
+            return code;
+        } else {
+            if (this.tsCalleeNamespace && this.tsName) {
+                code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
+            } else {
+                code += '__IDENTIFIER__';
+            }
+            return code;
+        }
     }
     @withSourceMap()
     toEmbeddedTSNormalFunction(state?: TranslatorState): string {

package/src/concepts/End__.ts

@@ -56,7 +56,14 @@ export class End extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
     toJS(state?: TranslatorState): string {
-        return '';
+        let code = '';
+        const ret = this.logic.returns[0];
+        if (ret) {
+            code += 'return ' + ret.name + ';';
+        } else {
+            code += 'return;';
+        }
+        return code;
     }
 
     toEmbeddedTS(state?: TranslatorState): string {

package/src/concepts/EntityProperty__.ts

@@ -1,5 +1,6 @@
 import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 type changeType = 'up' | 'down';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -331,6 +332,67 @@ export class EntityProperty extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
+
+    /**
+     * 是否展开
+     */
+    @property()
+    isLeaf: boolean = true;
+
+    getSelectRef() {
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
+    /**
+     * 设置是否必填
+     */
+    setSequence(sequence: string) {
+        const object = {
+            sequence,
+        };
+        this.update({
+            ...object,
+        });
+    }
     /**
      * 设置是否必填
      */
@@ -367,8 +429,8 @@ export class EntityProperty extends BaseNode {
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
         if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
-        } // else
+            code += '= ' + this.typeAnnotation.getDefaultValue(this.defaultValue);
+        }
         return code;
     }
     /**
@@ -388,7 +450,7 @@ export class EntityProperty extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -428,7 +490,8 @@ export class EntityProperty extends BaseNode {
      */
     moveUp() {
         const properties = [...(this.parentNode as Entity).properties];
-        const oldIndex = properties.indexOf(this);
+        const propertiesNameList = properties.map((item) => item.name);
+        const oldIndex = propertiesNameList.indexOf(this.name);
         this.changeSort(properties, oldIndex, 'up');
         this.parentNode.update({
             properties,
@@ -439,7 +502,8 @@ export class EntityProperty extends BaseNode {
      */
     moveDown() {
         const properties = [...(this.parentNode as Entity).properties];
-        const oldIndex = properties.indexOf(this);
+        const propertiesNameList = properties.map((item) => item.name);
+        const oldIndex = propertiesNameList.indexOf(this.name);
         this.changeSort(properties, oldIndex, 'down');
         this.parentNode.update({
             properties,

package/src/concepts/Entity__.ts

@@ -110,15 +110,15 @@ export class Entity extends BaseNode {
     /**
      * 设置实体名称
      */
-    setName(name: string) {
-        const object = {
-            name,
-        };
-        this.update({
-            ...object,
-            field: 'name',
-        });
-    }
+    // setName(name: string) {
+    //     const object = {
+    //         name,
+    //     };
+    //     this.update({
+    //         ...object,
+    //         field: 'name',
+    //     });
+    // }
 
     /**
      * 设置实体描述
@@ -132,7 +132,7 @@ export class Entity extends BaseNode {
         });
     }
 
-        getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
+    getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
         const excludedSet = new Set(excludedList);
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -176,7 +176,7 @@ export class Entity extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof EntityProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             property = options;
             Object.assign(property, relationOptions);
         } else {
@@ -264,7 +264,7 @@ export class Entity extends BaseNode {
 
     addProperty(options?: string | Partial<EntityProperty> | EntityProperty) {
         const node = this._addProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -273,7 +273,6 @@ export class Entity extends BaseNode {
         return node;
     }
 
-
     getEntityIndexExistingNames(excludedList: Array<EntityIndex> = []) {
         const excludedSet = new Set(excludedList);
         return (this.indexes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -318,7 +317,7 @@ export class Entity extends BaseNode {
                 name: options,
             }, this, 'indexes');
         } else if (options instanceof EntityIndex) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             entityIndex = options;
             Object.assign(entityIndex, relationOptions);
         } else {
@@ -406,7 +405,7 @@ export class Entity extends BaseNode {
 
     addEntityIndex(options?: string | Partial<EntityIndex> | EntityIndex) {
         const node = this._addEntityIndex(options as any);
-        const index = this.indexes.length;
+        const index = this.indexes.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -415,9 +414,6 @@ export class Entity extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
     * 删除实体字段
     * @param name 实体字段名称
@@ -466,8 +462,6 @@ export class Entity extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除实体索引
     * @param name 实体索引名称
@@ -520,6 +514,22 @@ export class Entity extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    /**
+     * 设置实体表名并修改表名
+     */
+    setName(name: string) {
+        const object: { name: string; tableName?: string } = {
+            name,
+        };
+        if (this.name === this.tableName && (this.origin === 'ide' || this.origin === 'sql')) {
+            object.tableName = name;
+        }
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
     /**
      * 设置实体表名
      */
@@ -681,10 +691,13 @@ export class Entity extends BaseNode {
     }
 
     get ns() {
-        const ns = entity2LogicNamespace(this);
+        const ns: Namespace = entity2LogicNamespace(this);
         ns.path = this.getNamespace() + '.' + ns.name;
         return ns;
     }
+    // @excludedInJSON()
+    // nslogic: Namespace;
+
     get logics() {
         const ns = this.ns;
         return ns.logics;
@@ -695,7 +708,11 @@ export class Entity extends BaseNode {
         code += '    @nasl.annotation.Entity()\n';
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {
@@ -711,7 +728,7 @@ export class Entity extends BaseNode {
     //================================================================================
 }
 
-classMap['Entity'] = Entity;
+classMap.Entity = Entity;
 export default Entity;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Enum__.ts

@@ -148,7 +148,7 @@ export class Enum extends BaseNode {
         const relationOptions = { parentNode: this, parentKey: 'enumItems' };
         let enumItem: EnumItem;
         if (options instanceof EnumItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             enumItem = options;
             Object.assign(enumItem, relationOptions);
         } else {
@@ -222,7 +222,7 @@ export class Enum extends BaseNode {
 
     addEnumItem(options?: Partial<EnumItem> | EnumItem) {
         const node = this._addEnumItem(options as any);
-        const index = this.enumItems.length;
+        const index = this.enumItems.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -280,24 +280,25 @@ export class Enum extends BaseNode {
     @property()
     children: any;
 
+    /**
+     * 是否展开
+     */
+    @property()
+    isLeaf: boolean = true;
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `export class ${this.name} {\n`;
+        let code = `export class ${this.name} extends nasl.core.Enums {\n`;
         // 增加一个单独的标签
-        code += indent(state.tabSize + 1) + `static __name: '${this.getNamespace()}.${this.name}';\n`;
-        let enumItemStr = '';
+        code += indent(state.tabSize + 1) + `__name: '${this.getNamespace()}.${this.name}';\n`;
         this.enumItems.forEach((property) => {
             code += indent(state.tabSize + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             code += ';\n';
-
-            enumItemStr += `${property.value}: ${this.name},\n`;
         });
         code += `
         static toList() {
-            let value: nasl.collection.List<{
-                ${enumItemStr}
-            }>
+            let value: nasl.collection.List<nasl.ui.EnumItem>
             return value;
         }
         static toString() {
@@ -330,7 +331,11 @@ export class Enum extends BaseNode {
         let code = `namespace ${this.getNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {

package/src/concepts/Event__.ts

@@ -150,7 +150,7 @@ export class Event extends BaseNode {
                 name: options,
             }, this, 'params');
         } else if (options instanceof Param) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         } else {
@@ -238,7 +238,7 @@ export class Event extends BaseNode {
 
     addParam(options?: string | Partial<Param> | Param) {
         const node = this._addParam(options as any);
-        const index = this.params.length;
+        const index = this.params.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/ForEachStatement__.ts

@@ -1,5 +1,6 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import TypeAnnotation from './TypeAnnotation__';
+import Identifier from './Identifier__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -176,7 +177,7 @@ export class ForEachStatement extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'body' };
         let logicItem: LogicItem;
         if (options instanceof LogicItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logicItem = options;
             Object.assign(logicItem, relationOptions);
         } else {
@@ -250,7 +251,7 @@ export class ForEachStatement extends LogicItem {
 
     addItem(options?: Partial<LogicItem> | LogicItem) {
         const node = this._addItem(options as any);
-        const index = this.body.length;
+        const index = this.body.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -463,8 +464,8 @@ export class ForEachStatement extends LogicItem {
         const itemNames = [];
         const idxNames = [];
         let n = this.parentNode;
-        while(n && n.concept !== 'Logic') {
-            if(n instanceof ForEachStatement){
+        while (n && n.concept !== 'Logic') {
+            if (n instanceof ForEachStatement) {
                 itemNames.push(n.item.name);
                 idxNames.push(n.index.name);
             }
@@ -472,15 +473,14 @@ export class ForEachStatement extends LogicItem {
         }
         const uniqueItemName = utils.unique('item', itemNames);
         const uniqueIdxName = utils.unique('index', idxNames);
-        if(this.item.name !== uniqueItemName) {
+        if (this.item.name !== uniqueItemName) {
             this.item.setName(uniqueItemName);
         }
-        if(this.index.name !== uniqueIdxName) {
+        if (this.index.name !== uniqueIdxName) {
             this.index.setName(uniqueIdxName);
         }
     }
 
-
     public static getDefaultOptions() {
         return {
             label: 'ForEach 循环分支',
@@ -509,18 +509,13 @@ export class ForEachStatement extends LogicItem {
 
     toJS(state?: TranslatorState): string {
         let code = '';
-        code += this.each ? this.each.toJS(shiftState(state, code, {
+        const list = this.each ? this.each.toJS(shiftState(state, code, {
             tabSize: 0,
         })) : '';
-        code += '.slice(';
-        code += this.start && this.start.toJS() ? this.start.toJS() : '';
-        code += ', ';
-        code += this.end && this.end.toJS() ? this.end.toJS() : '';
-        code += ').forEach((';
-        code += this.item.name ? `${this.item.name}` : '';
-        code += ', ';
-        code += this.index.name ? `${this.index.name}` : '';
-        code += ') => {\n';
+        code += `if(Array.isArray(${list})) {\n`;
+        code += `for (let ${this.index.name} = ${this.start && this.start.toJS() ? this.start.toJS() : ''}; `;
+        code += `${this.index.name} < (${this.end && this.end.toJS() ? this.end.toJS() : ''}); ${this.index.name}++) {\n`;
+        code += `const ${this.item.name} = ${list}[${this.index.name}];\n`;
         if (Array.isArray(this.body)) {
             this.body.forEach((logicItem) => {
                 code
@@ -529,8 +524,8 @@ export class ForEachStatement extends LogicItem {
                     })) + '\n';
             });
         }
-        code += '})\n';
-
+        code += '}\n';
+        code += '}\n';
         return code;
     }