@acorex/core 3.0.1 → 5.0.1

package/fesm2015/acorex-core.js

@@ -1,60 +1,8 @@
-import * as moment_ from 'jalali-moment';
+import * as i0 from '@angular/core';
+import { Pipe, NgModule, Injectable } from '@angular/core';
+import * as i1 from '@angular/platform-browser';
 import { Subject } from 'rxjs';
-import { EventEmitter, InjectionToken, Injector, ɵɵdefineInjectable, ɵɵinject, INJECTOR, Injectable, NgModule, Pipe, ApplicationRef, ComponentFactoryResolver, ElementRef, Input, HostListener, Directive } from '@angular/core';
-import { __decorate, __metadata } from 'tslib';
-import { CommonModule } from '@angular/common';
-import { HttpHeaders, HttpParams, HttpClient, HttpClientModule } from '@angular/common/http';
 import merge from 'lodash-es/merge';
-import { Router } 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;
-    }
-}
 
 // @dynamic
 class AXObjectUtil {
@@ -93,51 +41,93 @@ class AXObjectUtil {
         }
         throw new Error('Unable to copy obj! Its type isn\'t supported.');
     }
-}
-function AXFetchProp(obj, prop) {
-    if (typeof obj === 'undefined') {
-        return false;
+    static fetchProp(obj, prop) {
+        if (typeof obj === 'undefined') {
+            return false;
+        }
+        const index = prop.indexOf('.');
+        if (index > -1) {
+            return AXObjectUtil.fetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+        }
+        return obj[prop];
+    }
+    static 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;
     }
-    const index = prop.indexOf('.');
-    if (index > -1) {
-        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+    static 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; // Return the top-level object to allow chaining
     }
-    return obj[prop];
-}
-function getPropByPath(obj, path, defaultVal) {
-    path = path
-        .replace(/\[/g, '.')
-        .replace(/]/g, '')
-        .split('.');
-    path.forEach((level) => {
-        if (obj) {
-            obj = obj[level];
+}
+
+class AXSafePipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value, type) {
+        if (value == null || value == undefined || value == '')
+            return null;
+        switch (type) {
+            case 'html': return this.sanitizer.bypassSecurityTrustHtml(value);
+            case 'style': return this.sanitizer.bypassSecurityTrustStyle(value);
+            case 'script': return this.sanitizer.bypassSecurityTrustScript(value);
+            case 'url': return this.sanitizer.bypassSecurityTrustUrl(value);
+            case 'resourceUrl': return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+            default: throw new Error(`Invalid safe type specified: ${type}`);
         }
-    });
-    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; // Return the top-level object to allow chaining
-}
+AXSafePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+AXSafePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, name: "safe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXSafePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safe',
+                    pure: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+
+class AXCoreModule {
+}
+AXCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, declarations: [AXSafePipe], exports: [AXSafePipe] });
+AXCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXSafePipe],
+                    declarations: [AXSafePipe],
+                    providers: [],
+                }]
+        }] });
 
 // @dynamic
 class AXConfig {
@@ -146,7 +136,7 @@ class AXConfig {
     }
     static set(arg1, arg2) {
         if (arg1 && typeof arg1 == 'string') {
-            setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXObjectUtil.setPropByPath(AXConfig.dataModel, arg1, arg2);
             AXConfig.dataChangeSubject.next(AXConfig.dataModel);
             return;
         }
@@ -159,285 +149,167 @@ class AXConfig {
             return AXConfig.dataChangeSubject.asObservable();
         }
     }
-    static get(path) {
-        return getPropByPath(AXConfig.dataModel, path);
+    static get(path, defaultValue) {
+        return AXObjectUtil.getPropByPath(AXConfig.dataModel, path) || defaultValue;
     }
 }
 AXConfig.dataModel = {};
 AXConfig.dataChangeSubject = new Subject();
 
-const moment = moment_;
+const AX_CALENDARS = [
+    {
+        name: 'gregorian',
+        type: 'GeorgianCalendar'
+    },
+    {
+        name: 'jalali',
+        type: 'JalaliCalendar'
+    }
+];
+/**
+ * Standard links:
+ * {@link Foo} or {@linkplain Foo} or [[Foo]]
+ *
+ * Code links: (Puts Foo inside <code> tags)
+ * {@linkcode Foo} or [[`Foo`]]
+ */
+// @dynamic
 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;
+    constructor(value = new Date(), calendar = AXConfig.get('dateTime.type') || 'gregorian') {
+        this._calendar =
+            typeof calendar == 'string'
+                ? eval(`new ${AX_CALENDARS.find((c) => c.name == calendar).type}()`)
+                : calendar;
         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') {
+    static convert(value, calendar = AXConfig.get('dateTime.type') || 'gregorian') {
         let date;
         if (typeof value === 'string' || value instanceof String) {
-            date = new AXDateTime(value, type);
+            date = new AXDateTime(value, calendar);
         }
         else if (value instanceof Date) {
-            date = new AXDateTime(value, type);
+            date = new AXDateTime(value, calendar);
         }
         else if (value instanceof AXDateTime) {
-            date = value;
+            date = new AXDateTime(value.date, calendar);
         }
         return date;
     }
+    /**
+ * This comment _supports_ [Markdown](https://marked.js.org/)
+ */
     get date() {
         return this._date;
     }
-    resolveUnit(unit) {
-        return this.type === 'jalali' ? 'j' + unit : unit;
+    get calendar() {
+        return this._calendar;
     }
     clone() {
-        return new AXDateTime(this.date, this.type);
+        return new AXDateTime(this.date, this.calendar.name());
     }
     get dayInMonth() {
-        return this._moment.date();
+        return this._calendar.dayInMonth(this.date);
     }
     get dayOfYear() {
-        return this._moment.dayOfYear();
+        return this._calendar.dayOfYear(this.date);
     }
     get dayInWeek() {
-        return this._moment.day();
+        return this._calendar.dayInWeek(this.date);
     }
     get hour() {
-        return this._moment.hour();
+        return this._date.getHours();
     }
     get minute() {
-        return this._moment.minute();
+        return this._date.getMinutes();
     }
     get second() {
-        return this._moment.second();
+        return this._date.getSeconds();
     }
     get year() {
-        return this._moment.year();
+        return this._calendar.year(this.date);
     }
     get monthOfYear() {
-        return this._moment.month();
+        return this._calendar.monthOfYear(this.date);
     }
     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);
+    add(unit, amount) {
+        return this._calendar.add(this.date, unit, amount);
     }
     set(unit = 'day', value) {
-        return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
+        return this._calendar.set(this.date, unit, value);
     }
-    duration(end, unit = 'days') {
-        const duration = moment.duration(this._moment.diff(end._moment));
-        return Math.round(duration.as(unit));
+    duration(end, unit = 'day') {
+        const range = new AXDateTimeRange(this, AXDateTime.convert(end, this.calendar.name()));
+        return range.duration();
     }
     startOf(unit = 'day') {
-        return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
+        return this._calendar.startOf(this.date, unit);
     }
     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);
+        return this._calendar.endOf(this.date, unit);
+    }
+    format(format = AXConfig.get('dateTime.shortDateFormat') ||
+        'DDD, dd MMM yyyy') {
+        format = format.replace('ss', this.pad(this.date.getSeconds(), 2));
+        format = format.replace('s', this.date.getSeconds().toString());
+        format = format.replace('dd', this.pad(this.calendar.dayInMonth(this.date), 2));
+        format = format.replace('d', this.calendar.dayInMonth(this.date).toString());
+        format = format.replace('mm', this.pad(this.date.getMinutes(), 2));
+        format = format.replace('m', this.date.getMinutes().toString());
+        format = format.replace('MMMM', this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1]);
+        format = format.replace('MMM', this.calendar.monthShortNames[this.calendar.monthOfYear(this.date) - 1]);
+        format = format.replace('MM', this.pad(this.calendar.monthOfYear(this.date), 2));
+        format = format.replace(/M(?![ao])/, this.calendar.monthOfYear(this.date).toString());
+        format = format.replace('DDDD', this.calendar.dayNames[this.calendar.dayInWeek(this.date) - 1]);
+        format = format.replace('DDD', this.calendar.dayShortNames[this.calendar.dayInWeek(this.date) - 1]);
+        format = format.replace(/D(?!e)/, this.calendar.dayNames[this.calendar.dayInWeek(this.date) - 1].substring(0, 3));
+        format = format.replace('yyyy', this.calendar.year(this.date).toString());
+        format = format.replace('YYYY', this.calendar.year(this.date).toString());
+        format = format.replace('yy', this.calendar.year(this.date).toString().substring(2));
+        format = format.replace('YY', this.calendar.year(this.date).toString().substring(2));
+        format = format.replace('HH', this.pad(this.date.getHours(), 2));
+        format = format.replace('H', this.date.getHours().toString());
+        return format;
+    }
+    pad(n, width, z = '0') {
+        n = n + '';
+        return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
     }
     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) {
-        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;
-        }
+        return this.compaire(value, unit) == 0;
     }
     compaire(value, unit = 'day') {
-        if (this._moment.isSame(moment(value.date), this.resolveUnit(unit))) {
+        // TODO:
+        const val = AXDateTime.convert(value);
+        if (this.date == val.date) {
             return 0;
         }
-        else if (this._moment.isAfter(moment(value.date), this.resolveUnit(unit))) {
+        else if (this.date > val.date) {
             return 1;
         }
         else {
             return -1;
         }
     }
-    toISOString() {
-        return this._date.toISOString();
+    convert(calendar) {
+        return AXDateTime.convert(this, calendar);
     }
 }
 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));
+        this.name = date.format('MMMM');
+        this.range = new AXDateTimeRange(new AXDateTime(date.startOf('month').date, date.calendar), new AXDateTime(date.endOf('month').date, date.calendar));
     }
     get range() {
         return this._range;
@@ -451,330 +323,81 @@ class AXDateTimeRange {
         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));
-        }
+    duration() {
+        const result = {
+            miliseconds: 0,
+            seconds: 0,
+            minutes: 0,
+            hours: 0,
+            days: 0,
+            months: 0,
+            years: 0,
+            total: {
+                miliseconds: 0,
+                seconds: 0,
+                minutes: 0,
+                hours: 0,
+                days: 0,
+                weeks: 0,
+                months: 0,
+                years: 0,
+            },
+        };
+        const one_second = 1000;
+        const one_min = one_second * 60;
+        const one_hour = one_min * 60;
+        const one_day = one_hour * 24;
+        const one_week = one_day * 7;
+        const one_year = 365.25 * one_day;
+        const one_month = one_year / 12;
+        const startTime = this.startTime.date.getTime();
+        const endTime = this.endTime.date.getTime();
+        const diff = Math.abs(endTime - startTime);
+        //
+        result.total.miliseconds = diff;
+        result.total.seconds = Number((diff / one_second).toFixed(2));
+        result.total.minutes = Number((diff / one_min).toFixed(2));
+        result.total.hours = Number((diff / one_hour).toFixed(2));
+        result.total.days = Number((diff / one_day).toFixed(2));
+        result.total.weeks = Number((diff / one_week).toFixed(2));
+        //
+        // let months = (this.endTime.year - this.startTime.year) * 12;
+        // months += this.endTime.monthOfYear - this.startTime.monthOfYear + 1;
+        // if (this.endTime.dayOfYear < this.startTime.dayOfYear) {
+        //     months--;
+        // }
+        // result.total.months = Math.abs(months);
+        // TODO: review
+        result.total.months = Number((diff / one_month).toFixed(2));
+        result.total.years = Number((diff / one_year).toFixed(2));
+        //
+        result.miliseconds = result.total.miliseconds % 1000;
+        result.seconds = Number((result.total.seconds % 60).toFixed(0));
+        result.minutes = Number((result.total.minutes % 60).toFixed(0));
+        result.hours = Number((result.total.hours % 24).toFixed(0));
+        // TODO: review
+        result.days = Number((result.total.days % 30.4).toFixed(0));
+        result.months = Number((result.total.months % 12).toFixed(0));
+        result.years = Number(result.total.years.toFixed(0));
         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);
+    enumurate(unit = 'day') {
+        // TODO: ??
+        return [];
     }
-    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 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 {
-}
-
-/**
- * @deprecated Use AXBasePageComponent from @acorex/components
- */
-class AXBasePageComponent {
-    constructor() {
-        this.onClosed = new EventEmitter();
-    }
-    close(data) {
-        this.onClosed.emit({
-            component: this,
-            data: data
-        });
-    }
-    onClosing(e) {
-    }
-    ngOnDestroy() {
-        this.onClosed.unsubscribe();
-    }
-}
-
-const AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken('ax.error');
-let AXErrorService = class AXErrorService {
-    constructor(injector) {
-        this.injector = injector;
-    }
-    handle(message) {
-        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
-        if (instance) {
-            instance.show(message);
-        }
-    }
-};
-AXErrorService.ctorParameters = () => [
-    { type: Injector }
-];
-AXErrorService.ɵprov = ɵɵdefineInjectable({ factory: function AXErrorService_Factory() { return new AXErrorService(ɵɵinject(INJECTOR)); }, token: AXErrorService, providedIn: "root" });
-AXErrorService = __decorate([
-    Injectable({ providedIn: 'root' }),
-    __metadata("design:paramtypes", [Injector])
-], AXErrorService);
-
-let AXErrorModule = class AXErrorModule {
-};
-AXErrorModule = __decorate([
-    NgModule({
-        declarations: [],
-        imports: [CommonModule],
-        exports: [],
-        providers: [AXErrorService],
-    })
-], AXErrorModule);
-
-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;
+    includes(value, unit = 'day') {
+        // TODO: ??
+        return true;
     }
 }
 
-// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
-// import { of, concat, throwError } from 'rxjs';
-let AXHttpService = 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.ctorParameters = () => [
-    { type: HttpClient },
-    { type: Injector }
-];
-AXHttpService = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [HttpClient, Injector])
-], AXHttpService);
-
-var AXHttpModule_1;
-let AXHttpModule = AXHttpModule_1 = class AXHttpModule {
-    static forRoot() {
-        return {
-            ngModule: AXHttpModule_1,
-            providers: [AXHttpService]
-        };
-    }
-};
-AXHttpModule = AXHttpModule_1 = __decorate([
-    NgModule({
-        declarations: [],
-        imports: [
-            CommonModule,
-            HttpClientModule
-        ],
-        exports: [HttpClientModule],
-        providers: [
-            AXHttpService
-        ]
-    })
-], AXHttpModule);
-
-let AXDateTimePipe = class AXDateTimePipe {
+class AXDateTimePipe {
     constructor() { }
-    transform(value, format) {
-        const date = AXDateTime.convert(value);
+    transform(value, format, calendar) {
         if (value == null) {
             return '';
         }
+        const date = value instanceof AXDateTime ? value.clone() : AXDateTime.convert(value, calendar);
         if (!format) {
             return date.toString();
         }
@@ -782,81 +405,172 @@ let AXDateTimePipe = class AXDateTimePipe {
             return date.format(format);
         }
     }
-};
-AXDateTimePipe = __decorate([
-    Pipe({ name: 'dt' }),
-    __metadata("design:paramtypes", [])
-], AXDateTimePipe);
-
-let AXHtmlToTextPipe = 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 = __decorate([
-    Pipe({ name: 'html2text' })
-], AXHtmlToTextPipe);
-
-let AXEventService = class AXEventService {
+}
+AXDateTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXDateTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, name: "axDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'axDate' }]
+        }], ctorParameters: function () { return []; } });
+
+class AXDateTimeModule {
+}
+AXDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], exports: [AXDateTimePipe] });
+AXDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXDateTimePipe],
+                    declarations: [AXDateTimePipe],
+                    providers: [],
+                }]
+        }] });
+
+class GeorgianCalendar {
     constructor() {
-        this.list = [];
-    }
-    broadcast(key, options) {
-        const d = this.list.find(c => c.key === key);
-        if (d) {
-            d.events.forEach(c => {
-                c(options);
-            });
+        this.monthNames = [
+            "January", "February", "March",
+            "April", "May", "June", "July",
+            "August", "September", "October",
+            "November", "December"
+        ];
+        this.monthShortNames = [
+            "Jan", "Feb", "Mar",
+            "Apr", "May", "Jun", "Jul",
+            "Aug", "Sep", "Oct",
+            "Nov", "Dec"
+        ];
+        this.dayNames = [
+            "Sunday", "Monday", "Tuesday", "Wednesday",
+            "Thursday", "Friday", "Saturday"
+        ];
+        this.dayShortNames = [
+            "Sun", "Mon", "Tue", "Wed",
+            "Thu", "Fri", "Sat"
+        ];
+    }
+    name() {
+        return 'gregorian';
+    }
+    dayInMonth(date) {
+        return date.getDate();
+    }
+    dayOfYear(date) {
+        const start = +new Date(date.getFullYear(), 0, 0);
+        const diff = +date - start;
+        const oneDay = 1000 * 60 * 60 * 24;
+        return Math.floor(diff / oneDay);
+    }
+    dayInWeek(date) {
+        return date.getDay() + 1;
+    }
+    year(date) {
+        return date.getFullYear();
+    }
+    monthOfYear(date) {
+        return date.getMonth() + 1;
+    }
+    add(date, unit, amount) {
+        let value = date.valueOf();
+        switch (unit) {
+            case 'second':
+                value += 1000 * amount;
+                break;
+            case 'minute':
+                value += 60000 * amount;
+                break;
+            case 'hour':
+                value += 3600000 * amount;
+                break;
+            case 'month':
+                const v = new Date(value);
+                var mo = date.getMonth();
+                var yr = date.getFullYear();
+                mo = (mo + amount) % 12;
+                if (0 > mo) {
+                    yr += (date.getMonth() + amount - mo - 12) / 12;
+                    mo += 12;
+                }
+                else
+                    yr += ((date.getMonth() + amount - mo) / 12);
+                v.setMonth(mo);
+                v.setFullYear(yr);
+                value = v.valueOf();
+                break;
+            case 'week':
+                value += 7 * 86400000 * amount;
+                break;
+            case 'year':
+                const yv = new Date(value);
+                yv.setFullYear(yv.getFullYear() + amount);
+                value = v.valueOf();
+                break;
+            case 'day':
+            default:
+                value += 86400000 * amount;
         }
+        return new AXDateTime(new Date(value), this.name());
     }
-    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);
+    set(date, unit, value) {
+        throw new Error("Method not implemented.");
     }
-    destroy(key, callback) {
-        const d = this.list.find(c => c.key === key);
-        if (d) {
-            d.events = [];
+    startOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 0);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 0, 0);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(0, 0, 0, 0);
+                return new AXDateTime(clone, this.name());
+            case "week":
+                const diff = clone.getDate() - clone.getDay() + (clone.getDay() === 0 ? -6 : 1);
+                clone.setDate(diff);
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "month":
+                clone.setDate(1);
+                return new AXDateTime(clone, this.name()).startOf('day');
+            case "year":
+                clone.setMonth(0);
+                clone.setDate(1);
+                return new AXDateTime(clone, this.name()).startOf('day');
+        }
+    }
+    endOf(date, unit) {
+        const clone = new Date(date.valueOf());
+        switch (unit) {
+            case 'second':
+                clone.setHours(clone.getHours(), clone.getMinutes(), clone.getSeconds(), 999);
+                return new AXDateTime(clone, this.name());
+            case 'minute':
+                clone.setHours(clone.getHours(), clone.getMinutes(), 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'hour':
+                clone.setHours(clone.getHours(), 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            default:
+            case 'day':
+                clone.setHours(23, 59, 59, 999);
+                return new AXDateTime(clone, this.name());
+            case 'week':
+                return this.startOf(date, 'week').add('day', 6).endOf('day');
+            case 'month':
+                return new AXDateTime(new Date(date.getFullYear(), date.getMonth() + 1, 0), this.name()).endOf('day');
+            case "year":
+                clone.setMonth(11);
+                return new AXDateTime(clone, this.name()).endOf('month');
         }
     }
-};
-AXEventService.ɵprov = ɵɵdefineInjectable({ factory: function AXEventService_Factory() { return new AXEventService(); }, token: AXEventService, providedIn: "root" });
-AXEventService = __decorate([
-    Injectable({ providedIn: 'root' })
-], AXEventService);
-
-let AXNavigator = class AXNavigator {
-};
-AXNavigator = __decorate([
-    Injectable()
-], AXNavigator);
-
-let AXStorageService = class AXStorageService {
-    get(key) {
-        return localStorage.getItem(key);
-    }
-    set(key, value) {
-        localStorage.setItem(key, value);
-    }
-};
-AXStorageService = __decorate([
-    Injectable()
-], AXStorageService);
+}
 
 // @dynamic
 class AXTranslator {
@@ -875,1183 +589,163 @@ class AXTranslator {
         AXTranslator.lang = lang;
     }
     static get(key, lang) {
-        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+        return AXObjectUtil.getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
     }
 }
 AXTranslator.lang = 'en';
 AXTranslator.dataChangeSubject = new Subject();
 
-let AXTranslatorService = class AXTranslatorService {
-    load(lang, value) {
-        AXTranslator.load(lang, value);
-    }
-    use(lang) {
-        AXTranslator.use(lang);
-    }
-    get(key, lang) {
-        return AXTranslator.get(lang, lang);
-    }
-};
-AXTranslatorService.ɵprov = ɵɵdefineInjectable({ factory: function AXTranslatorService_Factory() { return new AXTranslatorService(); }, token: AXTranslatorService, providedIn: "platform" });
-AXTranslatorService = __decorate([
-    Injectable({ providedIn: 'platform' })
-], AXTranslatorService);
-
-let AXTranslatorPipe = 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));
-    //     });
-    // }
+class AXTranslatorPipe {
     transform(value, lang) {
         return AXTranslator.get(value, lang);
     }
-};
-AXTranslatorPipe = __decorate([
-    Pipe({ name: 'trans', pure: true }),
-    __metadata("design:paramtypes", [])
-], AXTranslatorPipe);
-
-var common = {
-	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",
-	condition: "Condition"
-};
-var dateTime = {
-	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 = {
-	contains: "contains",
-	"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 = {
-	messages: {
-		required: "This field is required!",
-		email: "Please enter a valid email address!",
-		phone: "Please enter a valid phone number!"
-	}
-};
-var dataGrid = {
-	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,
-	dateTime: dateTime,
-	queryBuilder: queryBuilder,
-	validation: validation,
-	dataGrid: dataGrid
-};
-
-var en$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    common: common,
-    dateTime: dateTime,
-    queryBuilder: queryBuilder,
-    validation: validation,
-    dataGrid: dataGrid,
-    'default': en
-});
-
-var common$1 = {
-	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": "نرخ بروز رسانی",
-	condition: "شرط"
-};
-var dateTime$1 = {
-	weekdaysShort: {
-		sun: "ی",
-		mon: "د",
-		tue: "س",
-		wed: "چ",
-		thu: "پ",
-		fri: "ج",
-		sat: "ش"
-	},
-	dayTime: {
-		am: "ق ظ",
-		pm: "ب ظُ",
-		m: ".ظ",
-		a: "ق",
-		p: "ب"
-	},
-	today: "امروز",
-	duration: {
-		format_second: "{0} ثانیه",
-		format_minute: "{0} دقیقه"
-	}
-};
-var queryBuilder$1 = {
-	contains: "شامل",
-	"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$1 = {
-	messages: {
-		required: "مقدار این فیلد  الزامی می باشد!",
-		email: "این آدرس ایمیل معتبر نمی باشد!",
-		phone: "این شماره تلفن معتبر نمی باشد!"
-	}
-};
-var dataGrid$1 = {
-	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$1,
-	dateTime: dateTime$1,
-	queryBuilder: queryBuilder$1,
-	validation: validation$1,
-	dataGrid: dataGrid$1
-};
-
-var fa$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    common: common$1,
-    dateTime: dateTime$1,
-    queryBuilder: queryBuilder$1,
-    validation: validation$1,
-    dataGrid: dataGrid$1,
-    'default': fa
-});
-
-let AXTranslatorModule = class AXTranslatorModule {
-    constructor() {
-        AXTranslator.load('en', en$1);
-        AXTranslator.load('fa', fa$1);
-    }
-};
-AXTranslatorModule = __decorate([
-    NgModule({
-        imports: [],
-        exports: [AXTranslatorPipe],
-        declarations: [AXTranslatorPipe],
-        providers: [],
-    }),
-    __metadata("design:paramtypes", [])
-], AXTranslatorModule);
-
-// @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 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);
-    }
+AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'trans', pure: true }]
+        }] });
+
+class AXTranslationModule {
 }
-// @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;
-        }
-    }
-}
-
-let AXHtmlModule = class AXHtmlModule {
+AXTranslationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AXTranslationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
+AXTranslationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXTranslationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [AXTranslatorPipe],
+                    declarations: [AXTranslatorPipe],
+                    providers: [],
+                }]
+        }] });
+
+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;
 };
-AXHtmlModule = __decorate([
-    NgModule({
-        declarations: [AXHtmlToTextPipe],
-        imports: [CommonModule],
-        exports: [AXHtmlToTextPipe],
-        providers: []
-    })
-], AXHtmlModule);
-
-let AXOnDemandPreloadService = class AXOnDemandPreloadService {
-    constructor() {
-        this.subject = new Subject();
-        this.tmp = AXHtmlUtil.getUID();
-    }
-    startPreload(routePath) {
-        const slices = [];
-        this.subject.next(routePath);
-        //console.log('ss', this.tmp);
-    }
+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);
 };
-AXOnDemandPreloadService = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [])
-], AXOnDemandPreloadService);
-
-let AXRenderService = class AXRenderService {
-    constructor(appRef, router, componentFactoryResolver, modulePreloadService, injector) {
-        this.appRef = appRef;
-        this.router = router;
-        this.componentFactoryResolver = componentFactoryResolver;
-        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(() => {
-                    found = 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) {
-        let found = null;
-        const f = (list, path) => {
-            for (const p in list) {
-                if (list.hasOwnProperty(p)) {
-                    const route = list[p];
-                    const pp = (route.path != '' && route.path != null) ? path + '/' + route.path : path;
-                    if (pp == search && !route._loadedConfig && route.component) {
-                        found = route;
-                        break;
-                    }
-                    else if (route._loadedConfig) {
-                        f(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']) {
-                    f(route['_loadedConfig'].routes, route.path);
-                }
-            }
-        }
-        return found;
-    }
+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);
 };
-AXRenderService.ctorParameters = () => [
-    { type: ApplicationRef },
-    { type: Router },
-    { type: ComponentFactoryResolver },
-    { type: AXOnDemandPreloadService },
-    { type: Injector }
-];
-AXRenderService.ɵprov = ɵɵdefineInjectable({ factory: function AXRenderService_Factory() { return new AXRenderService(ɵɵinject(ApplicationRef), ɵɵinject(Router), ɵɵinject(ComponentFactoryResolver), ɵɵinject(AXOnDemandPreloadService), ɵɵinject(INJECTOR)); }, token: AXRenderService, providedIn: "root" });
-AXRenderService = __decorate([
-    Injectable({ providedIn: 'root' }),
-    __metadata("design:paramtypes", [ApplicationRef,
-        Router,
-        ComponentFactoryResolver,
-        AXOnDemandPreloadService,
-        Injector])
-], AXRenderService);
-
-// @dynamic
-function getOnDemandPreloadServiceFactory() {
-    return new AXOnDemandPreloadService();
-}
-let AXRenderingModule = class AXRenderingModule {
+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)));
 };
-AXRenderingModule = __decorate([
-    NgModule({
-        imports: [],
-        exports: [],
-        declarations: [],
-        providers: [
-            {
-                provide: AXOnDemandPreloadService,
-                useFactory: getOnDemandPreloadServiceFactory
-            },
-            AXRenderService
-        ],
-    })
-], AXRenderingModule);
-
-let AXHorizontalScrollDirective = class AXHorizontalScrollDirective {
-    constructor(el) {
-        this.el = el;
-        this.scrollValue = 40;
+const isMobile = (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 PLATFORMS_MAP = {
+    'Android': isAndroid,
+    'iOS': isIOS,
+    'Desktop': isDesktop,
+    'Mobile': isMobile,
+    'Chrome': isChrome,
+    'Firefox': isFirefox,
+    'Safari': isSafari,
+    'Edge': isEdge,
+    'Opera': isOpera,
+    'Hybrid': isHybrid,
+    'PWA': isPWA,
+    'Electron': isElectron,
+};
+class AXPlatformEvent {
+}
+class AXPlatform {
+    constructor() {
+        this.resize = new Subject();
+        this.click = new Subject();
+        this.scroll = new Subject();
+        window.addEventListener('resize', (e) => {
+            this.resize.next({
+                nativeEvent: e,
+                source: this
+            });
+        });
+        document.addEventListener('click', (e) => {
+            this.click.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
+        document.addEventListener('scroll', (e) => {
+            this.scroll.next({
+                nativeEvent: e,
+                source: this
+            });
+        }, true);
     }
-    onMouseWheel(e) {
-        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
-        this.el.nativeElement.scrollLeft -= delta * this.scrollValue;
+    isRtl() {
+        return document.dir == 'rtl' || document.body.dir == 'rtl' || document.body.style.direction == 'rtl';
     }
-};
-AXHorizontalScrollDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-__decorate([
-    Input('horizontalScroll'),
-    __metadata("design:type", Object)
-], AXHorizontalScrollDirective.prototype, "scrollValue", void 0);
-__decorate([
-    HostListener('wheel', ['$event']),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], AXHorizontalScrollDirective.prototype, "onMouseWheel", null);
-AXHorizontalScrollDirective = __decorate([
-    Directive({
-        // tslint:disable-next-line: directive-selector
-        selector: '[horizontalScroll]'
-    }),
-    __metadata("design:paramtypes", [ElementRef])
-], AXHorizontalScrollDirective);
-let AXVerticalScrollDirective = 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;
+    isLandscape() {
+        return window.innerHeight < window.innerWidth;
     }
-};
-AXVerticalScrollDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-__decorate([
-    Input('verticalScroll'),
-    __metadata("design:type", Object)
-], AXVerticalScrollDirective.prototype, "scrollValue", void 0);
-__decorate([
-    HostListener('wheel', ['$event']),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], AXVerticalScrollDirective.prototype, "onMouseWheel", null);
-AXVerticalScrollDirective = __decorate([
-    Directive({
-        // tslint:disable-next-line: directive-selector
-        selector: '[verticalScroll]'
-    }),
-    __metadata("design:paramtypes", [ElementRef])
-], AXVerticalScrollDirective);
-
-let AXScrollModule = class AXScrollModule {
-};
-AXScrollModule = __decorate([
-    NgModule({
-        declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
-        imports: [CommonModule],
-        exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
-        providers: []
-    })
-], AXScrollModule);
-
-let AXSeparatorPipe = class AXSeparatorPipe {
-    transform(value) {
-        if (value) {
-            return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
-        }
-        else {
-            return '0';
-        }
+    isPortrate() {
+        return !this.isLandscape();
     }
-};
-AXSeparatorPipe.ɵprov = ɵɵdefineInjectable({ factory: function AXSeparatorPipe_Factory() { return new AXSeparatorPipe(); }, token: AXSeparatorPipe, providedIn: "root" });
-AXSeparatorPipe = __decorate([
-    Pipe({ name: 'separator' }),
-    Injectable({
-        providedIn: 'root'
-    })
-], AXSeparatorPipe);
-
-let AXSeparatorModule = class AXSeparatorModule {
-};
-AXSeparatorModule = __decorate([
-    NgModule({
-        declarations: [AXSeparatorPipe],
-        imports: [CommonModule],
-        exports: [AXSeparatorPipe],
-        providers: []
-    })
-], AXSeparatorModule);
+    is(name) {
+        return PLATFORMS_MAP[name](window) || false;
+    }
+}
+AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, providedIn: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AXPlatform, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'platform',
+                }]
+        }], ctorParameters: function () { return []; } });
 
-const PIPES = [AXDateTimePipe];
-const MODULES = [AXScrollModule, AXTranslatorModule];
-const SERVICES = [AXEventService,
-    AXStorageService
-];
-let AXCoreModule = class AXCoreModule {
-};
-AXCoreModule = __decorate([
-    NgModule({
-        declarations: [...PIPES],
-        imports: [...MODULES],
-        exports: [...PIPES],
-        providers: [...SERVICES]
-    })
-], AXCoreModule);
+/**
+ * Public API refrences of core libraries
+ * @module @acorex/core
+ */
 
 /**
  * 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, 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 };
+export { AXCalendarMonth, AXConfig, AXCoreModule, AXDateTime, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXObjectUtil, AXPlatform, AXPlatformEvent, AXSafePipe, AXTranslationModule, AXTranslator, AXTranslatorPipe, AX_CALENDARS, GeorgianCalendar, testUserAgent };
 //# sourceMappingURL=acorex-core.js.map