@acorex/core 6.5.29 → 6.5.30

package/fesm2015/acorex-core.mjs

@@ -10,1349 +10,1349 @@ import merge from 'lodash-es/merge';
 import { __awaiter } from 'tslib';
 import * as i1$1 from '@angular/router';
 
-class AXColorUtil {
-    static hex2Rgb(hexColor) {
-        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexColor);
-        return result ? {
-            r: parseInt(result[1], 16),
-            g: parseInt(result[2], 16),
-            b: parseInt(result[3], 16)
-        } : null;
-    }
-    static rgb2Hex(r, g, b, a = 255) {
-        let alpha;
-        let hex = (r | 1 << 8).toString(16).slice(1) +
-            (g | 1 << 8).toString(16).slice(1) +
-            (b | 1 << 8).toString(16).slice(1);
-        if (a !== 255) {
-            alpha = a;
-        }
-        else {
-            alpha = 1;
-        }
-        alpha = Math.round(alpha * 100) / 100;
-        alpha = Math.round(alpha * 255);
-        const hexAlpha = (alpha + 0x10000).toString(16).substr(-2).toUpperCase();
-        return '#' + hex + (alpha == 255 ? '' : hexAlpha);
-    }
-    ;
-    static illuminance(hexColor) {
-        const rgbColor = AXColorUtil.hex2Rgb(hexColor);
-        if (!rgbColor) {
-            return -1;
-        }
-        const r = rgbColor.r;
-        const g = rgbColor.g;
-        const b = rgbColor.b;
-        const a = [r, g, b].map(v => {
-            v /= 255;
-            return (v <= 0.03928) ?
-                v / 12.92 :
-                Math.pow(((v + 0.055) / 1.055), 2.4);
-        });
-        return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
-    }
-    static contrastToWhite(hexColor) {
-        const whiteIlluminance = 1;
-        const illuminance = AXColorUtil.illuminance(hexColor);
-        return whiteIlluminance / illuminance;
-    }
+class AXColorUtil {
+    static hex2Rgb(hexColor) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexColor);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : null;
+    }
+    static rgb2Hex(r, g, b, a = 255) {
+        let alpha;
+        let hex = (r | 1 << 8).toString(16).slice(1) +
+            (g | 1 << 8).toString(16).slice(1) +
+            (b | 1 << 8).toString(16).slice(1);
+        if (a !== 255) {
+            alpha = a;
+        }
+        else {
+            alpha = 1;
+        }
+        alpha = Math.round(alpha * 100) / 100;
+        alpha = Math.round(alpha * 255);
+        const hexAlpha = (alpha + 0x10000).toString(16).substr(-2).toUpperCase();
+        return '#' + hex + (alpha == 255 ? '' : hexAlpha);
+    }
+    ;
+    static illuminance(hexColor) {
+        const rgbColor = AXColorUtil.hex2Rgb(hexColor);
+        if (!rgbColor) {
+            return -1;
+        }
+        const r = rgbColor.r;
+        const g = rgbColor.g;
+        const b = rgbColor.b;
+        const a = [r, g, b].map(v => {
+            v /= 255;
+            return (v <= 0.03928) ?
+                v / 12.92 :
+                Math.pow(((v + 0.055) / 1.055), 2.4);
+        });
+        return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+    }
+    static contrastToWhite(hexColor) {
+        const whiteIlluminance = 1;
+        const illuminance = AXColorUtil.illuminance(hexColor);
+        return whiteIlluminance / illuminance;
+    }
 }
 
-// @dynamic
-class AXObjectUtil {
-    static deepJSONClone(obj) {
-        return obj ? JSON.parse(JSON.stringify(obj)) : null;
-    }
-    static deepCopy(obj) {
-        let copy;
-        // Handle the 3 simple types, and null or undefined
-        if (null == obj || 'object' !== typeof obj) {
-            return obj;
-        }
-        // Handle Date
-        if (obj instanceof Date) {
-            copy = new Date();
-            copy.setTime(obj.getTime());
-            return copy;
-        }
-        // Handle Array
-        if (obj instanceof Array) {
-            copy = [];
-            for (let i = 0, len = obj.length; i < len; i++) {
-                copy[i] = AXObjectUtil.deepCopy(obj[i]);
-            }
-            return copy;
-        }
-        // Handle Object
-        if (obj instanceof Object) {
-            copy = {};
-            for (const attr in obj) {
-                if (obj.hasOwnProperty(attr)) {
-                    copy[attr] = AXObjectUtil.deepCopy(obj[attr]);
-                }
-            }
-            return copy;
-        }
-        throw new Error('Unable to copy obj! Its type isn\'t supported.');
-    }
-}
-function AXFetchProp(obj, prop) {
-    if (typeof obj === 'undefined') {
-        return false;
-    }
-    const index = prop.indexOf('.');
-    if (index > -1) {
-        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
-    }
-    return obj[prop];
-}
-function getPropByPath(obj, path, defaultVal) {
-    path = path
-        .replace(/\[/g, '.')
-        .replace(/]/g, '')
-        .split('.');
-    path.forEach((level) => {
-        if (obj) {
-            obj = obj[level];
-        }
-    });
-    if (obj === undefined) {
-        return defaultVal;
-    }
-    return obj;
-}
-function setPropByPath(obj, path, value) {
-    if (Object(obj) !== obj) {
-        return obj;
-    } // When obj is not an object
-    // If not yet an array, get the keys from the string-path
-    if (!Array.isArray(path)) {
-        path = path.toString().match(/[^.[\]]+/g) || [];
-    }
-    path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
-     Object(a[c]) === a[c] // Does the key exist and is its value an object?
-        // Yes: then follow that path
-        ? a[c]
-        // No: create the key. Is the next key a potential array-index?
-        : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
-            ? [] // Yes: assign a new array object
-            : {}, // No: assign a new plain object
-    obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
-    return obj[path[0]]; // Return the top-level object to allow chaining
+// @dynamic
+class AXObjectUtil {
+    static deepJSONClone(obj) {
+        return obj ? JSON.parse(JSON.stringify(obj)) : null;
+    }
+    static deepCopy(obj) {
+        let copy;
+        // Handle the 3 simple types, and null or undefined
+        if (null == obj || 'object' !== typeof obj) {
+            return obj;
+        }
+        // Handle Date
+        if (obj instanceof Date) {
+            copy = new Date();
+            copy.setTime(obj.getTime());
+            return copy;
+        }
+        // Handle Array
+        if (obj instanceof Array) {
+            copy = [];
+            for (let i = 0, len = obj.length; i < len; i++) {
+                copy[i] = AXObjectUtil.deepCopy(obj[i]);
+            }
+            return copy;
+        }
+        // Handle Object
+        if (obj instanceof Object) {
+            copy = {};
+            for (const attr in obj) {
+                if (obj.hasOwnProperty(attr)) {
+                    copy[attr] = AXObjectUtil.deepCopy(obj[attr]);
+                }
+            }
+            return copy;
+        }
+        throw new Error('Unable to copy obj! Its type isn\'t supported.');
+    }
+}
+function AXFetchProp(obj, prop) {
+    if (typeof obj === 'undefined') {
+        return false;
+    }
+    const index = prop.indexOf('.');
+    if (index > -1) {
+        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+    }
+    return obj[prop];
+}
+function getPropByPath(obj, path, defaultVal) {
+    path = path
+        .replace(/\[/g, '.')
+        .replace(/]/g, '')
+        .split('.');
+    path.forEach((level) => {
+        if (obj) {
+            obj = obj[level];
+        }
+    });
+    if (obj === undefined) {
+        return defaultVal;
+    }
+    return obj;
+}
+function setPropByPath(obj, path, value) {
+    if (Object(obj) !== obj) {
+        return obj;
+    } // When obj is not an object
+    // If not yet an array, get the keys from the string-path
+    if (!Array.isArray(path)) {
+        path = path.toString().match(/[^.[\]]+/g) || [];
+    }
+    path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
+     Object(a[c]) === a[c] // Does the key exist and is its value an object?
+        // Yes: then follow that path
+        ? a[c]
+        // No: create the key. Is the next key a potential array-index?
+        : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
+            ? [] // Yes: assign a new array object
+            : {}, // No: assign a new plain object
+    obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
+    return obj[path[0]]; // Return the top-level object to allow chaining
 }
 
-// @dynamic
-class AXConfig {
-    static get onChange() {
-        return AXConfig.dataChangeSubject.asObservable();
-    }
-    static set(arg1, arg2) {
-        if (arg1 && typeof arg1 == 'string') {
-            setPropByPath(AXConfig.dataModel, arg1, arg2);
-            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
-            return;
-        }
-        if (arg1 && typeof arg1 == 'object') {
-            Object.assign(AXConfig.dataModel, arg1);
-            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
-            return;
-        }
-        if (!arg1 && !arg2) {
-            return AXConfig.dataChangeSubject.asObservable();
-        }
-    }
-    static get(path) {
-        return getPropByPath(AXConfig.dataModel, path);
-    }
-}
-AXConfig.dataModel = {};
+// @dynamic
+class AXConfig {
+    static get onChange() {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+    static set(arg1, arg2) {
+        if (arg1 && typeof arg1 == 'string') {
+            setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (arg1 && typeof arg1 == 'object') {
+            Object.assign(AXConfig.dataModel, arg1);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (!arg1 && !arg2) {
+            return AXConfig.dataChangeSubject.asObservable();
+        }
+    }
+    static get(path) {
+        return getPropByPath(AXConfig.dataModel, path);
+    }
+}
+AXConfig.dataModel = {};
 AXConfig.dataChangeSubject = new Subject();
 
-class AXDateTime {
-    // private get _moment(): moment_.Moment {
-    //     const m = moment(this.date);
-    //     if (this.type === 'jalali') {
-    //         m.locale('fa');
-    //     }
-    //     return m;
-    // }
-    constructor(value = new Date(), type = AXConfig.get('dateTime.type') || 'gregorian') {
-        this.type = type;
-        if (value instanceof Date) {
-            this._date = value;
-        }
-        else {
-            this._date = new Date(value);
-        }
-        this._moment = moment(this.date);
-        if (this.type === 'jalali') {
-            this._moment.locale('fa');
-        }
-    }
-    static convert(value, type = AXConfig.get('dateTime.type') || 'gregorian') {
-        let date;
-        if (typeof value === 'string' || value instanceof String) {
-            date = new AXDateTime(value, type);
-        }
-        else if (value instanceof Date) {
-            date = new AXDateTime(value, type);
-        }
-        else if (value instanceof AXDateTime) {
-            date = value;
-        }
-        return date;
-    }
-    get date() {
-        return this._date;
-    }
-    resolveUnit(unit) {
-        return this.type === 'jalali' ? 'j' + unit : unit;
-    }
-    clone() {
-        return new AXDateTime(this.date, this.type);
-    }
-    get dayInMonth() {
-        return this._moment.date();
-    }
-    get dayOfYear() {
-        return this._moment.dayOfYear();
-    }
-    get dayInWeek() {
-        return this._moment.day();
-    }
-    get hour() {
-        return this._moment.hour();
-    }
-    get minute() {
-        return this._moment.minute();
-    }
-    get second() {
-        return this._moment.second();
-    }
-    get year() {
-        return this._moment.year();
-    }
-    get monthOfYear() {
-        return this._moment.month();
-    }
-    get month() {
-        return new AXCalendarMonth(this);
-    }
-    get firstDayOfWeek() {
-        const a = moment(this.date);
-        if (this.type === 'jalali') {
-            this._moment.locale('fa');
-        }
-        return new AXDateTime(a.startOf('w').toDate(), this.type);
-    }
-    get endDayOfWeek() {
-        const a = moment(this.date);
-        if (this.type === 'jalali') {
-            this._moment.locale('fa');
-        }
-        return new AXDateTime(moment(this.date).endOf('w').toDate(), this.type);
-    }
-    convertStringToJalali(date, format) {
-        return moment(date).locale('fa').format('YYYY/M/D');
-    }
-    convertStringToGregorian(date, format) {
-        return new Date(moment.from(date, 'fa', 'YYYY/MM/DD').format('YYYY/MM/DD'));
-    }
-    add(unit = 'day', amount) {
-        return new AXDateTime(moment(this.date).add(amount, this.resolveUnit(unit)).toDate(), this.type);
-    }
-    addDay(amount) {
-        return new AXDateTime(moment(this.date).add(amount, 'd').toDate(), this.type);
-    }
-    addMonth(amount) {
-        return new AXDateTime(moment(this.date).add(amount, 'months').toDate(), this.type);
-    }
-    addHour(amount) {
-        return new AXDateTime(moment(this.date).add(amount, 'hours').toDate(), this.type);
-    }
-    set(unit = 'day', value) {
-        return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
-    }
-    duration(end, unit = 'days') {
-        const duration = moment.duration(this._moment.diff(end._moment));
-        return Math.round(duration.as(unit));
-    }
-    startOf(unit = 'day') {
-        return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
-    }
-    endOf(unit = 'day') {
-        return new AXDateTime(moment(this.date).endOf(this.resolveUnit(unit)).toDate(), this.type);
-    }
-    format(format = AXConfig.get('dateTime.shortDateFormat') || (this.type === 'gregorian' ? 'DD-MM-YYYY' : 'YYYY-MM-DD')) {
-        if (format === 'P') {
-            return this._moment.fromNow();
-        }
-        return this._moment.format(format);
-    }
-    toString() {
-        return this.format();
-    }
-    equal(value, unit = 'day') {
-        if (!value) {
-            return false;
-        }
-        return this._moment.isSame(moment(value.date), this.resolveUnit(unit));
-    }
-    convertToJalaliDate(value) {
-        const options = {
-            numberingSystem: 'latn',
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit'
-        };
-        const jDate = new Date(value).toLocaleDateString('fa-IR', options);
-        const item = {};
-        item.year = jDate.slice(0, 4);
-        item.month = jDate.slice(5, 7);
-        item.day = jDate.slice(8, 10);
-        item.hour = jDate.slice(13, 15);
-        item.minutes = jDate.slice(16, 18);
-        item.seconds = jDate.slice(19, 21);
-        return item;
-    }
-    toJalaliString(value) {
-        const date = this.convertToJalaliDate(value);
-        let str = '';
-        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
-        return str;
-    }
-    convertToGregorianDate(value) {
-        // TODO: check this fucking type
-        const options = {
-            numberingSystem: 'latn',
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit'
-        };
-        const date = new Date(value).toLocaleString('en-us', options);
-        const item = {};
-        item.year = date.slice(6, 10);
-        item.month = date.slice(0, 2);
-        item.day = date.slice(3, 5);
-        item.hour = date.slice(12, 14);
-        item.minutes = date.slice(15, 17);
-        item.seconds = date.slice(18, 20);
-        return item;
-    }
-    toGregorianString(value) {
-        const date = this.convertToGregorianDate(value);
-        let str = '';
-        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
-        return str;
-    }
-    compaireNew(value, unit = 'YMD', type = 'jalali') {
-        const range = [0, 0];
-        let str1;
-        let str2;
-        if (type === 'jalali') {
-            str1 = this.toJalaliString(this.date);
-            str2 = this.toJalaliString(value.date ? value.date : value);
-        }
-        else {
-            str1 = this.toGregorianString(this.date);
-            str2 = this.toGregorianString(value.date ? value.date : value);
-        }
-        switch (unit) {
-            case 'YMDhms':
-                range[0] = 0;
-                range[1] = 19;
-                break;
-            case 'YMDhm':
-                range[0] = 0;
-                range[1] = 16;
-                break;
-            case 'YMDh':
-                range[0] = 0;
-                range[1] = 13;
-                break;
-            case 'YMD':
-                range[0] = 0;
-                range[1] = 10;
-                break;
-            case 'YM':
-                range[0] = 0;
-                range[1] = 7;
-                break;
-            case 'h':
-                range[0] = 11;
-                range[1] = 13;
-                break;
-            case 'm':
-                range[0] = 14;
-                range[1] = 16;
-                break;
-            case 's':
-                range[0] = 17;
-                range[1] = 19;
-                break;
-            case 'D':
-                range[0] = 8;
-                range[1] = 10;
-                break;
-            case 'M':
-                range[0] = 5;
-                range[1] = 7;
-                break;
-            case 'Y':
-                range[0] = 0;
-                range[1] = 4;
-                break;
-        }
-        if (str1.slice(range[0], range[1]) === str2.slice(range[0], range[1])) {
-            return 0;
-        }
-        else if (str1.slice(range[0], range[1]) > str2.slice(range[0], range[1])) {
-            return 1;
-        }
-        else {
-            return -1;
-        }
-    }
-    compaire(value, unit = 'day') {
-        if (this._moment.isSame(moment(value.date), this.resolveUnit(unit))) {
-            return 0;
-        }
-        else if (this._moment.isAfter(moment(value.date), this.resolveUnit(unit))) {
-            return 1;
-        }
-        else {
-            return -1;
-        }
-    }
-    toISOString() {
-        return this._date.toISOString();
-    }
-}
-class AXCalendarMonth {
-    constructor(date) {
-        this._moment = moment(date.date);
-        this.index = date.date.getMonth();
-        this.name = this._moment.format('MMMM');
-        this.range = new AXDateTimeRange(new AXDateTime(this._moment.startOf('month').toDate(), date.type), new AXDateTime(this._moment.endOf('month').toDate(), date.type));
-    }
-    get range() {
-        return this._range;
-    }
-    set range(v) {
-        this._range = v;
-    }
-}
-class AXDateTimeRange {
-    constructor(startTime, endTime) {
-        this.startTime = startTime;
-        this.endTime = endTime;
-    }
-    duration(unit = 'days') {
-        const duration = moment.duration(moment(this.startTime.date).diff(moment(this.endTime.date)));
-        return duration.as(unit);
-    }
-    enumurate(unit = 'day', type = AXConfig.get('dateTime.type') || 'jalali') {
-        const result = [];
-        for (let index = 0; this.startTime.add(unit, index).compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0; index++) {
-            result.push(this.startTime.add(unit, index));
-        }
-        return result;
-    }
-    includes(value, unit = 'day', type = 'jalali') {
-        return (value.compaireNew(this.startTime, this.getViewCompaire(unit), type) >= 0 &&
-            value.compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0);
-    }
-    getViewCompaire(view) {
-        switch (view) {
-            case 'day':
-                return 'YMD';
-            case 'month':
-                return 'YM';
-            case 'year':
-                return 'Y';
-        }
-    }
+class AXDateTime {
+    // private get _moment(): moment_.Moment {
+    //     const m = moment(this.date);
+    //     if (this.type === 'jalali') {
+    //         m.locale('fa');
+    //     }
+    //     return m;
+    // }
+    constructor(value = new Date(), type = AXConfig.get('dateTime.type') || 'gregorian') {
+        this.type = type;
+        if (value instanceof Date) {
+            this._date = value;
+        }
+        else {
+            this._date = new Date(value);
+        }
+        this._moment = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+    }
+    static convert(value, type = AXConfig.get('dateTime.type') || 'gregorian') {
+        let date;
+        if (typeof value === 'string' || value instanceof String) {
+            date = new AXDateTime(value, type);
+        }
+        else if (value instanceof Date) {
+            date = new AXDateTime(value, type);
+        }
+        else if (value instanceof AXDateTime) {
+            date = value;
+        }
+        return date;
+    }
+    get date() {
+        return this._date;
+    }
+    resolveUnit(unit) {
+        return this.type === 'jalali' ? 'j' + unit : unit;
+    }
+    clone() {
+        return new AXDateTime(this.date, this.type);
+    }
+    get dayInMonth() {
+        return this._moment.date();
+    }
+    get dayOfYear() {
+        return this._moment.dayOfYear();
+    }
+    get dayInWeek() {
+        return this._moment.day();
+    }
+    get hour() {
+        return this._moment.hour();
+    }
+    get minute() {
+        return this._moment.minute();
+    }
+    get second() {
+        return this._moment.second();
+    }
+    get year() {
+        return this._moment.year();
+    }
+    get monthOfYear() {
+        return this._moment.month();
+    }
+    get month() {
+        return new AXCalendarMonth(this);
+    }
+    get firstDayOfWeek() {
+        const a = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+        return new AXDateTime(a.startOf('w').toDate(), this.type);
+    }
+    get endDayOfWeek() {
+        const a = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+        return new AXDateTime(moment(this.date).endOf('w').toDate(), this.type);
+    }
+    convertStringToJalali(date, format) {
+        return moment(date).locale('fa').format('YYYY/M/D');
+    }
+    convertStringToGregorian(date, format) {
+        return new Date(moment.from(date, 'fa', 'YYYY/MM/DD').format('YYYY/MM/DD'));
+    }
+    add(unit = 'day', amount) {
+        return new AXDateTime(moment(this.date).add(amount, this.resolveUnit(unit)).toDate(), this.type);
+    }
+    addDay(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'd').toDate(), this.type);
+    }
+    addMonth(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'months').toDate(), this.type);
+    }
+    addHour(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'hours').toDate(), this.type);
+    }
+    set(unit = 'day', value) {
+        return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
+    }
+    duration(end, unit = 'days') {
+        const duration = moment.duration(this._moment.diff(end._moment));
+        return Math.round(duration.as(unit));
+    }
+    startOf(unit = 'day') {
+        return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
+    }
+    endOf(unit = 'day') {
+        return new AXDateTime(moment(this.date).endOf(this.resolveUnit(unit)).toDate(), this.type);
+    }
+    format(format = AXConfig.get('dateTime.shortDateFormat') || (this.type === 'gregorian' ? 'DD-MM-YYYY' : 'YYYY-MM-DD')) {
+        if (format === 'P') {
+            return this._moment.fromNow();
+        }
+        return this._moment.format(format);
+    }
+    toString() {
+        return this.format();
+    }
+    equal(value, unit = 'day') {
+        if (!value) {
+            return false;
+        }
+        return this._moment.isSame(moment(value.date), this.resolveUnit(unit));
+    }
+    convertToJalaliDate(value) {
+        const options = {
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        };
+        const jDate = new Date(value).toLocaleDateString('fa-IR', options);
+        const item = {};
+        item.year = jDate.slice(0, 4);
+        item.month = jDate.slice(5, 7);
+        item.day = jDate.slice(8, 10);
+        item.hour = jDate.slice(13, 15);
+        item.minutes = jDate.slice(16, 18);
+        item.seconds = jDate.slice(19, 21);
+        return item;
+    }
+    toJalaliString(value) {
+        const date = this.convertToJalaliDate(value);
+        let str = '';
+        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
+        return str;
+    }
+    convertToGregorianDate(value) {
+        // TODO: check this fucking type
+        const options = {
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        };
+        const date = new Date(value).toLocaleString('en-us', options);
+        const item = {};
+        item.year = date.slice(6, 10);
+        item.month = date.slice(0, 2);
+        item.day = date.slice(3, 5);
+        item.hour = date.slice(12, 14);
+        item.minutes = date.slice(15, 17);
+        item.seconds = date.slice(18, 20);
+        return item;
+    }
+    toGregorianString(value) {
+        const date = this.convertToGregorianDate(value);
+        let str = '';
+        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
+        return str;
+    }
+    compaireNew(value, unit = 'YMD', type = 'jalali') {
+        const range = [0, 0];
+        let str1;
+        let str2;
+        if (type === 'jalali') {
+            str1 = this.toJalaliString(this.date);
+            str2 = this.toJalaliString(value.date ? value.date : value);
+        }
+        else {
+            str1 = this.toGregorianString(this.date);
+            str2 = this.toGregorianString(value.date ? value.date : value);
+        }
+        switch (unit) {
+            case 'YMDhms':
+                range[0] = 0;
+                range[1] = 19;
+                break;
+            case 'YMDhm':
+                range[0] = 0;
+                range[1] = 16;
+                break;
+            case 'YMDh':
+                range[0] = 0;
+                range[1] = 13;
+                break;
+            case 'YMD':
+                range[0] = 0;
+                range[1] = 10;
+                break;
+            case 'YM':
+                range[0] = 0;
+                range[1] = 7;
+                break;
+            case 'h':
+                range[0] = 11;
+                range[1] = 13;
+                break;
+            case 'm':
+                range[0] = 14;
+                range[1] = 16;
+                break;
+            case 's':
+                range[0] = 17;
+                range[1] = 19;
+                break;
+            case 'D':
+                range[0] = 8;
+                range[1] = 10;
+                break;
+            case 'M':
+                range[0] = 5;
+                range[1] = 7;
+                break;
+            case 'Y':
+                range[0] = 0;
+                range[1] = 4;
+                break;
+        }
+        if (str1.slice(range[0], range[1]) === str2.slice(range[0], range[1])) {
+            return 0;
+        }
+        else if (str1.slice(range[0], range[1]) > str2.slice(range[0], range[1])) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    compaire(value, unit = 'day') {
+        if (this._moment.isSame(moment(value.date), this.resolveUnit(unit))) {
+            return 0;
+        }
+        else if (this._moment.isAfter(moment(value.date), this.resolveUnit(unit))) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    toISOString() {
+        return this._date.toISOString();
+    }
+}
+class AXCalendarMonth {
+    constructor(date) {
+        this._moment = moment(date.date);
+        this.index = date.date.getMonth();
+        this.name = this._moment.format('MMMM');
+        this.range = new AXDateTimeRange(new AXDateTime(this._moment.startOf('month').toDate(), date.type), new AXDateTime(this._moment.endOf('month').toDate(), date.type));
+    }
+    get range() {
+        return this._range;
+    }
+    set range(v) {
+        this._range = v;
+    }
+}
+class AXDateTimeRange {
+    constructor(startTime, endTime) {
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+    duration(unit = 'days') {
+        const duration = moment.duration(moment(this.startTime.date).diff(moment(this.endTime.date)));
+        return duration.as(unit);
+    }
+    enumurate(unit = 'day', type = AXConfig.get('dateTime.type') || 'jalali') {
+        const result = [];
+        for (let index = 0; this.startTime.add(unit, index).compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0; index++) {
+            result.push(this.startTime.add(unit, index));
+        }
+        return result;
+    }
+    includes(value, unit = 'day', type = 'jalali') {
+        return (value.compaireNew(this.startTime, this.getViewCompaire(unit), type) >= 0 &&
+            value.compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0);
+    }
+    getViewCompaire(view) {
+        switch (view) {
+            case 'day':
+                return 'YMD';
+            case 'month':
+                return 'YM';
+            case 'year':
+                return 'Y';
+        }
+    }
 }
 
-class AXBaseMenuItem {
-    constructor() {
-        this.uid = new Date().getTime().toString();
-        this.visible = true;
-        this.disable = false;
-        this.selected = false;
-        this.style = 'ax light';
-        this.orderIndex = 0;
-    }
-}
-class AXMenuItem extends AXBaseMenuItem {
-    constructor() {
-        super(...arguments);
-        this.divider = false;
-    }
-}
-class AXButtonItem extends AXBaseMenuItem {
-    constructor() {
-        super(...arguments);
-        this.dropdown = false;
-        this.submitBehavior = false;
-        this.cancelBehavior = false;
-    }
-}
-class AXCheckItem {
+class AXBaseMenuItem {
+    constructor() {
+        this.uid = new Date().getTime().toString();
+        this.visible = true;
+        this.disable = false;
+        this.selected = false;
+        this.style = 'ax light';
+        this.orderIndex = 0;
+    }
+}
+class AXMenuItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.divider = false;
+    }
+}
+class AXButtonItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.dropdown = false;
+        this.submitBehavior = false;
+        this.cancelBehavior = false;
+    }
+}
+class AXCheckItem {
 }
 
-class AXPromise {
-    constructor(executor) {
-        this._executor = executor;
-        setTimeout(() => {
-            this._executor(this.thenAction);
-        }, 50);
-    }
-    static resolve(value) {
-        const r = new AXPromise(z => {
-            z(value);
-        }).then(() => { });
-        return r;
-    }
-    then(action) {
-        this.thenAction = action;
-        return this;
-    }
+class AXPromise {
+    constructor(executor) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.thenAction);
+        }, 50);
+    }
+    static resolve(value) {
+        const r = new AXPromise(z => {
+            z(value);
+        }).then(() => { });
+        return r;
+    }
+    then(action) {
+        this.thenAction = action;
+        return this;
+    }
 }
 
-class AXSelectItem {
+class AXSelectItem {
 }
 
-/**
- * @deprecated Use AXBasePageComponent from @acorex/components
- */
-// TODO: Add Angular decorator.
-class AXBasePageComponent {
-    constructor() {
-        this.onClosed = new EventEmitter();
-    }
-    close(data) {
-        this.onClosed.emit({
-            component: this,
-            data: data
-        });
-    }
-    onClosing(e) {
-    }
-    ngOnDestroy() {
-        this.onClosed.unsubscribe();
-    }
-}
-AXBasePageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXBasePageComponent.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent, decorators: [{
-            type: Injectable
+/**
+ * @deprecated Use AXBasePageComponent from @acorex/components
+ */
+// TODO: Add Angular decorator.
+class AXBasePageComponent {
+    constructor() {
+        this.onClosed = new EventEmitter();
+    }
+    close(data) {
+        this.onClosed.emit({
+            component: this,
+            data: data
+        });
+    }
+    onClosing(e) {
+    }
+    ngOnDestroy() {
+        this.onClosed.unsubscribe();
+    }
+}
+AXBasePageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXBasePageComponent.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXBasePageComponent, decorators: [{
+            type: Injectable
         }] });
 
-const AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken('ax.error');
-class AXErrorService {
-    constructor(injector) {
-        this.injector = injector;
-    }
-    handle(message) {
-        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
-        if (instance) {
-            instance.show(message);
-        }
-    }
-}
-AXErrorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-AXErrorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+const AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken('ax.error');
+class AXErrorService {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    handle(message) {
+        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
+        if (instance) {
+            instance.show(message);
+        }
+    }
+}
+AXErrorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AXErrorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-class AXErrorModule {
-}
-AXErrorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXErrorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, imports: [CommonModule] });
-AXErrorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, providers: [AXErrorService], imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [CommonModule],
-                    exports: [],
-                    providers: [AXErrorService],
-                }]
+class AXErrorModule {
+}
+AXErrorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXErrorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, imports: [CommonModule] });
+AXErrorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, providers: [AXErrorService], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXErrorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule],
+                    exports: [],
+                    providers: [AXErrorService],
+                }]
         }] });
 
 const AX_HTTP_EVENT_INTERCEPTOR = new InjectionToken('ax.http.events');
 
-class HttpResult {
-    constructor(executor) {
-        this._executor = executor;
-        setTimeout(() => {
-            this._executor(this.resultAction, this.errorAction, this.completeAction);
-        }, 50);
-    }
-    result(action) {
-        this.resultAction = action;
-        return this;
-    }
-    error(action) {
-        this.errorAction = action;
-        return this;
-    }
-    complete(action) {
-        this.completeAction = action;
-        return this;
-    }
+class HttpResult {
+    constructor(executor) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.resultAction, this.errorAction, this.completeAction);
+        }, 50);
+    }
+    result(action) {
+        this.resultAction = action;
+        return this;
+    }
+    error(action) {
+        this.errorAction = action;
+        return this;
+    }
+    complete(action) {
+        this.completeAction = action;
+        return this;
+    }
 }
 
-// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
-// import { of, concat, throwError } from 'rxjs';
-class AXHttpService {
-    constructor(http, injector) {
-        this.http = http;
-        this.injector = injector;
-        this.interceptor = this.injector.get(AX_HTTP_EVENT_INTERCEPTOR);
-    }
-    get(url, config = {}) {
-        config.url = url;
-        config.method = "get";
-        return this.request(config);
-    }
-    post(url, config = {}) {
-        config.url = url;
-        config.method = "post";
-        return this.request(config);
-    }
-    delete(url, config = {}) {
-        config.url = url;
-        config.method = "delete";
-        return this.request(config);
-    }
-    put(url, config = {}) {
-        config.url = url;
-        config.method = "put";
-        return this.request(config);
-    }
-    request(config) {
-        return new HttpResult((result, error, complete) => {
-            this.handleBegin(config).then(c => {
-                this.http
-                    .request(config.method, config.url, this.mapOptions(config))
-                    //.pipe(this.retry)
-                    .subscribe(data => {
-                    this.handleResult(data, result, complete, config);
-                }, c => {
-                    this.handleError(c, error, complete, config);
-                });
-            });
-        });
-    }
-    handleResult(data, result, complete, config) {
-        if (this.interceptor) {
-            this.interceptor.success(config, data).then(c => {
-                if (result)
-                    result(c);
-                this.handleComplete(complete, config);
-            });
-        }
-        else {
-            //
-            if (result)
-                result(data);
-            this.handleComplete(complete, config);
-        }
-    }
-    handleBegin(config) {
-        return new Promise((resolve) => {
-            if (!config.headers)
-                config.headers = {};
-            if (!config.params)
-                config.params = {};
-            //
-            if (this.interceptor) {
-                this.interceptor.begin(config).then(c => {
-                    resolve(c);
-                });
-            }
-            else {
-                resolve(config);
-            }
-        });
-    }
-    handleComplete(complete, config) {
-        if (complete)
-            complete();
-        if (this.interceptor)
-            this.interceptor.complete(config);
-    }
-    handleError(c, error, complete, config) {
-        var _a;
-        let r = {
-            message: c.message,
-            status: c.status,
-            code: (_a = c.status) === null || _a === void 0 ? void 0 : _a.toString(),
-            handled: false,
-            error: c.error
-        };
-        if (error) {
-            error(r);
-        }
-        if (!r.handled) {
-            if (this.interceptor)
-                this.interceptor.error(config, r);
-        }
-        this.handleComplete(complete, config);
-    }
-    mapOptions(options) {
-        let headers = new HttpHeaders();
-        for (const key in options.headers) {
-            if (options.headers.hasOwnProperty(key)) {
-                const value = options.headers[key];
-                headers = headers.set(key, value);
-            }
-        }
-        let params = new HttpParams();
-        for (const key in options.params) {
-            if (options.params.hasOwnProperty(key)) {
-                const value = options.params[key];
-                params = params.set(key, value);
-            }
-        }
-        return {
-            headers: headers,
-            params: params,
-            body: options.body,
-            responseType: options.responseType || 'json'
-        };
-        // if (options.method == "get") {
-        //     return {
-        //         headers: headers,
-        //         params: params
-        //     };
-        // }
-        // else {
-        //     return {
-        //         headers: headers,
-        //         params: params,
-        //         body: options.body
-        //     };
-        // }
-    }
-}
-AXHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-AXHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService, decorators: [{
-            type: Injectable
+// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
+// import { of, concat, throwError } from 'rxjs';
+class AXHttpService {
+    constructor(http, injector) {
+        this.http = http;
+        this.injector = injector;
+        this.interceptor = this.injector.get(AX_HTTP_EVENT_INTERCEPTOR);
+    }
+    get(url, config = {}) {
+        config.url = url;
+        config.method = "get";
+        return this.request(config);
+    }
+    post(url, config = {}) {
+        config.url = url;
+        config.method = "post";
+        return this.request(config);
+    }
+    delete(url, config = {}) {
+        config.url = url;
+        config.method = "delete";
+        return this.request(config);
+    }
+    put(url, config = {}) {
+        config.url = url;
+        config.method = "put";
+        return this.request(config);
+    }
+    request(config) {
+        return new HttpResult((result, error, complete) => {
+            this.handleBegin(config).then(c => {
+                this.http
+                    .request(config.method, config.url, this.mapOptions(config))
+                    //.pipe(this.retry)
+                    .subscribe(data => {
+                    this.handleResult(data, result, complete, config);
+                }, c => {
+                    this.handleError(c, error, complete, config);
+                });
+            });
+        });
+    }
+    handleResult(data, result, complete, config) {
+        if (this.interceptor) {
+            this.interceptor.success(config, data).then(c => {
+                if (result)
+                    result(c);
+                this.handleComplete(complete, config);
+            });
+        }
+        else {
+            //
+            if (result)
+                result(data);
+            this.handleComplete(complete, config);
+        }
+    }
+    handleBegin(config) {
+        return new Promise((resolve) => {
+            if (!config.headers)
+                config.headers = {};
+            if (!config.params)
+                config.params = {};
+            //
+            if (this.interceptor) {
+                this.interceptor.begin(config).then(c => {
+                    resolve(c);
+                });
+            }
+            else {
+                resolve(config);
+            }
+        });
+    }
+    handleComplete(complete, config) {
+        if (complete)
+            complete();
+        if (this.interceptor)
+            this.interceptor.complete(config);
+    }
+    handleError(c, error, complete, config) {
+        var _a;
+        let r = {
+            message: c.message,
+            status: c.status,
+            code: (_a = c.status) === null || _a === void 0 ? void 0 : _a.toString(),
+            handled: false,
+            error: c.error
+        };
+        if (error) {
+            error(r);
+        }
+        if (!r.handled) {
+            if (this.interceptor)
+                this.interceptor.error(config, r);
+        }
+        this.handleComplete(complete, config);
+    }
+    mapOptions(options) {
+        let headers = new HttpHeaders();
+        for (const key in options.headers) {
+            if (options.headers.hasOwnProperty(key)) {
+                const value = options.headers[key];
+                headers = headers.set(key, value);
+            }
+        }
+        let params = new HttpParams();
+        for (const key in options.params) {
+            if (options.params.hasOwnProperty(key)) {
+                const value = options.params[key];
+                params = params.set(key, value);
+            }
+        }
+        return {
+            headers: headers,
+            params: params,
+            body: options.body,
+            responseType: options.responseType || 'json'
+        };
+        // if (options.method == "get") {
+        //     return {
+        //         headers: headers,
+        //         params: params
+        //     };
+        // }
+        // else {
+        //     return {
+        //         headers: headers,
+        //         params: params,
+        //         body: options.body
+        //     };
+        // }
+    }
+}
+AXHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AXHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpService, decorators: [{
+            type: Injectable
         }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.Injector }]; } });
 
-class AXHttpModule {
-    static forRoot() {
-        return {
-            ngModule: AXHttpModule,
-            providers: [AXHttpService]
-        };
-    }
-}
-AXHttpModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXHttpModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, imports: [CommonModule,
-        HttpClientModule], exports: [HttpClientModule] });
-AXHttpModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, providers: [
-        AXHttpService
-    ], imports: [[
-            CommonModule,
-            HttpClientModule
-        ], HttpClientModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [
-                        CommonModule,
-                        HttpClientModule
-                    ],
-                    exports: [HttpClientModule],
-                    providers: [
-                        AXHttpService
-                    ]
-                }]
+class AXHttpModule {
+    static forRoot() {
+        return {
+            ngModule: AXHttpModule,
+            providers: [AXHttpService]
+        };
+    }
+}
+AXHttpModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXHttpModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, imports: [CommonModule,
+        HttpClientModule], exports: [HttpClientModule] });
+AXHttpModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, providers: [
+        AXHttpService
+    ], imports: [[
+            CommonModule,
+            HttpClientModule
+        ], HttpClientModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHttpModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule
+                    ],
+                    exports: [HttpClientModule],
+                    providers: [
+                        AXHttpService
+                    ]
+                }]
         }] });
 
-const isChrome = (win) => testUserAgent(win, /Chrome/i);
-const isFirefox = (win) => testUserAgent(win, /Firefox/i);
-const isEdge = (win) => testUserAgent(win, /Edge/i);
-const isSafari = (win) => testUserAgent(win, /Safari/i);
-const isOpera = (win) => testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);
-const isMSIE = (win) => testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);
-const isMobileWeb = (win) => isMobile(win) && !isHybrid(win);
-const isIpad = (win) => {
-    // iOS 12 and below
-    if (testUserAgent(win, /iPad/i)) {
-        return true;
-    }
-    // iOS 13+
-    if (testUserAgent(win, /Macintosh/i) && isMobile(win)) {
-        return true;
-    }
-    return false;
-};
-const isIphone = (win) => testUserAgent(win, /iPhone/i);
-const isIOS = (win) => testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
-const isAndroid = (win) => testUserAgent(win, /android|sink/i);
-const isAndroidTablet = (win) => {
-    return isAndroid(win) && !testUserAgent(win, /mobile/i);
-};
-const isPhablet = (win) => {
-    const width = win.innerWidth;
-    const height = win.innerHeight;
-    const smallest = Math.min(width, height);
-    const largest = Math.max(width, height);
-    return (smallest > 390 && smallest < 520) &&
-        (largest > 620 && largest < 800);
-};
-const isTablet = (win) => {
-    const width = win.innerWidth;
-    const height = win.innerHeight;
-    const smallest = Math.min(width, height);
-    const largest = Math.max(width, height);
-    return (isIpad(win) ||
-        isAndroidTablet(win) ||
-        ((smallest > 460 && smallest < 820) &&
-            (largest > 780 && largest < 1400)));
-};
-const isMobile = (win) => matchMedia(win, '(any-pointer:coarse)');
-const isTouch = (win) => matchMedia(win, '(any-pointer:coarse)');
-const isDesktop = (win) => !isMobile(win);
-const isHybrid = (win) => isCordova(win) || isCapacitorNative(win);
-const isCordova = (win) => !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);
-const isCapacitorNative = (win) => {
-    const capacitor = win['Capacitor'];
-    return !!(capacitor && capacitor.isNative);
-};
-const isElectron = (win) => testUserAgent(win, /electron/i);
-const isPWA = (win) => !!(win.matchMedia('(display-mode: standalone)').matches || win.navigator.standalone);
-const testUserAgent = (win, expr) => expr.test(win.navigator.userAgent);
-const matchMedia = (win, query) => win.matchMedia(query).matches;
-const isSMScreen = (win) => matchMedia(win, '(max-width: 640px)');
-const isMDScreen = (win) => matchMedia(win, '(max-width: 768px)');
-const isLGScreen = (win) => matchMedia(win, '(max-width: 1024px)');
-const isXLScreen = (win) => matchMedia(win, '(max-width: 1280px)');
-const is2XLScreen = (win) => matchMedia(win, '(max-width: 1536px)');
-const PLATFORMS_MAP = {
-    'Android': isAndroid,
-    'iOS': isIOS,
-    'Desktop': isDesktop,
-    'Mobile': isMobile,
-    'Touch': isTouch,
-    'Chrome': isChrome,
-    'Firefox': isFirefox,
-    'Safari': isSafari,
-    'Edge': isEdge,
-    'Opera': isOpera,
-    'Hybrid': isHybrid,
-    'PWA': isPWA,
-    'Electron': isElectron,
-    SM: isSMScreen,
-    MD: isMDScreen,
-    LG: isLGScreen,
-    XL: isXLScreen,
-    "2XL": is2XLScreen,
-};
-class AXPlatformEvent {
-}
-class AXPlatform {
-    constructor() {
-        this.resize = new Subject();
-        this.click = new Subject();
-        this.scroll = new Subject();
-        fromEvent(window, 'resize')
-            .pipe(debounceTime(100))
-            .pipe(distinctUntilChanged())
-            .subscribe((e) => {
-            this.resize.next({
-                nativeEvent: e,
-                source: this
-            });
-            //
-            this._setFullHeightRatio();
-        });
-        document.addEventListener('click', (e) => {
-            this.click.next({
-                nativeEvent: e,
-                source: this
-            });
-        }, true);
-        document.addEventListener('scroll', (e) => {
-            this.scroll.next({
-                nativeEvent: e,
-                source: this
-            });
-        }, true);
-        // init functions
-        this._setFullHeightRatio();
-    }
-    isRtl() {
-        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
-    }
-    isLandscape() {
-        return window.innerHeight < window.innerWidth;
-    }
-    isPortrate() {
-        return !this.isLandscape();
-    }
-    is(name) {
-        return PLATFORMS_MAP[name](window) || false;
-    }
-    switchDarkMode() {
-        const _html = document.getElementsByTagName("html")[0];
-        _html.classList.add('ax-dark');
-    }
-    switchLightMode() {
-        const _html = document.getElementsByTagName("html")[0];
-        _html.classList.remove('ax-dark');
-    }
-    _setFullHeightRatio() {
-        document.querySelector(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');
-    }
-}
-AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
+const isChrome = (win) => testUserAgent(win, /Chrome/i);
+const isFirefox = (win) => testUserAgent(win, /Firefox/i);
+const isEdge = (win) => testUserAgent(win, /Edge/i);
+const isSafari = (win) => testUserAgent(win, /Safari/i);
+const isOpera = (win) => testUserAgent(win, /Opera/i) || testUserAgent(win, /OPR/i);
+const isMSIE = (win) => testUserAgent(win, /MSIE/i) || testUserAgent(win, /Trident/i);
+const isMobileWeb = (win) => isMobile(win) && !isHybrid(win);
+const isIpad = (win) => {
+    // iOS 12 and below
+    if (testUserAgent(win, /iPad/i)) {
+        return true;
+    }
+    // iOS 13+
+    if (testUserAgent(win, /Macintosh/i) && isMobile(win)) {
+        return true;
+    }
+    return false;
+};
+const isIphone = (win) => testUserAgent(win, /iPhone/i);
+const isIOS = (win) => testUserAgent(win, /iPhone|iPod/i) || isIpad(win);
+const isAndroid = (win) => testUserAgent(win, /android|sink/i);
+const isAndroidTablet = (win) => {
+    return isAndroid(win) && !testUserAgent(win, /mobile/i);
+};
+const isPhablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (smallest > 390 && smallest < 520) &&
+        (largest > 620 && largest < 800);
+};
+const isTablet = (win) => {
+    const width = win.innerWidth;
+    const height = win.innerHeight;
+    const smallest = Math.min(width, height);
+    const largest = Math.max(width, height);
+    return (isIpad(win) ||
+        isAndroidTablet(win) ||
+        ((smallest > 460 && smallest < 820) &&
+            (largest > 780 && largest < 1400)));
+};
+const isMobile = (win) => matchMedia(win, '(any-pointer:coarse)');
+const isTouch = (win) => matchMedia(win, '(any-pointer:coarse)');
+const isDesktop = (win) => !isMobile(win);
+const isHybrid = (win) => isCordova(win) || isCapacitorNative(win);
+const isCordova = (win) => !!(win['cordova'] || win['phonegap'] || win['PhoneGap']);
+const isCapacitorNative = (win) => {
+    const capacitor = win['Capacitor'];
+    return !!(capacitor && capacitor.isNative);
+};
+const isElectron = (win) => testUserAgent(win, /electron/i);
+const isPWA = (win) => !!(win.matchMedia('(display-mode: standalone)').matches || win.navigator.standalone);
+const testUserAgent = (win, expr) => expr.test(win.navigator.userAgent);
+const matchMedia = (win, query) => win.matchMedia(query).matches;
+const isSMScreen = (win) => matchMedia(win, '(max-width: 640px)');
+const isMDScreen = (win) => matchMedia(win, '(max-width: 768px)');
+const isLGScreen = (win) => matchMedia(win, '(max-width: 1024px)');
+const isXLScreen = (win) => matchMedia(win, '(max-width: 1280px)');
+const is2XLScreen = (win) => matchMedia(win, '(max-width: 1536px)');
+const PLATFORMS_MAP = {
+    'Android': isAndroid,
+    'iOS': isIOS,
+    'Desktop': isDesktop,
+    'Mobile': isMobile,
+    'Touch': isTouch,
+    'Chrome': isChrome,
+    'Firefox': isFirefox,
+    'Safari': isSafari,
+    'Edge': isEdge,
+    'Opera': isOpera,
+    'Hybrid': isHybrid,
+    'PWA': isPWA,
+    'Electron': isElectron,
+    SM: isSMScreen,
+    MD: isMDScreen,
+    LG: isLGScreen,
+    XL: isXLScreen,
+    "2XL": is2XLScreen,
+};
+class AXPlatformEvent {
+}
+class AXPlatform {
+    constructor() {
+        this.resize = new Subject();
+        this.click = new Subject();
+        this.scroll = new Subject();
+        fromEvent(window, 'resize')
+            .pipe(debounceTime(100))
+            .pipe(distinctUntilChanged())
+            .subscribe((e) => {
+            this.resize.next({
+                nativeEvent: e,
+                source: this
+            });
+            //
+            this._setFullHeightRatio();
+        });
+        document.addEventListener('click', (e) => {
+            this.click.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        document.addEventListener('scroll', (e) => {
+            this.scroll.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        // init functions
+        this._setFullHeightRatio();
+    }
+    isRtl() {
+        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
+    }
+    isLandscape() {
+        return window.innerHeight < window.innerWidth;
+    }
+    isPortrate() {
+        return !this.isLandscape();
+    }
+    is(name) {
+        return PLATFORMS_MAP[name](window) || false;
+    }
+    switchDarkMode() {
+        const _html = document.getElementsByTagName("html")[0];
+        _html.classList.add('ax-dark');
+    }
+    switchLightMode() {
+        const _html = document.getElementsByTagName("html")[0];
+        _html.classList.remove('ax-dark');
+    }
+    _setFullHeightRatio() {
+        document.querySelector(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');
+    }
+}
+AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: function () { return []; } });
 
-class AXDateTimePipe {
-    constructor() { }
-    transform(value, format) {
-        const date = AXDateTime.convert(value);
-        if (value == null) {
-            return '';
-        }
-        if (!format) {
-            return date.toString();
-        }
-        else {
-            return date.format(format);
-        }
-    }
-}
-AXDateTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXDateTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, name: "dt" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'dt' }]
+class AXDateTimePipe {
+    constructor() { }
+    transform(value, format) {
+        const date = AXDateTime.convert(value);
+        if (value == null) {
+            return '';
+        }
+        if (!format) {
+            return date.toString();
+        }
+        else {
+            return date.format(format);
+        }
+    }
+}
+AXDateTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXDateTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, name: "dt" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXDateTimePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dt' }]
         }], ctorParameters: function () { return []; } });
 
-class AXHtmlToTextPipe {
-    transform(value) {
-        if (value) {
-            const regexHtml = /<\/?[^>]+>/gi;
-            const regexNbsp = /&nbsp;/gi;
-            const regexAmp = /&amp;/gi;
-            return value
-                .replace(regexHtml, '')
-                .replace(regexNbsp, '')
-                .replace(regexAmp, '');
-        }
-        else {
-            return '';
-        }
-    }
-}
-AXHtmlToTextPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXHtmlToTextPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, name: "html2text" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'html2text' }]
+class AXHtmlToTextPipe {
+    transform(value) {
+        if (value) {
+            const regexHtml = /<\/?[^>]+>/gi;
+            const regexNbsp = /&nbsp;/gi;
+            const regexAmp = /&amp;/gi;
+            return value
+                .replace(regexHtml, '')
+                .replace(regexNbsp, '')
+                .replace(regexAmp, '');
+        }
+        else {
+            return '';
+        }
+    }
+}
+AXHtmlToTextPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXHtmlToTextPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, name: "html2text" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlToTextPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'html2text' }]
         }] });
 
-class AXEventService {
-    constructor() {
-        this.list = [];
-    }
-    broadcast(key, options) {
-        const d = this.list.find(c => c.key === key);
-        if (d) {
-            d.events.forEach(c => {
-                c(options);
-            });
-        }
-    }
-    on(key, callback) {
-        let d = this.list.find(c => c.key === key);
-        if (!d) {
-            d = { key, events: [] };
-            this.list.push(d);
-        }
-        d.events.push(callback);
-    }
-    destroy(key, callback) {
-        const d = this.list.find(c => c.key === key);
-        if (d) {
-            d.events = [];
-        }
-    }
-}
-AXEventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+class AXEventService {
+    constructor() {
+        this.list = [];
+    }
+    broadcast(key, options) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events.forEach(c => {
+                c(options);
+            });
+        }
+    }
+    on(key, callback) {
+        let d = this.list.find(c => c.key === key);
+        if (!d) {
+            d = { key, events: [] };
+            this.list.push(d);
+        }
+        d.events.push(callback);
+    }
+    destroy(key, callback) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events = [];
+        }
+    }
+}
+AXEventService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXEventService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }] });
 
-class AXNavigator {
-}
-AXNavigator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXNavigator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, decorators: [{
-            type: Injectable
+class AXNavigator {
+}
+AXNavigator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXNavigator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXNavigator, decorators: [{
+            type: Injectable
         }] });
 
-class AXStorageService {
-    get(key) {
-        return localStorage.getItem(key);
-    }
-    set(key, value) {
-        localStorage.setItem(key, value);
-    }
-}
-AXStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, decorators: [{
-            type: Injectable
+class AXStorageService {
+    get(key) {
+        return localStorage.getItem(key);
+    }
+    set(key, value) {
+        localStorage.setItem(key, value);
+    }
+}
+AXStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXStorageService, decorators: [{
+            type: Injectable
         }] });
 
-// @dynamic
-class AXTranslator {
-    static get onChange() {
-        return AXTranslator.dataChangeSubject.asObservable();
-    }
-    static load(lang, value) {
-        if (typeof value === 'object') {
-            if (!AXTranslator[`__data__${lang}`]) {
-                AXTranslator[`__data__${lang}`] = {};
-            }
-            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
-        }
-    }
-    static use(lang) {
-        AXTranslator.lang = lang;
-    }
-    static get(key, lang) {
-        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
-    }
-}
-AXTranslator.lang = 'en';
+// @dynamic
+class AXTranslator {
+    static get onChange() {
+        return AXTranslator.dataChangeSubject.asObservable();
+    }
+    static load(lang, value) {
+        if (typeof value === 'object') {
+            if (!AXTranslator[`__data__${lang}`]) {
+                AXTranslator[`__data__${lang}`] = {};
+            }
+            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
+        }
+    }
+    static use(lang) {
+        AXTranslator.lang = lang;
+    }
+    static get(key, lang) {
+        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+    }
+}
+AXTranslator.lang = 'en';
 AXTranslator.dataChangeSubject = new Subject();
 
-class AXTranslatorService {
-    load(lang, value) {
-        AXTranslator.load(lang, value);
-    }
-    use(lang) {
-        AXTranslator.use(lang);
-    }
-    get(key, lang) {
-        return AXTranslator.get(lang, lang);
-    }
-}
-AXTranslatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXTranslatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, providedIn: 'platform' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'platform' }]
+class AXTranslatorService {
+    load(lang, value) {
+        AXTranslator.load(lang, value);
+    }
+    use(lang) {
+        AXTranslator.use(lang);
+    }
+    get(key, lang) {
+        return AXTranslator.get(lang, lang);
+    }
+}
+AXTranslatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXTranslatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, providedIn: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
         }] });
 
-class AXTranslatorPipe {
-    constructor() { }
-    // transform(value: string, lang?: string): Promise<string> {
-    //     return new Promise<string>((resolve, reject) => {
-    //         if (!value) {
-    //             resolve(value);
-    //         }
-    //         resolve(this.translate.get(value, lang));
-    //     });
-    // }
-    transform(value, lang) {
-        return AXTranslator.get(value, lang);
-    }
-}
-AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'trans', pure: true }]
+class AXTranslatorPipe {
+    constructor() { }
+    // transform(value: string, lang?: string): Promise<string> {
+    //     return new Promise<string>((resolve, reject) => {
+    //         if (!value) {
+    //             resolve(value);
+    //         }
+    //         resolve(this.translate.get(value, lang));
+    //     });
+    // }
+    transform(value, lang) {
+        return AXTranslator.get(value, lang);
+    }
+}
+AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'trans', pure: true }]
         }], ctorParameters: function () { return []; } });
 
-var common$1 = {
-    search: "Search",
-    yes: "yes",
-    no: "No",
-    confirm: "Confirm",
-    okay: "Okay",
-    cancel: "Cancel",
-    remove: "Remove",
-    edit: "Edit",
-    configs: "Configs",
-    noDataFound: "No data found!",
-    searching: "searching ...",
-    save: "Save",
-    "save-as": "Save As...",
-    title: "Title",
-    description: "Description",
-    name: "Name",
-    uniquename: "Unique Name",
-    size: "Size",
-    "add-item": "Add Item",
-    color: "Color",
-    display: "Display",
-    "min-value": "Min Value",
-    value: "Value",
-    "max-value": "Max Value",
-    "refresh-rate": "Refresh Rate",
-    refresh: "Refresh",
-    reload: "Reload",
-    condition: "Condition",
-    next: "Next",
-    prev: "Prev"
-};
-var dateTime$1 = {
-    weekdaysShort: {
-        sun: "Sun",
-        mon: "Mon",
-        tue: "Tue",
-        wed: "Wed",
-        thu: "Thu",
-        fri: "Fri",
-        sat: "Sat"
-    },
-    dayTime: {
-        am: "am",
-        pm: "pm",
-        m: "m",
-        a: "a",
-        p: "p"
-    },
-    today: "today",
-    duration: {
-        format_second: "{0} second(s)",
-        format_minute: "{0} minute(s)"
-    }
-};
-var queryBuilder$1 = {
-    contains: "contains",
-    "not-contains": "not-contains",
-    "contains-all": "contains-all",
-    "start-with": "start-with",
-    "end-with": "end-with",
-    equal: "equal",
-    "not-equal": "not-equal",
-    "null": "null",
-    "not-null": "not-null",
-    "greater-than": "greater-than",
-    gt: "greater-than",
-    "greater-than-equal": "greater-than-equal",
-    gte: "greater-than-equal",
-    "less-than": "less-than",
-    lt: "less-than",
-    "less-than-equal": "less-than-equal",
-    lte: "less-than-equal",
-    "true": "true",
-    "false": "false",
-    empty: "empty"
-};
-var validation$1 = {
-    messages: {
-        required: "This field is required!",
-        email: "Please enter a valid email address!",
-        phone: "Please enter a valid phone number!"
-    }
-};
-var dataGrid$1 = {
-    page: "page",
-    more: "more",
-    to: "To",
-    of: "Of",
-    next: "next",
-    last: "last",
-    first: "first",
-    previous: "previous",
-    loadingOoo: "Loading...",
-    selectAll: "selectAll",
-    searchOoo: "Search...",
-    blanks: "blanks",
-    filterOoo: "Filter...",
-    equals: "Equals",
-    notEqual: "NotEqual",
-    lessThan: "LessThan",
-    greaterThan: "GreaterThan",
-    lessThanOrEqual: "LessThanOrEqual",
-    greaterThanOrEqual: "GreaterThanOrEqual",
-    inRange: "InRange",
-    inRangeStart: "To",
-    inRangeEnd: "From",
-    contains: "Contains",
-    notContains: "NotContains",
-    startsWith: "Starts with",
-    endsWith: "Ends with",
-    andCondition: "AND",
-    orCondition: "OR",
-    applyFilter: "Apply",
-    resetFilter: "Reset",
-    clearFilter: "Clear",
-    group: "Group",
-    columns: "Columns",
-    filters: "Filters",
-    groups: "Groups",
-    values: "Values",
-    enabled: "Enabled",
-    pinColumn: "Pin Column",
-    groupBy: "Group by",
-    ungroupBy: "UnGroup by",
-    resetColumns: "ResetColumns",
-    expandAll: "ExpandAll",
-    collapseAll: "CollapseAll",
-    toolPanel: "ToolPanel",
-    "export": "Exporto",
-    csvExport: "csv Export",
-    excelExport: "Excel Export (.xlsx)",
-    excelXmlExport: "Excel Exporto (.xml)",
-    chartRange: "Chart Range",
-    columnChart: "Column",
-    groupedColumn: "Grouped",
-    stackedColumn: "Stacked",
-    normalizedColumn: "normalized Column",
-    barChart: "bar Chart",
-    groupedBar: "Grouped",
-    stackedBar: "Stacked",
-    normalizedBar: "normalized Bar",
-    pie: "Pie",
-    doughnut: "Doughnut",
-    line: "Line",
-    xyChart: "X Y (Scatter)",
-    scatter: "Scatter",
-    bubble: "Bubble",
-    areaChart: "Area",
-    area: "Area",
-    stackedArea: "Stacked",
-    normalizedArea: "100% Stacked",
-    histogramChart: "Histogram",
-    pinLeft: "Pin Left",
-    pinRight: "Pin Right",
-    noPin: "Dont Pin",
-    sum: "Sum",
-    min: "Min",
-    max: "Max",
-    none: "None",
-    count: "Count",
-    avg: "Average",
-    filteredRows: "Filtered",
-    selectedRows: "Selected",
-    totalRows: "Total Rows",
-    totalAndFilteredRows: "Rows",
-    copy: "Copy",
-    copyWithHeaders: "Copy With Headers",
-    ctrlC: "Ctrl C",
-    paste: "Paste",
-    ctrlV: "Ctrl V",
-    pivotChartTitle: "Pivot Chart",
-    rangeChartTitle: "Range Chart",
-    settings: "Settings",
-    data: "Data",
-    format: "Format",
-    categories: "Categories",
-    series: "Series",
-    xyValues: "X Y Values",
-    paired: "Paired Mode",
-    axis: "Axis",
-    color: "Color",
-    thickness: "Thickness",
-    xType: "X Type",
-    automatic: "Automatic",
-    category: "Category",
-    number: "Number",
-    time: "Time",
-    xRotation: "X Rotation",
-    yRotation: "Y Rotation",
-    ticks: "Ticks",
-    width: "Width",
-    length: "Length",
-    padding: "Padding",
-    chart: "Chart",
-    title: "Title",
-    background: "Background",
-    font: "Font",
-    top: "Top",
-    right: "Right",
-    bottom: "Bottom",
-    left: "Left",
-    labels: "Labels",
-    size: "Size",
-    minSize: "Minimum Size",
-    maxSize: "Maximum Size",
-    legend: "Legend",
-    position: "Position",
-    markerSize: "Marker Size",
-    markerStroke: "Marker Stroke",
-    markerPadding: "Marker Padding",
-    itemPaddingX: "Item Padding X",
-    itemPaddingY: "Item Padding Y",
-    strokeWidth: "Stroke Width",
-    offset: "Offset",
-    offsets: "Offsets",
-    tooltips: "Tooltips",
-    callout: "Callout",
-    markers: "Markers",
-    shadow: "Shadow",
-    blur: "Blur",
-    xOffset: "X Offset",
-    yOffset: "Y Offset",
-    lineWidth: "Line Width",
-    normal: "Normal",
-    bold: "Bold",
-    italic: "Italic",
-    boldItalic: "Bold Italic",
-    predefined: "Predefined",
-    fillOpacity: "Fill Opacity",
-    strokeOpacity: "Line Opacity",
-    histogramBinCount: "Bin Count",
-    columnGroup: "Column",
-    barGroup: "Bar",
-    pieGroup: "Pie",
-    lineGroup: "Line",
-    scatterGroup: "Scatter",
-    areaGroup: "Area",
-    histogramGroup: "Histogram",
-    groupedColumnTooltip: "Grouped",
-    stackedColumnTooltip: "Stacked",
-    normalizedColumnTooltip: "100% Stacked",
-    groupedBarTooltip: "Grouped",
-    stackedBarTooltip: "Stacked",
-    pieTooltip: "Pie",
-    doughnutTooltip: "Doughnut",
-    lineTooltip: "Line",
-    groupedAreaTooltip: "Grouped",
-    stackedAreaTooltip: "Stacked",
-    scatterTooltip: "Scatter",
-    bubbleTooltip: "Bubble",
-    histogramTooltip: "Histogram"
-};
-var en = {
-    common: common$1,
-    dateTime: dateTime$1,
-    queryBuilder: queryBuilder$1,
-    validation: validation$1,
-    dataGrid: dataGrid$1
+var common$1 = {
+    search: "Search",
+    yes: "yes",
+    no: "No",
+    confirm: "Confirm",
+    okay: "Okay",
+    cancel: "Cancel",
+    remove: "Remove",
+    edit: "Edit",
+    configs: "Configs",
+    noDataFound: "No data found!",
+    searching: "searching ...",
+    save: "Save",
+    "save-as": "Save As...",
+    title: "Title",
+    description: "Description",
+    name: "Name",
+    uniquename: "Unique Name",
+    size: "Size",
+    "add-item": "Add Item",
+    color: "Color",
+    display: "Display",
+    "min-value": "Min Value",
+    value: "Value",
+    "max-value": "Max Value",
+    "refresh-rate": "Refresh Rate",
+    refresh: "Refresh",
+    reload: "Reload",
+    condition: "Condition",
+    next: "Next",
+    prev: "Prev"
+};
+var dateTime$1 = {
+    weekdaysShort: {
+        sun: "Sun",
+        mon: "Mon",
+        tue: "Tue",
+        wed: "Wed",
+        thu: "Thu",
+        fri: "Fri",
+        sat: "Sat"
+    },
+    dayTime: {
+        am: "am",
+        pm: "pm",
+        m: "m",
+        a: "a",
+        p: "p"
+    },
+    today: "today",
+    duration: {
+        format_second: "{0} second(s)",
+        format_minute: "{0} minute(s)"
+    }
+};
+var queryBuilder$1 = {
+    contains: "contains",
+    "not-contains": "not-contains",
+    "contains-all": "contains-all",
+    "start-with": "start-with",
+    "end-with": "end-with",
+    equal: "equal",
+    "not-equal": "not-equal",
+    "null": "null",
+    "not-null": "not-null",
+    "greater-than": "greater-than",
+    gt: "greater-than",
+    "greater-than-equal": "greater-than-equal",
+    gte: "greater-than-equal",
+    "less-than": "less-than",
+    lt: "less-than",
+    "less-than-equal": "less-than-equal",
+    lte: "less-than-equal",
+    "true": "true",
+    "false": "false",
+    empty: "empty"
+};
+var validation$1 = {
+    messages: {
+        required: "This field is required!",
+        email: "Please enter a valid email address!",
+        phone: "Please enter a valid phone number!"
+    }
+};
+var dataGrid$1 = {
+    page: "page",
+    more: "more",
+    to: "To",
+    of: "Of",
+    next: "next",
+    last: "last",
+    first: "first",
+    previous: "previous",
+    loadingOoo: "Loading...",
+    selectAll: "selectAll",
+    searchOoo: "Search...",
+    blanks: "blanks",
+    filterOoo: "Filter...",
+    equals: "Equals",
+    notEqual: "NotEqual",
+    lessThan: "LessThan",
+    greaterThan: "GreaterThan",
+    lessThanOrEqual: "LessThanOrEqual",
+    greaterThanOrEqual: "GreaterThanOrEqual",
+    inRange: "InRange",
+    inRangeStart: "To",
+    inRangeEnd: "From",
+    contains: "Contains",
+    notContains: "NotContains",
+    startsWith: "Starts with",
+    endsWith: "Ends with",
+    andCondition: "AND",
+    orCondition: "OR",
+    applyFilter: "Apply",
+    resetFilter: "Reset",
+    clearFilter: "Clear",
+    group: "Group",
+    columns: "Columns",
+    filters: "Filters",
+    groups: "Groups",
+    values: "Values",
+    enabled: "Enabled",
+    pinColumn: "Pin Column",
+    groupBy: "Group by",
+    ungroupBy: "UnGroup by",
+    resetColumns: "ResetColumns",
+    expandAll: "ExpandAll",
+    collapseAll: "CollapseAll",
+    toolPanel: "ToolPanel",
+    "export": "Exporto",
+    csvExport: "csv Export",
+    excelExport: "Excel Export (.xlsx)",
+    excelXmlExport: "Excel Exporto (.xml)",
+    chartRange: "Chart Range",
+    columnChart: "Column",
+    groupedColumn: "Grouped",
+    stackedColumn: "Stacked",
+    normalizedColumn: "normalized Column",
+    barChart: "bar Chart",
+    groupedBar: "Grouped",
+    stackedBar: "Stacked",
+    normalizedBar: "normalized Bar",
+    pie: "Pie",
+    doughnut: "Doughnut",
+    line: "Line",
+    xyChart: "X Y (Scatter)",
+    scatter: "Scatter",
+    bubble: "Bubble",
+    areaChart: "Area",
+    area: "Area",
+    stackedArea: "Stacked",
+    normalizedArea: "100% Stacked",
+    histogramChart: "Histogram",
+    pinLeft: "Pin Left",
+    pinRight: "Pin Right",
+    noPin: "Dont Pin",
+    sum: "Sum",
+    min: "Min",
+    max: "Max",
+    none: "None",
+    count: "Count",
+    avg: "Average",
+    filteredRows: "Filtered",
+    selectedRows: "Selected",
+    totalRows: "Total Rows",
+    totalAndFilteredRows: "Rows",
+    copy: "Copy",
+    copyWithHeaders: "Copy With Headers",
+    ctrlC: "Ctrl C",
+    paste: "Paste",
+    ctrlV: "Ctrl V",
+    pivotChartTitle: "Pivot Chart",
+    rangeChartTitle: "Range Chart",
+    settings: "Settings",
+    data: "Data",
+    format: "Format",
+    categories: "Categories",
+    series: "Series",
+    xyValues: "X Y Values",
+    paired: "Paired Mode",
+    axis: "Axis",
+    color: "Color",
+    thickness: "Thickness",
+    xType: "X Type",
+    automatic: "Automatic",
+    category: "Category",
+    number: "Number",
+    time: "Time",
+    xRotation: "X Rotation",
+    yRotation: "Y Rotation",
+    ticks: "Ticks",
+    width: "Width",
+    length: "Length",
+    padding: "Padding",
+    chart: "Chart",
+    title: "Title",
+    background: "Background",
+    font: "Font",
+    top: "Top",
+    right: "Right",
+    bottom: "Bottom",
+    left: "Left",
+    labels: "Labels",
+    size: "Size",
+    minSize: "Minimum Size",
+    maxSize: "Maximum Size",
+    legend: "Legend",
+    position: "Position",
+    markerSize: "Marker Size",
+    markerStroke: "Marker Stroke",
+    markerPadding: "Marker Padding",
+    itemPaddingX: "Item Padding X",
+    itemPaddingY: "Item Padding Y",
+    strokeWidth: "Stroke Width",
+    offset: "Offset",
+    offsets: "Offsets",
+    tooltips: "Tooltips",
+    callout: "Callout",
+    markers: "Markers",
+    shadow: "Shadow",
+    blur: "Blur",
+    xOffset: "X Offset",
+    yOffset: "Y Offset",
+    lineWidth: "Line Width",
+    normal: "Normal",
+    bold: "Bold",
+    italic: "Italic",
+    boldItalic: "Bold Italic",
+    predefined: "Predefined",
+    fillOpacity: "Fill Opacity",
+    strokeOpacity: "Line Opacity",
+    histogramBinCount: "Bin Count",
+    columnGroup: "Column",
+    barGroup: "Bar",
+    pieGroup: "Pie",
+    lineGroup: "Line",
+    scatterGroup: "Scatter",
+    areaGroup: "Area",
+    histogramGroup: "Histogram",
+    groupedColumnTooltip: "Grouped",
+    stackedColumnTooltip: "Stacked",
+    normalizedColumnTooltip: "100% Stacked",
+    groupedBarTooltip: "Grouped",
+    stackedBarTooltip: "Stacked",
+    pieTooltip: "Pie",
+    doughnutTooltip: "Doughnut",
+    lineTooltip: "Line",
+    groupedAreaTooltip: "Grouped",
+    stackedAreaTooltip: "Stacked",
+    scatterTooltip: "Scatter",
+    bubbleTooltip: "Bubble",
+    histogramTooltip: "Histogram"
+};
+var en = {
+    common: common$1,
+    dateTime: dateTime$1,
+    queryBuilder: queryBuilder$1,
+    validation: validation$1,
+    dataGrid: dataGrid$1
 };
 
 var en$1 = /*#__PURE__*/Object.freeze({
@@ -1365,255 +1365,255 @@ var en$1 = /*#__PURE__*/Object.freeze({
     'default': en
 });
 
-var common = {
-    search: "جستجو",
-    yes: "بله",
-    no: "خیر",
-    confirm: "تایید",
-    okay: "تایید",
-    cancel: "انصراف",
-    remove: "حذف",
-    edit: "ویرایش",
-    configs: "پیکربندی",
-    noDataFound: "موردی یافت نشد!",
-    searching: "درحال جستجو ...",
-    "save-as": "ذخیره به عنوان ...",
-    title: "عنوان",
-    description: "توضیحات",
-    name: "نام",
-    uniquename: "نام شناسه یکتا",
-    size: "اندازه",
-    "add-item": "افزودن",
-    color: "رنگ",
-    display: "نمایش",
-    value: "مقدار",
-    "min-value": "مقدار کمینه",
-    "max-value": "مقدار بیشینه",
-    "refresh-rate": "نرخ بروز رسانی",
-    refresh: "بروز رسانی",
-    reload: "بارگزاری مجدد",
-    condition: "شرط",
-    next: "بعدی",
-    prev: "قبلی",
-    reset: "بازنشانی"
-};
-var dateTime = {
-    weekdaysShort: {
-        sun: "ی",
-        mon: "د",
-        tue: "س",
-        wed: "چ",
-        thu: "پ",
-        fri: "ج",
-        sat: "ش"
-    },
-    dayTime: {
-        am: "ق ظ",
-        pm: "ب ظُ",
-        m: ".ظ",
-        a: "ق",
-        p: "ب"
-    },
-    today: "امروز",
-    duration: {
-        format_second: "{0} ثانیه",
-        format_minute: "{0} دقیقه"
-    }
-};
-var queryBuilder = {
-    contains: "شامل",
-    "not-contains": "به غیر از",
-    "contains-all": "شامل همه",
-    "start-with": "شروع شود با",
-    "end-with": "پایان با",
-    equal: "برابر با",
-    "not-equal": "نا برابر با",
-    "null": " خالی باشد",
-    "not-null": "خالی نباشد",
-    "greater-than": "بزرگ تر",
-    gt: "بزرگ تر",
-    "greater-than-equal": "بزرگتر مساوی",
-    gte: "بزرگتر مساوی",
-    "less-than": "کوچکتر",
-    lt: "کوچکتر",
-    "less-than-equal": "کوچکتر مساوی",
-    lte: "کوچکتر مساوی",
-    "true": "true",
-    "false": "false"
-};
-var validation = {
-    messages: {
-        required: "مقدار این فیلد  الزامی می باشد!",
-        email: "این آدرس ایمیل معتبر نمی باشد!",
-        phone: "این شماره تلفن معتبر نمی باشد!"
-    }
-};
-var dataGrid = {
-    page: "صفحه",
-    more: "بیشتر",
-    to: "تا",
-    of: "از",
-    next: "بعدی",
-    last: "آخرین",
-    first: "اولین",
-    previous: "قبلی",
-    loadingOoo: "... لطفا منتظر بمانید",
-    selectAll: "انتخاب همه",
-    searchOoo: "جستجو ...",
-    blanks: "جای خالی",
-    filterOoo: "فیلتر ...",
-    equals: "برابر",
-    notEqual: "نابرابر",
-    lessThan: "کوچکتر از",
-    greaterThan: "بزرگتر از",
-    lessThanOrEqual: "کوچکتر مساوی",
-    greaterThanOrEqual: "بزرکتر مساوی",
-    inRange: "در محدوده",
-    inRangeStart: "تا",
-    inRangeEnd: "از",
-    contains: "شامل",
-    notContains: "شامل نمی شود",
-    startsWith: "شروع شود با",
-    endsWith: "پایان با",
-    andCondition: "و",
-    orCondition: "یا",
-    applyFilter: "اعمال",
-    resetFilter: "تنظیم مجدد فیلتر",
-    clearFilter: "پاک کردن فیلتر",
-    group: "گروه",
-    columns: "ستون ها",
-    filters: "فیاتر ها",
-    groups: "گروه ها ",
-    values: "مقدار ها",
-    enabled: "فعال شده",
-    pinColumn: "سنجاق",
-    groupBy: "دسته بندی بر اساس",
-    ungroupBy: "حذف دسته بندی",
-    resetColumns: "تنظیم مجدد ستون ها",
-    expandAll: "باز کردن همه",
-    collapseAll: "بستن همه",
-    toolPanel: "پنل ابزار",
-    "export": "خروجی",
-    csvExport: "csv خروجی",
-    excelExport: "خروجی اکسل (.xlsx)",
-    excelXmlExport: "خروجی اکسل (.xml)",
-    chartRange: "محدوده نمودار",
-    columnChart: "ستون",
-    groupedColumn: "دسته بندی شده",
-    stackedColumn: "انباشته",
-    normalizedColumn: "ستون نرمال",
-    barChart: "نمودار میله ای",
-    groupedBar: "دسته بندی شده",
-    stackedBar: "انباشته",
-    normalizedBar: "نوار ",
-    pie: "پای",
-    doughnut: "Doughnut",
-    line: "خط",
-    xyChart: "X Y (پراکندگی)",
-    scatter: "پراکندگی",
-    bubble: "حباب",
-    areaChart: "حوزه",
-    area: "حوزه",
-    stackedArea: "انباشته ",
-    normalizedArea: "100% انباشته",
-    histogramChart: "هیستوگرام",
-    pinLeft: "سنجاق چپ",
-    pinRight: "سنجاق راست",
-    noPin: "حذف سنجاق",
-    sum: "مجموع",
-    min: "مینیمم",
-    max: "ماکزیمم",
-    none: "هیچ",
-    count: "شمردن",
-    avg: "میانگین",
-    filteredRows: "فیلتر شده",
-    selectedRows: "انتخاب شده",
-    totalRows: "مجموع ردیف ها",
-    totalAndFilteredRows: "سطر ها",
-    copy: "کپی",
-    copyWithHeaders: "کپی با هدر ها",
-    ctrlC: "Ctrl C",
-    paste: "جایگزینی",
-    ctrlV: "Ctrl V",
-    pivotChartTitle: "نمودار محوری",
-    rangeChartTitle: "نمودار محدوده",
-    settings: "تنظیمات",
-    data: "تاریخ",
-    format: "قالب",
-    categories: "دسته بندی ها",
-    series: "Series",
-    xyValues: "X Y مقادیر",
-    paired: "حالت زوج",
-    axis: "محور",
-    color: "رنگ",
-    thickness: "ضخامت",
-    xType: "X Type",
-    automatic: "خودکار",
-    category: "دسته بندی",
-    number: "عدد",
-    time: "زمان",
-    xRotation: "X چرخش",
-    yRotation: "Y چرخش",
-    ticks: "نمادها",
-    width: "عرض",
-    length: "طول",
-    padding: "لایه گزاری",
-    chart: "جدول",
-    title: "عنوان",
-    background: "زمینه",
-    font: "فونت",
-    top: "بالا",
-    right: "راست",
-    bottom: "پایین",
-    left: "چپ",
-    labels: "برچسب",
-    size: "اندازه",
-    minSize: "حداقل اندازه",
-    maxSize: "بیشترین اندازه",
-    position: "موقعیت",
-    markerSize: "اندازه نشانگر",
-    callout: "فراخوان",
-    markers: "نشانه گرها",
-    shadow: "سایه",
-    blur: "محو شدن",
-    xOffset: "X انحراف",
-    yOffset: "Y انحراف",
-    lineWidth: "عرض خط",
-    normal: "نرمال",
-    italic: "Italic",
-    boldItalic: "Bold Italic",
-    predefined: "Predefined",
-    fillOpacity: "Fill Opacity",
-    strokeOpacity: "Line Opacity",
-    histogramBinCount: "Bin Count",
-    columnGroup: "ستون",
-    barGroup: "Bar",
-    pieGroup: "Pie",
-    lineGroup: "خط",
-    areaGroup: "حوزه",
-    histogramGroup: "هیستوگرام",
-    groupedColumnTooltip: "دسته بندی شده",
-    stackedColumnTooltip: "Stacked",
-    normalizedColumnTooltip: "100% Stacked",
-    groupedBarTooltip: "دسته بندی شده",
-    stackedBarTooltip: "Stacked",
-    pieTooltip: "Pie",
-    doughnutTooltip: "Doughnut",
-    lineTooltip: "خط",
-    groupedAreaTooltip: "گروه بندی شده",
-    stackedAreaTooltip: "Stacked",
-    scatterTooltip: "Scatter",
-    bubbleTooltip: "حباب",
-    histogramTooltip: "هیستوگرام",
-    autosizeThiscolumn: "تنظیم اندازه ستون ",
-    autosizeAllColumns: "تنظیم اندازه همه ستون ها"
-};
-var fa = {
-    common: common,
-    dateTime: dateTime,
-    queryBuilder: queryBuilder,
-    validation: validation,
-    dataGrid: dataGrid
+var common = {
+    search: "جستجو",
+    yes: "بله",
+    no: "خیر",
+    confirm: "تایید",
+    okay: "تایید",
+    cancel: "انصراف",
+    remove: "حذف",
+    edit: "ویرایش",
+    configs: "پیکربندی",
+    noDataFound: "موردی یافت نشد!",
+    searching: "درحال جستجو ...",
+    "save-as": "ذخیره به عنوان ...",
+    title: "عنوان",
+    description: "توضیحات",
+    name: "نام",
+    uniquename: "نام شناسه یکتا",
+    size: "اندازه",
+    "add-item": "افزودن",
+    color: "رنگ",
+    display: "نمایش",
+    value: "مقدار",
+    "min-value": "مقدار کمینه",
+    "max-value": "مقدار بیشینه",
+    "refresh-rate": "نرخ بروز رسانی",
+    refresh: "بروز رسانی",
+    reload: "بارگزاری مجدد",
+    condition: "شرط",
+    next: "بعدی",
+    prev: "قبلی",
+    reset: "بازنشانی"
+};
+var dateTime = {
+    weekdaysShort: {
+        sun: "ی",
+        mon: "د",
+        tue: "س",
+        wed: "چ",
+        thu: "پ",
+        fri: "ج",
+        sat: "ش"
+    },
+    dayTime: {
+        am: "ق ظ",
+        pm: "ب ظُ",
+        m: ".ظ",
+        a: "ق",
+        p: "ب"
+    },
+    today: "امروز",
+    duration: {
+        format_second: "{0} ثانیه",
+        format_minute: "{0} دقیقه"
+    }
+};
+var queryBuilder = {
+    contains: "شامل",
+    "not-contains": "به غیر از",
+    "contains-all": "شامل همه",
+    "start-with": "شروع شود با",
+    "end-with": "پایان با",
+    equal: "برابر با",
+    "not-equal": "نا برابر با",
+    "null": " خالی باشد",
+    "not-null": "خالی نباشد",
+    "greater-than": "بزرگ تر",
+    gt: "بزرگ تر",
+    "greater-than-equal": "بزرگتر مساوی",
+    gte: "بزرگتر مساوی",
+    "less-than": "کوچکتر",
+    lt: "کوچکتر",
+    "less-than-equal": "کوچکتر مساوی",
+    lte: "کوچکتر مساوی",
+    "true": "true",
+    "false": "false"
+};
+var validation = {
+    messages: {
+        required: "مقدار این فیلد  الزامی می باشد!",
+        email: "این آدرس ایمیل معتبر نمی باشد!",
+        phone: "این شماره تلفن معتبر نمی باشد!"
+    }
+};
+var dataGrid = {
+    page: "صفحه",
+    more: "بیشتر",
+    to: "تا",
+    of: "از",
+    next: "بعدی",
+    last: "آخرین",
+    first: "اولین",
+    previous: "قبلی",
+    loadingOoo: "... لطفا منتظر بمانید",
+    selectAll: "انتخاب همه",
+    searchOoo: "جستجو ...",
+    blanks: "جای خالی",
+    filterOoo: "فیلتر ...",
+    equals: "برابر",
+    notEqual: "نابرابر",
+    lessThan: "کوچکتر از",
+    greaterThan: "بزرگتر از",
+    lessThanOrEqual: "کوچکتر مساوی",
+    greaterThanOrEqual: "بزرکتر مساوی",
+    inRange: "در محدوده",
+    inRangeStart: "تا",
+    inRangeEnd: "از",
+    contains: "شامل",
+    notContains: "شامل نمی شود",
+    startsWith: "شروع شود با",
+    endsWith: "پایان با",
+    andCondition: "و",
+    orCondition: "یا",
+    applyFilter: "اعمال",
+    resetFilter: "تنظیم مجدد فیلتر",
+    clearFilter: "پاک کردن فیلتر",
+    group: "گروه",
+    columns: "ستون ها",
+    filters: "فیاتر ها",
+    groups: "گروه ها ",
+    values: "مقدار ها",
+    enabled: "فعال شده",
+    pinColumn: "سنجاق",
+    groupBy: "دسته بندی بر اساس",
+    ungroupBy: "حذف دسته بندی",
+    resetColumns: "تنظیم مجدد ستون ها",
+    expandAll: "باز کردن همه",
+    collapseAll: "بستن همه",
+    toolPanel: "پنل ابزار",
+    "export": "خروجی",
+    csvExport: "csv خروجی",
+    excelExport: "خروجی اکسل (.xlsx)",
+    excelXmlExport: "خروجی اکسل (.xml)",
+    chartRange: "محدوده نمودار",
+    columnChart: "ستون",
+    groupedColumn: "دسته بندی شده",
+    stackedColumn: "انباشته",
+    normalizedColumn: "ستون نرمال",
+    barChart: "نمودار میله ای",
+    groupedBar: "دسته بندی شده",
+    stackedBar: "انباشته",
+    normalizedBar: "نوار ",
+    pie: "پای",
+    doughnut: "Doughnut",
+    line: "خط",
+    xyChart: "X Y (پراکندگی)",
+    scatter: "پراکندگی",
+    bubble: "حباب",
+    areaChart: "حوزه",
+    area: "حوزه",
+    stackedArea: "انباشته ",
+    normalizedArea: "100% انباشته",
+    histogramChart: "هیستوگرام",
+    pinLeft: "سنجاق چپ",
+    pinRight: "سنجاق راست",
+    noPin: "حذف سنجاق",
+    sum: "مجموع",
+    min: "مینیمم",
+    max: "ماکزیمم",
+    none: "هیچ",
+    count: "شمردن",
+    avg: "میانگین",
+    filteredRows: "فیلتر شده",
+    selectedRows: "انتخاب شده",
+    totalRows: "مجموع ردیف ها",
+    totalAndFilteredRows: "سطر ها",
+    copy: "کپی",
+    copyWithHeaders: "کپی با هدر ها",
+    ctrlC: "Ctrl C",
+    paste: "جایگزینی",
+    ctrlV: "Ctrl V",
+    pivotChartTitle: "نمودار محوری",
+    rangeChartTitle: "نمودار محدوده",
+    settings: "تنظیمات",
+    data: "تاریخ",
+    format: "قالب",
+    categories: "دسته بندی ها",
+    series: "Series",
+    xyValues: "X Y مقادیر",
+    paired: "حالت زوج",
+    axis: "محور",
+    color: "رنگ",
+    thickness: "ضخامت",
+    xType: "X Type",
+    automatic: "خودکار",
+    category: "دسته بندی",
+    number: "عدد",
+    time: "زمان",
+    xRotation: "X چرخش",
+    yRotation: "Y چرخش",
+    ticks: "نمادها",
+    width: "عرض",
+    length: "طول",
+    padding: "لایه گزاری",
+    chart: "جدول",
+    title: "عنوان",
+    background: "زمینه",
+    font: "فونت",
+    top: "بالا",
+    right: "راست",
+    bottom: "پایین",
+    left: "چپ",
+    labels: "برچسب",
+    size: "اندازه",
+    minSize: "حداقل اندازه",
+    maxSize: "بیشترین اندازه",
+    position: "موقعیت",
+    markerSize: "اندازه نشانگر",
+    callout: "فراخوان",
+    markers: "نشانه گرها",
+    shadow: "سایه",
+    blur: "محو شدن",
+    xOffset: "X انحراف",
+    yOffset: "Y انحراف",
+    lineWidth: "عرض خط",
+    normal: "نرمال",
+    italic: "Italic",
+    boldItalic: "Bold Italic",
+    predefined: "Predefined",
+    fillOpacity: "Fill Opacity",
+    strokeOpacity: "Line Opacity",
+    histogramBinCount: "Bin Count",
+    columnGroup: "ستون",
+    barGroup: "Bar",
+    pieGroup: "Pie",
+    lineGroup: "خط",
+    areaGroup: "حوزه",
+    histogramGroup: "هیستوگرام",
+    groupedColumnTooltip: "دسته بندی شده",
+    stackedColumnTooltip: "Stacked",
+    normalizedColumnTooltip: "100% Stacked",
+    groupedBarTooltip: "دسته بندی شده",
+    stackedBarTooltip: "Stacked",
+    pieTooltip: "Pie",
+    doughnutTooltip: "Doughnut",
+    lineTooltip: "خط",
+    groupedAreaTooltip: "گروه بندی شده",
+    stackedAreaTooltip: "Stacked",
+    scatterTooltip: "Scatter",
+    bubbleTooltip: "حباب",
+    histogramTooltip: "هیستوگرام",
+    autosizeThiscolumn: "تنظیم اندازه ستون ",
+    autosizeAllColumns: "تنظیم اندازه همه ستون ها"
+};
+var fa = {
+    common: common,
+    dateTime: dateTime,
+    queryBuilder: queryBuilder,
+    validation: validation,
+    dataGrid: dataGrid
 };
 
 var fa$1 = /*#__PURE__*/Object.freeze({
@@ -1626,648 +1626,648 @@ var fa$1 = /*#__PURE__*/Object.freeze({
     'default': fa
 });
 
-class AXTranslatorModule {
-    constructor() {
-        AXTranslator.load('en', en$1);
-        AXTranslator.load('fa', fa$1);
-    }
-}
-AXTranslatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXTranslatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
-AXTranslatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, providers: [], imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [AXTranslatorPipe],
-                    declarations: [AXTranslatorPipe],
-                    providers: [],
-                }]
+class AXTranslatorModule {
+    constructor() {
+        AXTranslator.load('en', en$1);
+        AXTranslator.load('fa', fa$1);
+    }
+}
+AXTranslatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXTranslatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
+AXTranslatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXTranslatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXTranslatorPipe],
+                    declarations: [AXTranslatorPipe],
+                    providers: [],
+                }]
         }], ctorParameters: function () { return []; } });
 
-// @dynamic
-class AXArrayUtil {
-    static pickRandom(array) {
-        return array[Math.floor(Math.random() * array.length)];
-    }
-    static insert(array, index, ...rest) {
-        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));
-        return array;
-    }
-    static range(min, max) {
-        return new Array(max - min).fill(1).map((d, i) => i);
-    }
-    static filter(array, filters) {
-        if (filters == null || filters.length === 0) {
-            return array;
-        }
-        const lamda = (item) => {
-            let result = true;
-            for (const key in filters) {
-                if (filters.hasOwnProperty(key)) {
-                    const f = filters[key];
-                    if (f !== 'AND') {
-                        const vals = [];
-                        const mt = f.field.match(/\[\:(.*?)\]/);
-                        if (mt && mt.length > 1) {
-                            const p1 = f.field.replace(mt[0], '');
-                            const p2 = mt[1];
-                            const prop = AXFetchProp(item, p1);
-                            if (prop instanceof Array && prop.length) {
-                                vals.push(...prop.map(m => (AXFetchProp(m, p2))));
-                            }
-                            else {
-                                result = false;
-                            }
-                        }
-                        else {
-                            vals.push(AXFetchProp(item, f.field));
-                        }
-                        for (const j in vals) {
-                            if (vals.hasOwnProperty(j)) {
-                                let v1 = vals[j];
-                                const v2 = f.value;
-                                if (f.dataType === 'string') {
-                                    v1 = v1.toString();
-                                    switch (f.condition) {
-                                        case 'equal':
-                                            result = (v1 && v2) && v1.toLowerCase() === v2.toLowerCase();
-                                            break;
-                                        case 'not-equal':
-                                            result = !((v1 && v2) && v1.toLowerCase() === v2.toLowerCase());
-                                            break;
-                                        case 'contains':
-                                            result = ((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
-                                            break;
-                                        case 'not-contains':
-                                            result = !((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
-                                            break;
-                                        case 'start-with':
-                                            result = ((v1 && v2) && (v1.toLowerCase().startsWith(v2.toLowerCase())));
-                                            break;
-                                        case 'end-with':
-                                            result = ((v1 && v2) && (v1.toLowerCase().endsWith(v2.toLowerCase())));
-                                            break;
-                                        case 'is-empty':
-                                            result = v1 == null || v1 === undefined;
-                                            break;
-                                        case 'is-not-empty':
-                                            result = !(v1 == null || v1 === undefined);
-                                            break;
-                                        default:
-                                            console.error('The condition is not defined');
-                                            result = false;
-                                    }
-                                }
-                                else if (f.dataType === 'date') {
-                                }
-                                else if (f.dataType === 'number') {
-                                    v1 = Number(v1);
-                                    switch (f.condition) {
-                                        case 'equal':
-                                            result = v1 === v2;
-                                            break;
-                                        case 'not-equal':
-                                            result = v1 !== v2;
-                                            break;
-                                        case 'contains':
-                                            result = v2 && v2 instanceof Array && v2.includes(v1);
-                                            break;
-                                        case 'less-than':
-                                            result = v1 < v2;
-                                            break;
-                                        case 'less-than-equal':
-                                            result = v1 <= v2;
-                                            break;
-                                        case 'greater-than':
-                                            result = v1 > v2;
-                                            break;
-                                        case 'greater-than-equal':
-                                            result = v1 >= v2;
-                                            break;
-                                        case 'is-empty':
-                                            result = v1 == null || v1 === undefined;
-                                            break;
-                                        case 'is-not-empty':
-                                            result = !(v1 == null || v1 === undefined);
-                                            break;
-                                        default:
-                                            console.error('The condition is not defined');
-                                            result = false;
-                                    }
-                                }
-                                else {
-                                    console.error('The datatype is not supported');
-                                    result = false;
-                                }
-                                if (result) {
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    if (!result) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        return array.filter(lamda);
-    }
+// @dynamic
+class AXArrayUtil {
+    static pickRandom(array) {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+    static insert(array, index, ...rest) {
+        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));
+        return array;
+    }
+    static range(min, max) {
+        return new Array(max - min).fill(1).map((d, i) => i);
+    }
+    static filter(array, filters) {
+        if (filters == null || filters.length === 0) {
+            return array;
+        }
+        const lamda = (item) => {
+            let result = true;
+            for (const key in filters) {
+                if (filters.hasOwnProperty(key)) {
+                    const f = filters[key];
+                    if (f !== 'AND') {
+                        const vals = [];
+                        const mt = f.field.match(/\[\:(.*?)\]/);
+                        if (mt && mt.length > 1) {
+                            const p1 = f.field.replace(mt[0], '');
+                            const p2 = mt[1];
+                            const prop = AXFetchProp(item, p1);
+                            if (prop instanceof Array && prop.length) {
+                                vals.push(...prop.map(m => (AXFetchProp(m, p2))));
+                            }
+                            else {
+                                result = false;
+                            }
+                        }
+                        else {
+                            vals.push(AXFetchProp(item, f.field));
+                        }
+                        for (const j in vals) {
+                            if (vals.hasOwnProperty(j)) {
+                                let v1 = vals[j];
+                                const v2 = f.value;
+                                if (f.dataType === 'string') {
+                                    v1 = v1.toString();
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = (v1 && v2) && v1.toLowerCase() === v2.toLowerCase();
+                                            break;
+                                        case 'not-equal':
+                                            result = !((v1 && v2) && v1.toLowerCase() === v2.toLowerCase());
+                                            break;
+                                        case 'contains':
+                                            result = ((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'not-contains':
+                                            result = !((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'start-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().startsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'end-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().endsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else if (f.dataType === 'date') {
+                                }
+                                else if (f.dataType === 'number') {
+                                    v1 = Number(v1);
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = v1 === v2;
+                                            break;
+                                        case 'not-equal':
+                                            result = v1 !== v2;
+                                            break;
+                                        case 'contains':
+                                            result = v2 && v2 instanceof Array && v2.includes(v1);
+                                            break;
+                                        case 'less-than':
+                                            result = v1 < v2;
+                                            break;
+                                        case 'less-than-equal':
+                                            result = v1 <= v2;
+                                            break;
+                                        case 'greater-than':
+                                            result = v1 > v2;
+                                            break;
+                                        case 'greater-than-equal':
+                                            result = v1 >= v2;
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else {
+                                    console.error('The datatype is not supported');
+                                    result = false;
+                                }
+                                if (result) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!result) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        return array.filter(lamda);
+    }
 }
 
-class AXMathUtil {
-    static randomRange(min, max) {
-        return Math.floor(Math.random() * (max - min + 1) + min);
-    }
+class AXMathUtil {
+    static randomRange(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
 }
 
-class AXPoint {
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-}
-class AXClientRec {
-    constructor(rec) {
-        this._left = rec.left;
-        this._top = rec.top;
-        this._width = rec.width;
-        this._height = rec.height;
-        this._right = this._left + this._width;
-        this._bottom = this._top + this._height;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get top() {
-        return this._top;
-    }
-    set top(v) {
-        this._top = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
-    }
-    get bottom() {
-        return this._bottom;
-    }
-    set bottom(v) {
-        this._bottom = v;
-    }
-    get width() {
-        return this._width;
-    }
-    set width(v) {
-        this._width = v;
-    }
-    get height() {
-        return this._height;
-    }
-    set height(v) {
-        this._height = v;
-    }
-    intersect(rec) {
-        return (this.left < rec.left + rec.width &&
-            this.left + this.width > rec.left &&
-            this.top < rec.top + rec.height &&
-            this.top + this.height > rec.top);
-    }
-}
-// @dynamic
-class AXHtmlUtil {
-    static getBoundingRectPoint(el, placement) {
-        const rec = el.getBoundingClientRect();
-        const width = el.offsetWidth;
-        const height = el.offsetHeight;
-        switch (placement) {
-            case 'top-start':
-                return new AXPoint(rec.left, rec.top);
-            case 'top-middle':
-                return new AXPoint(rec.left + (width / 2), rec.top);
-            case 'top-end':
-                return new AXPoint(rec.left + (width), rec.top);
-            case 'center-end':
-                return new AXPoint(rec.left + (width), rec.top + (height / 2));
-            case 'bottom-end':
-                return new AXPoint(rec.left + (width), rec.top + (height));
-            case 'bottom-middle':
-                return new AXPoint(rec.left + (width / 2), rec.top + (height));
-            case 'bottom-start':
-                return new AXPoint(rec.left, rec.top + (height));
-            case 'center-start':
-                return new AXPoint(rec.left, rec.top + (height / 2));
-            default:
-                return new AXPoint(rec.left + (width / 2), rec.top + (height));
-        }
-    }
-    static isInRecPoint(pos, rec) {
-        return pos.x >= rec.left && pos.x <= (rec.left + rec.width) && pos.y >= rec.top && (pos.y <= (rec.top + rec.height));
-    }
-    // static isOverLap(rec1: AXClientRecCtor, rec2: AXClientRecCtor): boolean {
-    //   const r1: AXClientRec = new AXClientRec(rec1);
-    //   const r2: AXClientRec = new AXClientRec(rec2);
-    //   return ;
-    // }
-    static isInElementBound(pos, element) {
-        const elBound = element.getBoundingClientRect();
-        return AXHtmlUtil.isInRecPoint(pos, {
-            left: elBound.left,
-            width: elBound.width,
-            top: elBound.top,
-            height: elBound.height
-        });
-    }
-    static getDimensions() {
-        let winW = 630;
-        let winH = 460;
-        if (document.body && document.body.offsetWidth) {
-            winW = document.body.offsetWidth;
-            winH = document.body.offsetHeight;
-        }
-        if (document.compatMode === 'CSS1Compat' && document.documentElement && document.documentElement.offsetWidth) {
-            winW = document.documentElement.offsetWidth;
-            winH = document.documentElement.offsetHeight;
-        }
-        if (window.innerWidth && window.innerHeight) {
-            winW = window.innerWidth;
-            winH = window.innerHeight;
-        }
-        return { width: winW, height: winH };
-    }
-    static getOffsetRight(elem) {
-        let element = elem;
-        const width = element.offsetWidth;
-        let right = 0;
-        while (element.offsetParent) {
-            right += element.offsetLeft;
-            element = element.offsetParent;
-        }
-        right += element.offsetLeft;
-        right = AXHtmlUtil.getDimensions().width - right;
-        right -= width;
-        return right;
-    }
-    static getUID() {
-        return 'el-' + AXMathUtil.randomRange(1000000000, 9999999999).toString();
-    }
-    static getRelatedPosition(source, placement, target, alignment) {
-        const result = { x: 0, y: 0 };
-        const sourcePos = AXHtmlUtil.getBoundingRectPoint(source, placement);
-        let top = 0;
-        let left = 0;
-        switch (alignment) {
-            case 'top-start':
-                top = sourcePos.y;
-                left = sourcePos.x;
-                break;
-            case 'top-middle':
-                top = sourcePos.y;
-                left = sourcePos.x - target.offsetWidth / 2;
-                break;
-            case 'top-end':
-                top = sourcePos.y;
-                left = sourcePos.x - target.offsetWidth;
-                break;
-            case 'center-end':
-                top = sourcePos.y - target.offsetHeight / 2;
-                left = sourcePos.x - target.offsetWidth;
-                break;
-            case 'bottom-end':
-                top = sourcePos.y - target.offsetHeight;
-                left = sourcePos.x - target.offsetWidth;
-                break;
-            case 'bottom-middle':
-                top = sourcePos.y - target.offsetHeight;
-                left = sourcePos.x - target.offsetWidth / 2;
-                break;
-            case 'bottom-start':
-                top = sourcePos.y - target.offsetHeight;
-                left = sourcePos.x;
-                break;
-            case 'center-start':
-                top = sourcePos.y - target.offsetHeight / 2;
-                left = sourcePos.x;
-                break;
-        }
-        result.y = top;
-        result.x = left;
-        return result;
-    }
-    static collision(a, b) {
-        const ac = a.getBoundingClientRect();
-        const bc = b.getBoundingClientRect();
-        if (ac.left < bc.left + bc.width && ac.left + ac.width > bc.left &&
-            ac.top < bc.top + bc.height && ac.top + ac.height > bc.top) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
+class AXPoint {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+class AXClientRec {
+    constructor(rec) {
+        this._left = rec.left;
+        this._top = rec.top;
+        this._width = rec.width;
+        this._height = rec.height;
+        this._right = this._left + this._width;
+        this._bottom = this._top + this._height;
+    }
+    get left() {
+        return this._left;
+    }
+    set left(v) {
+        this._left = v;
+    }
+    get top() {
+        return this._top;
+    }
+    set top(v) {
+        this._top = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        this._right = v;
+    }
+    get bottom() {
+        return this._bottom;
+    }
+    set bottom(v) {
+        this._bottom = v;
+    }
+    get width() {
+        return this._width;
+    }
+    set width(v) {
+        this._width = v;
+    }
+    get height() {
+        return this._height;
+    }
+    set height(v) {
+        this._height = v;
+    }
+    intersect(rec) {
+        return (this.left < rec.left + rec.width &&
+            this.left + this.width > rec.left &&
+            this.top < rec.top + rec.height &&
+            this.top + this.height > rec.top);
+    }
+}
+// @dynamic
+class AXHtmlUtil {
+    static getBoundingRectPoint(el, placement) {
+        const rec = el.getBoundingClientRect();
+        const width = el.offsetWidth;
+        const height = el.offsetHeight;
+        switch (placement) {
+            case 'top-start':
+                return new AXPoint(rec.left, rec.top);
+            case 'top-middle':
+                return new AXPoint(rec.left + (width / 2), rec.top);
+            case 'top-end':
+                return new AXPoint(rec.left + (width), rec.top);
+            case 'center-end':
+                return new AXPoint(rec.left + (width), rec.top + (height / 2));
+            case 'bottom-end':
+                return new AXPoint(rec.left + (width), rec.top + (height));
+            case 'bottom-middle':
+                return new AXPoint(rec.left + (width / 2), rec.top + (height));
+            case 'bottom-start':
+                return new AXPoint(rec.left, rec.top + (height));
+            case 'center-start':
+                return new AXPoint(rec.left, rec.top + (height / 2));
+            default:
+                return new AXPoint(rec.left + (width / 2), rec.top + (height));
+        }
+    }
+    static isInRecPoint(pos, rec) {
+        return pos.x >= rec.left && pos.x <= (rec.left + rec.width) && pos.y >= rec.top && (pos.y <= (rec.top + rec.height));
+    }
+    // static isOverLap(rec1: AXClientRecCtor, rec2: AXClientRecCtor): boolean {
+    //   const r1: AXClientRec = new AXClientRec(rec1);
+    //   const r2: AXClientRec = new AXClientRec(rec2);
+    //   return ;
+    // }
+    static isInElementBound(pos, element) {
+        const elBound = element.getBoundingClientRect();
+        return AXHtmlUtil.isInRecPoint(pos, {
+            left: elBound.left,
+            width: elBound.width,
+            top: elBound.top,
+            height: elBound.height
+        });
+    }
+    static getDimensions() {
+        let winW = 630;
+        let winH = 460;
+        if (document.body && document.body.offsetWidth) {
+            winW = document.body.offsetWidth;
+            winH = document.body.offsetHeight;
+        }
+        if (document.compatMode === 'CSS1Compat' && document.documentElement && document.documentElement.offsetWidth) {
+            winW = document.documentElement.offsetWidth;
+            winH = document.documentElement.offsetHeight;
+        }
+        if (window.innerWidth && window.innerHeight) {
+            winW = window.innerWidth;
+            winH = window.innerHeight;
+        }
+        return { width: winW, height: winH };
+    }
+    static getOffsetRight(elem) {
+        let element = elem;
+        const width = element.offsetWidth;
+        let right = 0;
+        while (element.offsetParent) {
+            right += element.offsetLeft;
+            element = element.offsetParent;
+        }
+        right += element.offsetLeft;
+        right = AXHtmlUtil.getDimensions().width - right;
+        right -= width;
+        return right;
+    }
+    static getUID() {
+        return 'el-' + AXMathUtil.randomRange(1000000000, 9999999999).toString();
+    }
+    static getRelatedPosition(source, placement, target, alignment) {
+        const result = { x: 0, y: 0 };
+        const sourcePos = AXHtmlUtil.getBoundingRectPoint(source, placement);
+        let top = 0;
+        let left = 0;
+        switch (alignment) {
+            case 'top-start':
+                top = sourcePos.y;
+                left = sourcePos.x;
+                break;
+            case 'top-middle':
+                top = sourcePos.y;
+                left = sourcePos.x - target.offsetWidth / 2;
+                break;
+            case 'top-end':
+                top = sourcePos.y;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'center-end':
+                top = sourcePos.y - target.offsetHeight / 2;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'bottom-end':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'bottom-middle':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x - target.offsetWidth / 2;
+                break;
+            case 'bottom-start':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x;
+                break;
+            case 'center-start':
+                top = sourcePos.y - target.offsetHeight / 2;
+                left = sourcePos.x;
+                break;
+        }
+        result.y = top;
+        result.x = left;
+        return result;
+    }
+    static collision(a, b) {
+        const ac = a.getBoundingClientRect();
+        const bc = b.getBoundingClientRect();
+        if (ac.left < bc.left + bc.width && ac.left + ac.width > bc.left &&
+            ac.top < bc.top + bc.height && ac.top + ac.height > bc.top) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 }
 
-class AXHtmlModule {
-}
-AXHtmlModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXHtmlModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, declarations: [AXHtmlToTextPipe], imports: [CommonModule], exports: [AXHtmlToTextPipe] });
-AXHtmlModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, providers: [], imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [AXHtmlToTextPipe],
-                    imports: [CommonModule],
-                    exports: [AXHtmlToTextPipe],
-                    providers: []
-                }]
+class AXHtmlModule {
+}
+AXHtmlModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXHtmlModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, declarations: [AXHtmlToTextPipe], imports: [CommonModule], exports: [AXHtmlToTextPipe] });
+AXHtmlModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, providers: [], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHtmlModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXHtmlToTextPipe],
+                    imports: [CommonModule],
+                    exports: [AXHtmlToTextPipe],
+                    providers: []
+                }]
         }] });
 
-class AXOnDemandPreloadService {
-    constructor() {
-        this.subject = new Subject();
-        this.tmp = AXHtmlUtil.getUID();
-    }
-    startPreload(routePath) {
-        const slices = [];
-        this.subject.next(routePath);
-    }
-}
-AXOnDemandPreloadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXOnDemandPreloadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService, decorators: [{
-            type: Injectable
+class AXOnDemandPreloadService {
+    constructor() {
+        this.subject = new Subject();
+        this.tmp = AXHtmlUtil.getUID();
+    }
+    startPreload(routePath) {
+        const slices = [];
+        this.subject.next(routePath);
+    }
+}
+AXOnDemandPreloadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXOnDemandPreloadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXOnDemandPreloadService, decorators: [{
+            type: Injectable
         }], ctorParameters: function () { return []; } });
 
-class AXRenderService {
-    constructor(appRef, router, componentFactoryResolver, compiler, modulePreloadService, injector) {
-        this.appRef = appRef;
-        this.router = router;
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.compiler = compiler;
-        this.modulePreloadService = modulePreloadService;
-        this.injector = injector;
-    }
-    appendComponent(componentClass, options = {}, location) {
-        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(componentClass);
-        const componentRef = componentFactory.create(this.injector);
-        this.appRef.attachView(componentRef.hostView);
-        Object.assign(componentRef.instance, options);
-        //
-        const domElem = componentRef.hostView.rootNodes[0];
-        componentRef.onDestroy(() => {
-            this.appRef.detachView(componentRef.hostView);
-        });
-        if (location) {
-            location.appendChild(domElem);
-        }
-        else {
-            document.body.appendChild(domElem);
-        }
-        setTimeout(() => {
-            componentRef.changeDetectorRef.detectChanges();
-        }, 0);
-        return componentRef;
-    }
-    findLoadedComponentByRoute(path, timeoutTime = 10) {
-        const delay = 200;
-        const loop = timeoutTime * 1000 / delay;
-        return new Promise((resolve, reject) => {
-            let found = null;
-            let preload = false;
-            const theLoop = (i) => {
-                setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    found = yield this._findLoadedComponentByRoute(path);
-                    if (--i && found == null) {
-                        if (!preload) {
-                            this.modulePreloadService.startPreload(path);
-                            preload = true;
-                        }
-                        theLoop(i);
-                    }
-                    else if (found) {
-                        resolve(found);
-                    }
-                    else {
-                        reject();
-                    }
-                }), delay);
-            };
-            theLoop(loop);
-        });
-    }
-    _findLoadedComponentByRoute(search) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let found = null;
-            const f = (children, parentPath) => {
-                for (const p in children) {
-                    if (children.hasOwnProperty(p)) {
-                        const route = children[p];
-                        const pp = (route.path != '' && route.path != null) ? parentPath + '/' + route.path : parentPath;
-                        if (pp == search && !route._loadedConfig && route.component) {
-                            found = route;
-                            return;
-                        }
-                        else if (route._loadedConfig || route.children) {
-                            f(route.children || route._loadedConfig.routes, pp);
-                        }
-                    }
-                }
-            };
-            for (const p in this.router.config) {
-                if (this.router.config.hasOwnProperty(p)) {
-                    const route = this.router.config[p];
-                    if (route.path === search && route.component) {
-                        found = route;
-                    }
-                    else if (route['_loadedConfig'] || route.children) {
-                        f(route.children || route['_loadedConfig'].routes, route.path);
-                    }
-                    if (found)
-                        break;
-                }
-            }
-            return found;
-        });
-    }
-}
-AXRenderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, deps: [{ token: i0.ApplicationRef }, { token: i1$1.Router }, { token: i0.ComponentFactoryResolver }, { token: i0.Compiler }, { token: AXOnDemandPreloadService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-AXRenderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+class AXRenderService {
+    constructor(appRef, router, componentFactoryResolver, compiler, modulePreloadService, injector) {
+        this.appRef = appRef;
+        this.router = router;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.compiler = compiler;
+        this.modulePreloadService = modulePreloadService;
+        this.injector = injector;
+    }
+    appendComponent(componentClass, options = {}, location) {
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(componentClass);
+        const componentRef = componentFactory.create(this.injector);
+        this.appRef.attachView(componentRef.hostView);
+        Object.assign(componentRef.instance, options);
+        //
+        const domElem = componentRef.hostView.rootNodes[0];
+        componentRef.onDestroy(() => {
+            this.appRef.detachView(componentRef.hostView);
+        });
+        if (location) {
+            location.appendChild(domElem);
+        }
+        else {
+            document.body.appendChild(domElem);
+        }
+        setTimeout(() => {
+            componentRef.changeDetectorRef.detectChanges();
+        }, 0);
+        return componentRef;
+    }
+    findLoadedComponentByRoute(path, timeoutTime = 10) {
+        const delay = 200;
+        const loop = timeoutTime * 1000 / delay;
+        return new Promise((resolve, reject) => {
+            let found = null;
+            let preload = false;
+            const theLoop = (i) => {
+                setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    found = yield this._findLoadedComponentByRoute(path);
+                    if (--i && found == null) {
+                        if (!preload) {
+                            this.modulePreloadService.startPreload(path);
+                            preload = true;
+                        }
+                        theLoop(i);
+                    }
+                    else if (found) {
+                        resolve(found);
+                    }
+                    else {
+                        reject();
+                    }
+                }), delay);
+            };
+            theLoop(loop);
+        });
+    }
+    _findLoadedComponentByRoute(search) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let found = null;
+            const f = (children, parentPath) => {
+                for (const p in children) {
+                    if (children.hasOwnProperty(p)) {
+                        const route = children[p];
+                        const pp = (route.path != '' && route.path != null) ? parentPath + '/' + route.path : parentPath;
+                        if (pp == search && !route._loadedConfig && route.component) {
+                            found = route;
+                            return;
+                        }
+                        else if (route._loadedConfig || route.children) {
+                            f(route.children || route._loadedConfig.routes, pp);
+                        }
+                    }
+                }
+            };
+            for (const p in this.router.config) {
+                if (this.router.config.hasOwnProperty(p)) {
+                    const route = this.router.config[p];
+                    if (route.path === search && route.component) {
+                        found = route;
+                    }
+                    else if (route['_loadedConfig'] || route.children) {
+                        f(route.children || route['_loadedConfig'].routes, route.path);
+                    }
+                    if (found)
+                        break;
+                }
+            }
+            return found;
+        });
+    }
+}
+AXRenderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, deps: [{ token: i0.ApplicationRef }, { token: i1$1.Router }, { token: i0.ComponentFactoryResolver }, { token: i0.Compiler }, { token: AXOnDemandPreloadService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AXRenderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i0.ApplicationRef }, { type: i1$1.Router }, { type: i0.ComponentFactoryResolver }, { type: i0.Compiler }, { type: AXOnDemandPreloadService }, { type: i0.Injector }]; } });
 
-// @dynamic
-function getOnDemandPreloadServiceFactory() {
-    return new AXOnDemandPreloadService();
-}
-class AXRenderingModule {
-}
-AXRenderingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXRenderingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule });
-AXRenderingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, providers: [
-        {
-            provide: AXOnDemandPreloadService,
-            useFactory: getOnDemandPreloadServiceFactory
-        },
-        AXRenderService
-    ], imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        {
-                            provide: AXOnDemandPreloadService,
-                            useFactory: getOnDemandPreloadServiceFactory
-                        },
-                        AXRenderService
-                    ],
-                }]
+// @dynamic
+function getOnDemandPreloadServiceFactory() {
+    return new AXOnDemandPreloadService();
+}
+class AXRenderingModule {
+}
+AXRenderingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXRenderingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule });
+AXRenderingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, providers: [
+        {
+            provide: AXOnDemandPreloadService,
+            useFactory: getOnDemandPreloadServiceFactory
+        },
+        AXRenderService
+    ], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXRenderingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXOnDemandPreloadService,
+                            useFactory: getOnDemandPreloadServiceFactory
+                        },
+                        AXRenderService
+                    ],
+                }]
         }] });
 
-class AXHorizontalScrollDirective {
-    constructor(el) {
-        this.el = el;
-        this.scrollValue = 40;
-    }
-    onMouseWheel(e) {
-        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
-        this.el.nativeElement.scrollLeft -= delta * this.scrollValue;
-    }
-}
-AXHorizontalScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHorizontalScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-AXHorizontalScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: AXHorizontalScrollDirective, selector: "[horizontalScroll]", inputs: { scrollValue: ["horizontalScroll", "scrollValue"] }, host: { listeners: { "wheel": "onMouseWheel($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHorizontalScrollDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // tslint:disable-next-line: directive-selector
-                    selector: '[horizontalScroll]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollValue: [{
-                type: Input,
-                args: ['horizontalScroll']
-            }], onMouseWheel: [{
-                type: HostListener,
-                args: ['wheel', ['$event']]
-            }] } });
-class AXVerticalScrollDirective {
-    constructor(el) {
-        this.el = el;
-        this.scrollValue = 40;
-    }
-    onMouseWheel(e) {
-        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
-        this.el.nativeElement.scrollTop -= delta * this.scrollValue;
-    }
-}
-AXVerticalScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXVerticalScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-AXVerticalScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: AXVerticalScrollDirective, selector: "[verticalScroll]", inputs: { scrollValue: ["verticalScroll", "scrollValue"] }, host: { listeners: { "wheel": "onMouseWheel($event)" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXVerticalScrollDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    // tslint:disable-next-line: directive-selector
-                    selector: '[verticalScroll]'
-                }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollValue: [{
-                type: Input,
-                args: ['verticalScroll']
-            }], onMouseWheel: [{
-                type: HostListener,
-                args: ['wheel', ['$event']]
+class AXHorizontalScrollDirective {
+    constructor(el) {
+        this.el = el;
+        this.scrollValue = 40;
+    }
+    onMouseWheel(e) {
+        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
+        this.el.nativeElement.scrollLeft -= delta * this.scrollValue;
+    }
+}
+AXHorizontalScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHorizontalScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AXHorizontalScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: AXHorizontalScrollDirective, selector: "[horizontalScroll]", inputs: { scrollValue: ["horizontalScroll", "scrollValue"] }, host: { listeners: { "wheel": "onMouseWheel($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXHorizontalScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // tslint:disable-next-line: directive-selector
+                    selector: '[horizontalScroll]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollValue: [{
+                type: Input,
+                args: ['horizontalScroll']
+            }], onMouseWheel: [{
+                type: HostListener,
+                args: ['wheel', ['$event']]
+            }] } });
+class AXVerticalScrollDirective {
+    constructor(el) {
+        this.el = el;
+        this.scrollValue = 40;
+    }
+    onMouseWheel(e) {
+        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
+        this.el.nativeElement.scrollTop -= delta * this.scrollValue;
+    }
+}
+AXVerticalScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXVerticalScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AXVerticalScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: AXVerticalScrollDirective, selector: "[verticalScroll]", inputs: { scrollValue: ["verticalScroll", "scrollValue"] }, host: { listeners: { "wheel": "onMouseWheel($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXVerticalScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // tslint:disable-next-line: directive-selector
+                    selector: '[verticalScroll]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollValue: [{
+                type: Input,
+                args: ['verticalScroll']
+            }], onMouseWheel: [{
+                type: HostListener,
+                args: ['wheel', ['$event']]
             }] } });
 
-class AXScrollModule {
-}
-AXScrollModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXScrollModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective], imports: [CommonModule], exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective] });
-AXScrollModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, providers: [], imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
-                    imports: [CommonModule],
-                    exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
-                    providers: []
-                }]
+class AXScrollModule {
+}
+AXScrollModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXScrollModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective], imports: [CommonModule], exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective] });
+AXScrollModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, providers: [], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXScrollModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
+                    imports: [CommonModule],
+                    exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
+                    providers: []
+                }]
         }] });
 
-// export class AXSeparatorPipe2 implements PipeTransform {
-//   transform(value: any) {
-//     if (value) {
-//       return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-//     } else {
-//       return '0';
-//     }
-//   }
-// }
-class AXSeparatorPipe {
-    transform(value, currency = '', decimal = 0, locale = AXConfig.get('layout.rtl') ? 'fa' : 'en') {
-        return (new Intl.NumberFormat(locale, {
-            minimumFractionDigits: 0,
-            maximumFractionDigits: decimal
-        }).format(Number(value)) + (currency != '' ? ' ' + currency : ''));
-    }
-}
-AXSeparatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXSeparatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, name: "separator" });
-AXSeparatorPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'separator' }]
-        }, {
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
+// export class AXSeparatorPipe2 implements PipeTransform {
+//   transform(value: any) {
+//     if (value) {
+//       return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+//     } else {
+//       return '0';
+//     }
+//   }
+// }
+class AXSeparatorPipe {
+    transform(value, currency = '', decimal = 0, locale = AXConfig.get('layout.rtl') ? 'fa' : 'en') {
+        return (new Intl.NumberFormat(locale, {
+            minimumFractionDigits: 0,
+            maximumFractionDigits: decimal
+        }).format(Number(value)) + (currency != '' ? ' ' + currency : ''));
+    }
+}
+AXSeparatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXSeparatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, name: "separator" });
+AXSeparatorPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'separator' }]
+        }, {
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
         }] });
 
-class AXSeparatorModule {
-}
-AXSeparatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXSeparatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, declarations: [AXSeparatorPipe], imports: [CommonModule], exports: [AXSeparatorPipe] });
-AXSeparatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, providers: [], imports: [[CommonModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [AXSeparatorPipe],
-                    imports: [CommonModule],
-                    exports: [AXSeparatorPipe],
-                    providers: []
-                }]
+class AXSeparatorModule {
+}
+AXSeparatorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXSeparatorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, declarations: [AXSeparatorPipe], imports: [CommonModule], exports: [AXSeparatorPipe] });
+AXSeparatorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, providers: [], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXSeparatorModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXSeparatorPipe],
+                    imports: [CommonModule],
+                    exports: [AXSeparatorPipe],
+                    providers: []
+                }]
         }] });
 
-const PIPES = [AXDateTimePipe];
-const MODULES = [AXScrollModule, AXTranslatorModule];
-const SERVICES = [AXEventService,
-    AXStorageService
-];
-class AXCoreModule {
-}
-AXCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, declarations: [AXDateTimePipe], imports: [AXScrollModule, AXTranslatorModule], exports: [AXDateTimePipe] });
-AXCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, providers: [...SERVICES], imports: [[...MODULES]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [...PIPES],
-                    imports: [...MODULES],
-                    exports: [...PIPES],
-                    providers: [...SERVICES]
-                }]
+const PIPES = [AXDateTimePipe];
+const MODULES = [AXScrollModule, AXTranslatorModule];
+const SERVICES = [AXEventService,
+    AXStorageService
+];
+class AXCoreModule {
+}
+AXCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, declarations: [AXDateTimePipe], imports: [AXScrollModule, AXTranslatorModule], exports: [AXDateTimePipe] });
+AXCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, providers: [...SERVICES], imports: [[...MODULES]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...PIPES],
+                    imports: [...MODULES],
+                    exports: [...PIPES],
+                    providers: [...SERVICES]
+                }]
         }] });
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { AXArrayUtil, AXBaseMenuItem, AXBasePageComponent, AXButtonItem, AXCalendarMonth, AXCheckItem, AXClientRec, AXColorUtil, AXConfig, AXCoreModule, AXDateTime, AXDateTimePipe, AXDateTimeRange, AXErrorModule, AXErrorService, AXEventService, AXFetchProp, AXHorizontalScrollDirective, AXHtmlModule, AXHtmlToTextPipe, AXHtmlUtil, AXHttpModule, AXHttpService, AXMathUtil, AXMenuItem, AXNavigator, AXObjectUtil, AXOnDemandPreloadService, AXPlatform, AXPlatformEvent, AXPoint, AXPromise, AXRenderService, AXRenderingModule, AXScrollModule, AXSelectItem, AXSeparatorModule, AXSeparatorPipe, AXStorageService, AXTranslator, AXTranslatorModule, AXTranslatorPipe, AXTranslatorService, AXVerticalScrollDirective, AX_ERROR_DISPLAY_INTERCEPTOR, AX_HTTP_EVENT_INTERCEPTOR, HttpResult, getOnDemandPreloadServiceFactory, getPropByPath, setPropByPath, testUserAgent };