diff --git a/common/util.js b/common/util.js
index 580821e2..ecd25390 100644
--- a/common/util.js
+++ b/common/util.js
@@ -5,199 +5,178 @@ const rendy = require('rendy');
 const jonny = require('jonny');
 const itype = require('itype/legacy');
 
-module.exports = new UtilProto(exec);
+const Scope = global || window;
 
-function UtilProto(exec) {
-    const Util = this;
-    const Scope = global || window;
+module.exports.getStrBigFirst = getStrBigFirst;
+module.exports.kebabToCamelCase = kebabToCamelCase;
+
+/**
+ * copy objFrom properties to target
+ *
+ * @target
+ * @objFrom
+ */
+const extend = (target, objFrom) => {
+    const isFunc  = itype.function(objFrom);
+    const isArray = Array.isArray(objFrom);
+    const isObj = itype.object(target);
+    let ret = isObj ? target : {};
     
-    this.getStrBigFirst = getStrBigFirst;
-    this.kebabToCamelCase = kebabToCamelCase;
-    
-    /**
-     * copy objFrom properties to target
-     *
-     * @target
-     * @objFrom
-     */
-    this.extend = (target, objFrom) => {
-        let obj;
-        let keys;
-        let proto;
-        
-        const isFunc  = itype.function(objFrom);
-        const isArray = Array.isArray(objFrom);
-        const isObj = itype.object(target);
-        let ret = isObj ? target : {};
-        
-        if (isArray)
-            objFrom.forEach((item) => {
-               ret = Util.extend(target, item);
-            });
-        
-        else if (objFrom) {
-            obj     = isFunc ? new objFrom() : objFrom;
-            keys    = Object.keys(obj);
-            
-            if (!keys.length) {
-                proto = Object.getPrototypeOf(objFrom);
-                keys  = Object.keys(proto);
-            }
-            
-            keys.forEach(function(name) {
-                ret[name] = obj[name];
-            });
-        }
-        
-        return ret;
-    };
-    
-    /**
-     * extend proto
-     *
-     * @obj
-     */
-    this.extendProto           = function(obj) {
-        var ret, F      = function() {};
-        F.prototype     = Util.extend({}, obj);
-        ret             = new F();
-        
-        return ret;
-    };
-    
-    this.json               = jonny;
-    
-    this.escapeRegExp = function(str) {
-        var isStr = typeof str === 'string';
-        
-        if (isStr)
-            str = str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-        
-        return str;
-    };
-    
-    /**
-     * get regexp from wild card
-     */
-    this.getRegExp              = function(wildcard) {
-        var regExp;
-        
-        if (!wildcard)
-            wildcard = '*';
-        
-        wildcard    = '^' + wildcard /* search from start of line */
-            .replace('.', '\\.')
-            .replace('*', '.*')
-            .replace('?', '.?');
-        
-        wildcard    += '$'; /* search to end of line */
-        
-        regExp      = new RegExp(wildcard);
-        
-        return regExp;
-    };
-    
-    this.exec = exec;
-    
-    /**
-     * function gets file extension
-     *
-     * @param pFileName
-     * @return Ext
-     */
-    this.getExt = function(name) {
-        var ret = '';
-        var dot;
-        var isStr = typeof name === 'string'
-        
-        if (isStr) {
-            dot = name.lastIndexOf('.');
-            
-            if (~dot)
-                ret = name.substr(dot);
-        }
-        
-        return ret;
-    };
-    
-    /**
-     * find object by name in arrray
-     *
-     * @param array
-     * @param name
-     */
-    this.findObjByNameInArr         = function(array, name) {
-        var ret;
-        
-         if (!Array.isArray(array))
-            throw Error('array should be array!');
-            
-        if (typeof name !== 'string')
-            throw Error('name should be string!');
-        
-        array.some(function(item) {
-            var is = item.name === name,
-                isArray = Array.isArray(item);
-            
-            if (is)
-                ret = item;
-            else if (isArray)
-                item.some(function(item) {
-                    is = item.name === name;
-                    
-                    if (is)
-                        ret = item.data;
-                    
-                    return is;
-                });
-            
-            return is;
+    if (isArray)
+        objFrom.forEach((item) => {
+           ret = Util.extend(target, item);
         });
-        
-        return ret;
-    };
     
-    /**
-     * start timer
-     * @param name
-     */
-    this.time = function(name) {
-        const console = Scope.console;
+    else if (objFrom) {
+        const obj = isFunc ? new objFrom() : objFrom;
+        let keys = Object.keys(obj);
         
-        Util.exec.ifExist(console, 'time', [name]);
+        if (!keys.length) {
+            const proto = Object.getPrototypeOf(objFrom);
+            keys = Object.keys(proto);
+        }
         
-        return this;
-    };
-    
-    /**
-     * stop timer
-     * @param name
-     */
-    this.timeEnd                   = function(name) {
-        var console    = Scope.console;
-        
-        Util.exec.ifExist(console, 'timeEnd', [name]);
-        
-        return this;
-    };
-    
-    function getStrBigFirst(str) {
-        if (!str)
-            throw Error('str could not be empty!');
-        
-        const first = str[0].toUpperCase();
-        return first + str.slice(1);
+        keys.forEach((name) => {
+            ret[name] = obj[name];
+        });
     }
     
-    function kebabToCamelCase(str) {
-        if (!str)
-            throw Error('str could not be empty!');
+    return ret;
+};
+
+module.exports.extend = extend;
+
+/**
+ * extend proto
+ *
+ * @obj
+ */
+module.exports.extendProto = (obj) => {
+    const F = () => {};
+    F.prototype = extend({}, obj);
+    return new F();
+};
+
+module.exports.json = jonny;
+
+module.exports.escapeRegExp = (str) => {
+    const isStr = typeof str === 'string';
+    
+    if (isStr)
+        str = str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    
+    return str;
+};
+
+/**
+ * get regexp from wild card
+ */
+module.exports.getRegExp = (wildcard = '*') => {
+    const escaped = '^' + wildcard // search from start of line
+        .replace('.', '\\.')
+        .replace('*', '.*')
+        .replace('?', '.?') + '$'; // search to end of line
+    
+    const regExp = new RegExp(escaped);
+    
+    return regExp;
+};
+
+module.exports.exec = exec;
+
+/**
+ * function gets file extension
+ *
+ * @param name
+ * @return ext
+ */
+module.exports.getExt = (name) => {
+    const isStr = typeof name === 'string'
+    
+    if (!isStr)
+        return '';
+    
+    const dot = name.lastIndexOf('.');
+    
+    if (~dot)
+        return name.substr(dot);
+    
+    return '';
+};
+
+/**
+ * find object by name in arrray
+ *
+ * @param array
+ * @param name
+ */
+module.exports.findObjByNameInArr = (array, name) => {
+    let ret;
+    
+     if (!Array.isArray(array))
+        throw Error('array should be array!');
         
-        return str
-            .split('-')
-            .map(getStrBigFirst)
-            .join('')
-            .replace(/.js$/, '');
-    }
+    if (typeof name !== 'string')
+        throw Error('name should be string!');
+    
+    array.some((item) => {
+        let is = item.name === name;
+        const isArray = Array.isArray(item);
+        
+        if (is)
+            ret = item;
+        else if (isArray)
+            item.some((item) => {
+                is = item.name === name;
+                
+                if (is)
+                    ret = item.data;
+                
+                return is;
+            });
+        
+        return is;
+    });
+    
+    return ret;
+};
+
+/**
+ * start timer
+ * @param name
+ */
+module.exports.time = (name) => {
+    const console = Scope.console;
+    
+    exec.ifExist(console, 'time', [name]);
+};
+
+/**
+ * stop timer
+ * @param name
+ */
+module.exports.timeEnd = (name) => {
+    const console = Scope.console;
+    
+    exec.ifExist(console, 'timeEnd', [name]);
+};
+
+function getStrBigFirst(str) {
+    if (!str)
+        throw Error('str could not be empty!');
+    
+    const first = str[0].toUpperCase();
+    return first + str.slice(1);
+}
+
+function kebabToCamelCase(str) {
+    if (!str)
+        throw Error('str could not be empty!');
+    
+    return str
+        .split('-')
+        .map(getStrBigFirst)
+        .join('')
+        .replace(/.js$/, '');
 }