@acorex/core 5.1.1 → 5.1.5

package/fesm2015/acorex-core.mjs

@@ -1,11 +1,63 @@
+import moment from 'jalali-moment';
+import { Subject, fromEvent } from 'rxjs';
 import * as i0 from '@angular/core';
-import { Pipe, NgModule, Injectable, Inject } from '@angular/core';
-import * as i1 from '@angular/platform-browser';
-import _ from 'lodash';
-import { Subject } from 'rxjs';
-import { DOCUMENT } from '@angular/common';
-import { Observable } from 'rxjs/internal/Observable';
+import { EventEmitter, Injectable, InjectionToken, NgModule, Pipe, Directive, Input, HostListener } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpParams, HttpClientModule } from '@angular/common/http';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
 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;
+    }
+}
 
 // @dynamic
 class AXObjectUtil {
@@ -44,95 +96,51 @@ class AXObjectUtil {
         }
         throw new Error('Unable to copy obj! Its type isn\'t supported.');
     }
-}
-
-// @dynamic
-class AXDrawingUtil {
-    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;
-        }
-    }
-    static isInElementBound(pos, element) {
-        const elBound = element.getBoundingClientRect();
-        return AXDrawingUtil.isInRecPoint(pos, {
-            left: elBound.x,
-            width: elBound.width,
-            top: elBound.y,
-            height: elBound.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));
+}
+function AXFetchProp(obj, prop) {
+    if (typeof obj === 'undefined') {
+        return false;
     }
-}
-
-// @dynamic
-class AXStringUtil {
-    static getWordBoundsAtPosition(str, position) {
-        const isSpace = (c) => /[^a-zA-Z0-9]+/i.test(c);
-        let start = position - 1;
-        while (start >= 0 && !isSpace(str[start])) {
-            start -= 1;
-        }
-        start = Math.max(0, start + 1);
-        const leftSideString = str.slice(start).match(/[a-zA-Z0-9]+/i);
-        start += leftSideString.index;
-        let end = start + leftSideString[0].length;
-        return {
-            start,
-            end
-        };
+    const index = prop.indexOf('.');
+    if (index > -1) {
+        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
     }
-}
-
-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}`);
+    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;
 }
-AXSafePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXSafePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
-AXSafePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXSafePipe, name: "safe" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", 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: "13.3.2", ngImport: i0, type: AXCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXCoreModule, declarations: [AXSafePipe], exports: [AXSafePipe] });
-AXCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXCoreModule, providers: [], imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXCoreModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [AXSafePipe],
-                    declarations: [AXSafePipe],
-                    providers: [],
-                }]
-        }] });
+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 {
@@ -141,12 +149,12 @@ class AXConfig {
     }
     static set(arg1, arg2) {
         if (arg1 && typeof arg1 == 'string') {
-            _.set(AXConfig.dataModel, arg1, arg2);
+            setPropByPath(AXConfig.dataModel, arg1, arg2);
             AXConfig.dataChangeSubject.next(AXConfig.dataModel);
             return;
         }
         if (arg1 && typeof arg1 == 'object') {
-            _.merge(AXConfig.dataModel, arg1);
+            Object.assign(AXConfig.dataModel, arg1);
             AXConfig.dataChangeSubject.next(AXConfig.dataModel);
             return;
         }
@@ -154,213 +162,285 @@ class AXConfig {
             return AXConfig.dataChangeSubject.asObservable();
         }
     }
-    static get(path, defaultValue) {
-        return _.get(AXConfig.dataModel, path, defaultValue);
+    static get(path) {
+        return getPropByPath(AXConfig.dataModel, path);
     }
 }
 AXConfig.dataModel = {};
 AXConfig.dataChangeSubject = new Subject();
 
-// @dynamic
 class AXDateTime {
-    constructor(value = new Date(), calendar = AXConfig.get(`dateTime.calendar`)) {
-        this._formatKeys = {
-            ss: () => this.pad(this.date.getSeconds(), 2),
-            s: () => this.date.getSeconds().toString(),
-            //
-            dd: () => this.pad(this.calendar.dayOfMonth(this.date), 2),
-            d: () => this.calendar.dayOfMonth(this.date).toString(),
-            //
-            mm: () => this.pad(this.date.getMinutes(), 2),
-            m: () => this.date.getMinutes().toString(),
-            //
-            MMMM: () => this.calendar.monthNames[this.calendar.monthOfYear(this.date) - 1],
-            MMM: () => this.calendar.monthShortNames[this.calendar.monthOfYear(this.date) - 1],
-            MM: () => this.pad(this.calendar.monthOfYear(this.date), 2),
-            //
-            DDDD: () => this.calendar.dayNames[this.calendar.dayOfWeek(this.date) - 1],
-            DDD: () => this.calendar.dayShortNames[this.calendar.dayOfWeek(this.date) - 1],
-            //
-            yyyy: () => this.calendar.year(this.date).toString(),
-            YYYY: () => this.calendar.year(this.date).toString(),
-            yy: () => this.calendar.year(this.date).toString().substring(2),
-            YY: () => this.calendar.year(this.date).toString().substring(2),
-            //
-            HH: () => this.pad(this.date.getHours(), 2),
-            H: () => this.date.getHours().toString(),
-            //
-            hh: () => this.pad((this.date.getHours() % 12 || 12), 2),
-            h: () => (this.date.getHours() % 12 || 12).toString(),
-            //
-            A: () => (this.date.getHours() < 12) ? 'am' : 'pm',
-            a: () => (this.date.getHours() < 12) ? 'am' : 'pm',
-        };
-        this._calendar = AXDateTime.resolveCalendar(calendar);
+    // 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 {
-            //TODO: parse jalali
             this._date = new Date(value);
         }
+        this._moment = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
     }
-    static convert(value, calendar = AXConfig.get('dateTime.calendar')) {
+    static convert(value, type = AXConfig.get('dateTime.type') || 'gregorian') {
         let date;
         if (typeof value === 'string' || value instanceof String) {
-            date = new AXDateTime(value, calendar);
+            date = new AXDateTime(value, type);
         }
         else if (value instanceof Date) {
-            date = new AXDateTime(value, calendar);
+            date = new AXDateTime(value, type);
         }
         else if (value instanceof AXDateTime) {
-            date = new AXDateTime(value.date, calendar);
+            date = value;
         }
         return date;
     }
-    static from(value = {
-        calendar: AXConfig.get('dateTime.calendar'),
-        year: 1,
-        month: 1,
-        date: 1,
-        hours: 0,
-        minutes: 0,
-        seconds: 0,
-        ms: 0
-    }) {
-        // let date: AXDateTime = new AXDateTime(new Date(), value.calendar);
-        // date.set('year', value.year);
-        // date.set('month', value.month);
-        // date.set('day', value.date);
-        // date.set('hour', value.hours);
-        // date.set('minute', value.minutes);
-        // date.set('second', value.seconds);
-        // date.set('ms', value.ms);
-        return AXDateTime.resolveCalendar(value.calendar).create(value);
-    }
-    static resolveCalendar(calendar) {
-        return typeof calendar == 'string'
-            ? AXConfig.get(`dateTime.calendars.${calendar}`)
-            : calendar;
-    }
     get date() {
         return this._date;
     }
-    get calendar() {
-        return this._calendar;
+    resolveUnit(unit) {
+        return this.type === 'jalali' ? 'j' + unit : unit;
     }
     clone() {
-        return new AXDateTime(this.date, this.calendar);
+        return new AXDateTime(this.date, this.type);
     }
-    get dayOfMonth() {
-        return this._calendar.dayOfMonth(this.date);
+    get dayInMonth() {
+        return this._moment.date();
     }
     get dayOfYear() {
-        return this._calendar.dayOfYear(this.date);
+        return this._moment.dayOfYear();
     }
-    get dayOfWeek() {
-        return this._calendar.dayOfWeek(this.date);
+    get dayInWeek() {
+        return this._moment.day();
     }
     get hour() {
-        return this._date.getHours();
+        return this._moment.hour();
     }
     get minute() {
-        return this._date.getMinutes();
+        return this._moment.minute();
     }
     get second() {
-        return this._date.getSeconds();
+        return this._moment.second();
     }
     get year() {
-        return this._calendar.year(this.date);
+        return this._moment.year();
     }
     get monthOfYear() {
-        return this._calendar.monthOfYear(this.date);
-    }
-    get weekOfYear() {
-        return this._calendar.weekOfYear(this.date);
+        return this._moment.month();
     }
     get month() {
         return new AXCalendarMonth(this);
     }
-    add(unit, amount) {
-        return this._calendar.add(this.date, unit, amount);
+    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 this._calendar.set(this.date, unit, value);
+        return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
     }
-    duration(end, unit = 'day') {
-        const range = new AXDateTimeRange(this, AXDateTime.convert(end, this.calendar.name()));
-        return range.duration();
+    duration(end, unit = 'days') {
+        const duration = moment.duration(this._moment.diff(end._moment));
+        return Math.round(duration.as(unit));
     }
     startOf(unit = 'day') {
-        return this._calendar.startOf(this.date, unit);
+        return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
     }
     endOf(unit = 'day') {
-        return this._calendar.endOf(this.date, unit);
+        return new AXDateTime(moment(this.date).endOf(this.resolveUnit(unit)).toDate(), this.type);
     }
-    format(format = AXConfig.get('dateTime.shortDateFormat')) {
-        const re = new RegExp(_.orderBy(Object.keys(this._formatKeys), c => c.length, ['desc']).join("|"), "gi");
-        return format.replace(re, (matched) => {
-            return this._formatKeys[matched]();
-        });
-    }
-    pad(n, width, z = '0') {
-        n = n + '';
-        return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
+    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(format = AXConfig.get('dateTime.shortDateFormat')) {
-        return this.format(format);
+    toString() {
+        return this.format();
     }
     equal(value, unit = 'day') {
-        return this.compare(value, unit) == 0;
-    }
-    compare(value, unit = 'day') {
-        const val = AXDateTime.convert(value, this.calendar.name());
-        const func = (v1, v2) => {
-            if (v1 == v2) {
-                return 0;
-            }
-            else if (v1 > v2) {
-                return 1;
-            }
-            else {
-                return -1;
-            }
+        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'
         };
-        let p = 0;
+        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 'year':
-                return func(this.year, val.year);
-            case 'week':
-                p = this.compare(val, 'year');
-                return p == 0 ? func(this.weekOfYear, val.weekOfYear) : p;
-            case 'month':
-                p = this.compare(val, 'year');
-                return p == 0 ? func(this.monthOfYear, val.monthOfYear) : p;
-            case 'day':
-                p = this.compare(val, 'year');
-                return p == 0 ? func(this.dayOfYear, val.dayOfYear) : p;
-            case 'hour':
-                p = this.compare(val, 'day');
-                return p == 0 ? func(this.hour, val.hour) : p;
-            case 'minute':
-                p = this.compare(val, 'hour');
-                return p == 0 ? func(this.minute, val.minute) : p;
-            case 'second':
-                p = this.compare(val, 'minute');
-                return p == 0 ? func(this.second, val.second) : p;
-            default:
-                return func(this.date.getTime(), val.date.getTime());
+            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;
         }
     }
-    convert(calendar) {
-        return AXDateTime.convert(this, calendar);
+    toISOString() {
+        return this._date.toISOString();
     }
 }
 class AXCalendarMonth {
     constructor(date) {
+        this._moment = moment(date.date);
         this.index = date.date.getMonth();
-        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));
+        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;
@@ -371,816 +451,337 @@ class AXCalendarMonth {
 }
 class AXDateTimeRange {
     constructor(startTime, endTime) {
-        this._startTime = startTime;
-        this._endTime = endTime;
-    }
-    get startTime() {
-        return this._startTime;
-    }
-    get endTime() {
-        return this._endTime;
-    }
-    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;
+        this.startTime = startTime;
+        this.endTime = endTime;
     }
-    enumurate(unit = 'day', amount = 1) {
-        // TODO: setptemper savingtime issue
-        const result = [];
-        let item = this._startTime.clone();
-        while (item.compare(this._endTime, unit) < 1) {
-            result.push(item);
-            item = item.add(unit, amount);
-        }
-        return result;
-    }
-    includes(value, unit = 'day') {
-        // TODO: ??
-        return true;
-    }
-}
-
-class AXDateTimePipe {
-    constructor() { }
-    transform(value, format, calendar) {
-        if (value == null) {
-            return '';
-        }
-        const date = value instanceof AXDateTime ? value.clone() : AXDateTime.convert(value, calendar);
-        if (!format) {
-            return date.format(AXConfig.get('dateTime.shortDateFormat'));
-        }
-        else {
-            return date.format(format);
-        }
+    duration(unit = 'days') {
+        const duration = moment.duration(moment(this.startTime.date).diff(moment(this.endTime.date)));
+        return duration.as(unit);
     }
-}
-AXDateTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXDateTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimePipe, name: "axDate" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimePipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'axDate' }]
-        }], ctorParameters: function () { return []; } });
-
-class GeorgianCalendar {
-    constructor() {
-        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"
-        ];
-    }
-    create(value) {
-        return new AXDateTime(new Date(value.year, value.month - 1, value.date, value.hours || 0, value.minutes || 0, value.seconds || 0, value.ms || 0), this.name());
-    }
-    name() {
-        return 'gregorian';
-    }
-    dayOfMonth(date) {
-        return date.getDate();
-    }
-    dayOfYear(date) {
-        let result = 0;
-        let m = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-        if (this.isLeap(date)) {
-            m[1] = 29;
-        }
-        for (let i = 0; i < date.getMonth(); i++) {
-            result = result + m[i];
+    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));
         }
-        result += date.getDate();
         return result;
     }
-    dayOfWeek(date) {
-        return date.getDay() + 1;
-    }
-    weekOfYear(date) {
-        const firstDay = new AXDateTime(date).startOf('year');
-        return Math.ceil((((date.getTime() - firstDay.date.getTime()) / 86400000) + firstDay.date.getDay() + 1) / 7);
-    }
-    year(date) {
-        return date.getFullYear();
-    }
-    monthOfYear(date) {
-        return date.getMonth() + 1;
+    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);
     }
-    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;
+    getViewCompaire(view) {
+        switch (view) {
+            case 'day':
+                return 'YMD';
             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;
+                return 'YM';
             case 'year':
-                const yv = new Date(value);
-                yv.setFullYear(yv.getFullYear() + amount);
-                value = yv.valueOf();
-                break;
-            case 'day':
-            default:
-                value += 86400000 * amount;
+                return 'Y';
         }
-        return new AXDateTime(new Date(value), this.name());
     }
-    set(date, unit, value) {
-        const clone = new Date(date.valueOf());
-        switch (unit) {
-            case 'second':
-                clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
-                break;
-            case 'minute':
-                clone.setHours(clone.getHours(), value, clone.getSeconds(), clone.getMilliseconds());
-                break;
-            case 'hour':
-                clone.setHours(value, clone.getMinutes(), clone.getSeconds(), clone.getMilliseconds());
-                break;
-            default:
-            case 'day':
-                clone.setDate(value);
-                break;
-            case "week":
-                break;
-            case "month":
-                clone.setMonth(Math.max(0, value - 1));
-                break;
-            case "year":
-                clone.setFullYear(value);
-                break;
-        }
-        return new AXDateTime(clone, this.name());
+}
+
+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;
     }
-    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 index = 0;
-                const start = index >= 0 ? index : 0;
-                const day = clone.getDay();
-                const diff = clone.getDate() - day + (start > day ? start - 7 : start);
-                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');
-        }
+}
+class AXMenuItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.divider = false;
     }
-    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');
-        }
+}
+class AXButtonItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.dropdown = false;
+        this.submitBehavior = false;
+        this.cancelBehavior = false;
     }
-    isLeap(date) {
-        let leapYear = new Date(date.getFullYear(), 1, 29);
-        return leapYear.getDate() == 29;
+}
+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 JalaliCalendar {
+class AXSelectItem {
+}
+
+/**
+ * @deprecated Use AXBasePageComponent from @acorex/components
+ */
+// TODO: Add Angular decorator.
+class AXBasePageComponent {
     constructor() {
-        this.monthNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
-        this.monthShortNames = ("فروردین_اردیبهشت_خرداد_تیر_مرداد_شهریور_مهر_آبان_آذر_دی_بهمن_اسفند").split("_");
-        this.dayNames = ("شنبه_یکشنبه_دوشنبه_سه شنبه_چهارشنبه_پنج شنبه_جمعه").split("_");
-        this.dayShortNames = "ش_ی_د_س_چ_پ_ج".split("_");
+        this.onClosed = new EventEmitter();
     }
-    create(value) {
-        const a = this.toGregorian(value.year, value.month, value.date);
-        return new AXDateTime(new Date(a.getFullYear(), a.getMonth(), a.getDate(), value.hours || 0, value.minutes || 0, value.seconds || 0, value.ms || 0), this.name());
+    close(data) {
+        this.onClosed.emit({
+            component: this,
+            data: data
+        });
     }
-    name() {
-        return 'jalali';
+    onClosing(e) {
     }
-    dayOfMonth(date) {
-        return this.toJalali(date).day;
+    ngOnDestroy() {
+        this.onClosed.unsubscribe();
     }
-    dayOfYear(date) {
-        const j = this.toJalali(date);
-        return (j.month <= 6 ? ((j.month - 1) * 31) : ((6 * 31) + (j.month - 7) * 30)) + j.day;
+}
+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);
+        }
     }
-    dayOfWeek(date) {
-        return date.getDay() == 6 ? 1 : date.getDay() + 2;
+}
+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],
+                }]
+        }] });
+
+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);
     }
-    weekOfYear(date) {
-        //TODO : apply jalali
-        const firstDay = new AXDateTime(date).startOf('year');
-        return Math.ceil((((date.getTime() - firstDay.date.getTime()) / 86400000) + firstDay.date.getDay() + 1) / 7);
+    result(action) {
+        this.resultAction = action;
+        return this;
     }
-    year(date) {
-        return this.toJalali(date).year;
+    error(action) {
+        this.errorAction = action;
+        return this;
     }
-    monthOfYear(date) {
-        return this.toJalali(date).month;
+    complete(action) {
+        this.completeAction = action;
+        return this;
     }
-    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);
-                    let jd = this.dayOfMonth(date);
-                    let jm = this.monthOfYear(date);
-                    let jy = this.year(date);
-                    const nm = (jm + amount);
-                    const ny = (nm % 12) ? Math.floor(nm / 12) : 0;
-                    jy += ny;
-                    jm = nm - (ny * 12);
-                    const vv = this.toGregorian(jy, jm, jd);
-                    v.setFullYear(vv.getFullYear());
-                    v.setMonth(vv.getMonth());
-                    v.setDate(vv.getDate());
-                    value = v.valueOf();
-                    break;
-                }
-            case 'week':
-                value += 7 * 86400000 * amount;
-                break;
-            case 'year':
-                {
-                    // const v = new Date(value);
-                    // v.setFullYear(v.getFullYear() + amount);
-                    // value = v.valueOf();
-                    // break
-                    const v = new Date(value);
-                    let jd = this.dayOfMonth(date);
-                    let jm = this.monthOfYear(date);
-                    let jy = this.year(date);
-                    const vv = this.toGregorian(jy + amount, jm, jd);
-                    v.setFullYear(vv.getFullYear());
-                    v.setMonth(vv.getMonth());
-                    v.setDate(vv.getDate());
-                    value = v.valueOf();
-                    break;
-                }
-            case 'day':
-            default:
-                value += 86400000 * amount;
-        }
-        return new AXDateTime(new Date(value), this.name());
+}
+
+// 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);
+                });
+            });
+        });
     }
-    set(date, unit, value) {
-        const clone = new Date(date.valueOf());
-        const jDate = this.toJalali(clone);
-        switch (unit) {
-            case 'second':
-                clone.setHours(clone.getHours(), clone.getMinutes(), value, clone.getMilliseconds());
-                break;
-            case 'minute':
-                clone.setHours(clone.getHours(), value, clone.getSeconds(), clone.getMilliseconds());
-                break;
-            case 'hour':
-                clone.setHours(value, clone.getMinutes(), clone.getSeconds(), clone.getMilliseconds());
-                break;
-            default:
-            case 'day':
-                const gDate = this.toGregorian(jDate.year, jDate.month, value);
-                clone.setDate(gDate.getDate());
-                break;
-            case "week":
-                break;
-            case "month":
-                const gDate2 = this.toGregorian(jDate.year, value, jDate.day);
-                clone.setMonth(gDate2.getMonth());
-                break;
-            case "year":
-                const gDate3 = this.toGregorian(value, jDate.month, jDate.day);
-                clone.setFullYear(gDate3.getFullYear());
-                break;
+    handleResult(data, result, complete, config) {
+        if (this.interceptor) {
+            this.interceptor.success(config, data).then(c => {
+                if (result)
+                    result(c);
+                this.handleComplete(complete, config);
+            });
         }
-        return new AXDateTime(clone, this.name());
-    }
-    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":
-                return new AXDateTime(clone, this.name()).add('day', -this.dayOfWeek(clone) + 1).startOf('day');
-            case "month":
-                {
-                    const jy = this.year(date);
-                    const jm = this.monthOfYear(date);
-                    const gDate = this.toGregorian(jy, jm, 1);
-                    return new AXDateTime(gDate, this.name()).startOf('day');
-                }
-            case "year":
-                {
-                    const jy = this.year(date);
-                    const gDate = this.toGregorian(jy, 1, 1);
-                    return new AXDateTime(gDate, this.name()).startOf('day');
-                }
+        else {
+            //
+            if (result)
+                result(data);
+            this.handleComplete(complete, config);
         }
     }
-    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':
-                {
-                    const jy = this.year(date);
-                    const jm = this.monthOfYear(date);
-                    const jd = this.monthLength(jy, jm);
-                    const gDate = this.toGregorian(jy, jm, jd);
-                    return new AXDateTime(gDate, this.name()).endOf('day');
-                }
-            case "year":
-                let jy = this.year(date);
-                const gDate = this.toGregorian(jy, 12, this.monthLength(jy, 12));
-                return new AXDateTime(gDate, this.name()).endOf('day');
-        }
+    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);
+            }
+        });
     }
-    toJalali(date) {
-        const gy = date.getFullYear();
-        const gm = date.getMonth() + 1;
-        const gd = date.getDate();
-        const r = this.d2j(this.g2d(gy, gm, gd));
-        return {
-            year: r.jy,
-            month: r.jm,
-            day: r.jd,
+    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
         };
-    }
-    /*
-      Converts a Jalaali date to Gregorian.
-    */
-    toGregorian(jy, jm, jd) {
-        const g = this.d2g(this.j2d(jy, jm, jd));
-        return new Date(g.gy, g.gm - 1, g.gd);
-    }
-    /*
-      Checks whether a Jalaali date is valid or not.
-    */
-    isValid(jy, jm, jd) {
-        return jy >= -61 && jy <= 3177 &&
-            jm >= 1 && jm <= 12 &&
-            jd >= 1 && jd <= this.monthLength(jy, jm);
-    }
-    /*
-      Is this a leap year or not?
-    */
-    isLeapYear(jy) {
-        return this.jalCal(jy).leap === 0;
-    }
-    /*
-      Number of days in a given month in a Jalaali year.
-    */
-    monthLength(jy, jm) {
-        if (jm <= 6)
-            return 31;
-        if (jm <= 11)
-            return 30;
-        if (this.isLeapYear(jy))
-            return 30;
-        return 29;
-    }
-    jalCal(jy) {
-        // Jalaali years starting the 33-year rule.
-        let breaks = [-61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181, 1210,
-            1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178
-        ], bl = breaks.length, gy = jy + 621, leapJ = -14, jp = breaks[0], jm, jump, leap, leapG, march, n, i;
-        if (jy < jp || jy >= breaks[bl - 1])
-            throw new Error('Invalid Jalaali year ' + jy);
-        // Find the limiting years for the Jalaali year jy.
-        for (i = 1; i < bl; i += 1) {
-            jm = breaks[i];
-            jump = jm - jp;
-            if (jy < jm)
-                break;
-            leapJ = leapJ + this.div(jump, 33) * 8 + this.div(this.mod(jump, 33), 4);
-            jp = jm;
+        if (error) {
+            error(r);
         }
-        n = jy - jp;
-        // Find the number of leap years from AD 621 to the beginning
-        // of the current Jalaali year in the Persian calendar.
-        leapJ = leapJ + this.div(n, 33) * 8 + this.div(this.mod(n, 33) + 3, 4);
-        if (this.mod(jump, 33) === 4 && jump - n === 4)
-            leapJ += 1;
-        // And the same in the Gregorian calendar (until the year gy).
-        leapG = this.div(gy, 4) - this.div((this.div(gy, 100) + 1) * 3, 4) - 150;
-        // Determine the Gregorian date of Farvardin the 1st.
-        march = 20 + leapJ - leapG;
-        // Find how many years have passed since the last leap year.
-        if (jump - n < 6)
-            n = n - jump + this.div(jump + 4, 33) * 33;
-        leap = this.mod(this.mod(n + 1, 33) - 1, 4);
-        if (leap === -1) {
-            leap = 4;
+        if (!r.handled) {
+            if (this.interceptor)
+                this.interceptor.error(config, r);
         }
-        return {
-            leap: leap,
-            gy: gy,
-            march: march
-        };
-    }
-    /*
-      Converts a date of the Jalaali calendar to the Julian Day number.
-      @param jy Jalaali year (1 to 3100)
-      @param jm Jalaali month (1 to 12)
-      @param jd Jalaali day (1 to 29/31)
-      @return Julian Day number
-    */
-    j2d(jy, jm, jd) {
-        let r = this.jalCal(jy);
-        return this.g2d(r.gy, 3, r.march) + (jm - 1) * 31 - this.div(jm, 7) * (jm - 7) + jd - 1;
-    }
-    /*
-      Converts the Julian Day number to a date in the Jalaali calendar.
-      @param jdn Julian Day number
-      @return
-        jy: Jalaali year (1 to 3100)
-        jm: Jalaali month (1 to 12)
-        jd: Jalaali day (1 to 29/31)
-    */
-    d2j(jdn) {
-        let gy = this.d2g(jdn).gy // Calculate Gregorian year (gy).
-        , jy = gy - 621, r = this.jalCal(jy), jdn1f = this.g2d(gy, 3, r.march), jd, jm, k;
-        // Find number of days that passed since 1 Farvardin.
-        k = jdn - jdn1f;
-        if (k >= 0) {
-            if (k <= 185) {
-                // The first 6 months.
-                jm = 1 + this.div(k, 31);
-                jd = this.mod(k, 31) + 1;
-                return {
-                    jy: jy,
-                    jm: jm,
-                    jd: jd
-                };
+        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);
             }
-            else {
-                // The remaining months.
-                k -= 186;
-            }
-        }
-        else {
-            // Previous Jalaali year.
-            jy -= 1;
-            k += 179;
-            if (r.leap === 1)
-                k += 1;
         }
-        jm = 7 + this.div(k, 30);
-        jd = this.mod(k, 30) + 1;
-        return {
-            jy: jy,
-            jm: jm,
-            jd: jd
-        };
-    }
-    g2d(gy, gm, gd) {
-        let d = this.div((gy + this.div(gm - 8, 6) + 100100) * 1461, 4)
-            + this.div(153 * this.mod(gm + 9, 12) + 2, 5)
-            + gd - 34840408;
-        d = d - this.div(this.div(gy + 100100 + this.div(gm - 8, 6), 100) * 3, 4) + 752;
-        return d;
-    }
-    d2g(jdn) {
-        let j, i, gd, gm, gy;
-        j = 4 * jdn + 139361631;
-        j = j + this.div(this.div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908;
-        i = this.div(this.mod(j, 1461), 4) * 5 + 308;
-        gd = this.div(this.mod(i, 153), 5) + 1;
-        gm = this.mod(this.div(i, 153), 12) + 1;
-        gy = this.div(j, 1461) - 100100 + this.div(8 - gm, 6);
-        return {
-            gy: gy,
-            gm: gm,
-            gd: gd
-        };
-    }
-    /*
-      Utility helper functions.
-    */
-    div(a, b) {
-        return ~~(a / b);
-    }
-    mod(a, b) {
-        return a - ~~(a / b) * b;
-    }
-}
-
-class AXDateTimeModule {
-    constructor() {
-        AXConfig.set({
-            dateTime: {
-                calendars: {
-                    jalali: new JalaliCalendar(),
-                    gregorian: new GeorgianCalendar()
-                },
-                calendar: 'gregorian',
-                shortDateFormat: 'DDDD, d MMM yyyy'
+        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);
             }
-        });
-    }
-}
-AXDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimeModule, declarations: [AXDateTimePipe], exports: [AXDateTimePipe] });
-AXDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimeModule, providers: [], imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXDateTimeModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [AXDateTimePipe],
-                    declarations: [AXDateTimePipe],
-                    providers: [],
-                }]
-        }], ctorParameters: function () { return []; } });
-
-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.2", ngImport: i0, type: AXEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXEventService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXEventService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXEventService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class AXHotkeysService {
-    constructor(eventManager, document) {
-        this.eventManager = eventManager;
-        this.document = document;
-        this.defaults = {
-            element: this.document
+        return {
+            headers: headers,
+            params: params,
+            body: options.body,
+            responseType: options.responseType || 'json'
         };
-    }
-    addShortcut(options) {
-        const merged = Object.assign(Object.assign({}, this.defaults), options);
-        const event = `keydown.${merged.keys}`;
-        return new Observable(observer => {
-            const handler = (e) => {
-                e.preventDefault();
-                observer.next(e);
-            };
-            const dispose = this.eventManager.addEventListener(merged.element, event, handler);
-            return () => {
-                dispose();
-            };
-        });
+        // if (options.method == "get") {
+        //     return {
+        //         headers: headers,
+        //         params: params
+        //     };
+        // }
+        // else {
+        //     return {
+        //         headers: headers,
+        //         params: params,
+        //         body: options.body
+        //     };
+        // }
     }
 }
-AXHotkeysService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXHotkeysService, deps: [{ token: i1.EventManager }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
-AXHotkeysService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXHotkeysService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXHotkeysService, decorators: [{
+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.EventManager }, { type: Document, decorators: [{
-                        type: Inject,
-                        args: [DOCUMENT]
-                    }] }];
-    } });
-
-// @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, params) {
-        lang = lang || AXTranslator.lang;
-        let result = _.get(AXTranslator[`__data__${lang}`], key, key);
-        const vars = typeof (result) == 'string' ? result === null || result === void 0 ? void 0 : result.match(this._varsRegx) : [];
-        if (vars === null || vars === void 0 ? void 0 : vars.length) {
-            vars.forEach(v => {
-                var _a;
-                const varKey = ((_a = v.match(this._varNameRegx)) === null || _a === void 0 ? void 0 : _a.length) ? v.match(this._varNameRegx)[0] : null;
-                if (varKey) {
-                    const p = _.get(params, varKey) || this.get(varKey, lang);
-                    if (p) {
-                        result = result.replace(v, p);
-                    }
-                }
-            });
-        }
-        return typeof (result) == 'string' ? result : JSON.stringify(result);
-    }
-}
-AXTranslator.lang = 'en';
-AXTranslator.dataChangeSubject = new Subject();
-AXTranslator._varsRegx = /((\$\{[a-zA-Z_0-9\.]+\})+)/gm;
-AXTranslator._varNameRegx = /[a-zA-Z_0-9\.]+/gm;
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.Injector }]; } });
 
-class AXTranslatorPipe {
-    transform(value, lang) {
-        return AXTranslator.get(value, lang);
+class AXHttpModule {
+    static forRoot() {
+        return {
+            ngModule: AXHttpModule,
+            providers: [AXHttpService]
+        };
     }
 }
-AXTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-AXTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslatorPipe, name: "trans" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslatorPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'trans', pure: true }]
-        }] });
-
-class AXTranslationModule {
-}
-AXTranslationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AXTranslationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslationModule, declarations: [AXTranslatorPipe], exports: [AXTranslatorPipe] });
-AXTranslationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslationModule, providers: [], imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXTranslationModule, decorators: [{
+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: [{
-                    imports: [],
-                    exports: [AXTranslatorPipe],
-                    declarations: [AXTranslatorPipe],
-                    providers: [],
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule
+                    ],
+                    exports: [HttpClientModule],
+                    providers: [
+                        AXHttpService
+                    ]
                 }]
         }] });
 
@@ -1259,7 +860,10 @@ class AXPlatform {
         this.resize = new Subject();
         this.click = new Subject();
         this.scroll = new Subject();
-        window.addEventListener('resize', (e) => {
+        fromEvent(window, 'resize')
+            .pipe(debounceTime(100))
+            .pipe(distinctUntilChanged())
+            .subscribe((e) => {
             this.resize.next({
                 nativeEvent: e,
                 source: this
@@ -1306,23 +910,1352 @@ class AXPlatform {
         document.querySelector(':root').style.setProperty('--ax-vh', window.innerHeight / 100 + 'px');
     }
 }
-AXPlatform.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXPlatform, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-AXPlatform.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXPlatform, providedIn: 'platform' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AXPlatform, decorators: [{
+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: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AXPlatform, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'platform',
                 }]
         }], ctorParameters: function () { return []; } });
 
-/**
- * Public API refrences of core libraries
- * @module @acorex/core
- */
+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 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 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';
+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 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 en$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    common: common$1,
+    dateTime: dateTime$1,
+    queryBuilder: queryBuilder$1,
+    validation: validation$1,
+    dataGrid: dataGrid$1,
+    '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: "قبلی"
+};
+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({
+    __proto__: null,
+    common: common,
+    dateTime: dateTime,
+    queryBuilder: queryBuilder,
+    validation: validation,
+    dataGrid: dataGrid,
+    '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: [],
+                }]
+        }], 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);
+    }
+}
+
+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 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
+        }], 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' }]
+        }], 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
+                    ],
+                }]
+        }] });
+
+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: []
+                }]
+        }] });
+
+// 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: []
+                }]
+        }] });
+
+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.
  */
 
-export { AXCalendarMonth, AXConfig, AXCoreModule, AXDateTime, AXDateTimeModule, AXDateTimePipe, AXDateTimeRange, AXDrawingUtil, AXEventService, AXHotkeysService, AXObjectUtil, AXPlatform, AXPlatformEvent, AXSafePipe, AXStringUtil, AXTranslationModule, AXTranslator, AXTranslatorPipe, GeorgianCalendar, JalaliCalendar, testUserAgent };
+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 };
 //# sourceMappingURL=acorex-core.mjs.map