@ng-nest/ui 12.0.8 → 13.0.2

package/fesm2015/ng-nest-ui-core.mjs

@@ -0,0 +1,1432 @@
+import { Observable, isObservable, of, throwError, Subject } from 'rxjs';
+import { trigger, transition, style, animate, state } from '@angular/animations';
+import { coerceBooleanProperty, _isNumberValue } from '@angular/cdk/coercion';
+import { map, takeUntil, filter, mapTo } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { Injectable, InjectionToken, Inject, Optional } from '@angular/core';
+import * as i1 from '@angular/common/http';
+import { DOCUMENT } from '@angular/common';
+
+function chunk(array, size = 1) {
+    const len = array == null ? 0 : array.length;
+    if (!len || size < 1) {
+        return [];
+    }
+    let index = 0;
+    let resIndex = 0;
+    const result = new Array(Math.ceil(len / size));
+    while (index < len) {
+        result[resIndex++] = array.slice(index, (index += size));
+    }
+    return result;
+}
+
+/**
+ * 生成 GUID
+ */
+function guid() {
+    let S4 = () => {
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    };
+    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+}
+
+function groupBy(array, name) {
+    const groups = {};
+    array.forEach((obj) => {
+        const group = JSON.stringify(obj[name]);
+        groups[group] = groups[group] || [];
+        groups[group].push(obj);
+    });
+    return Object.keys(groups).map((group) => groups[group]);
+}
+
+const XResize = (...element) => {
+    return new Observable((x) => {
+        const resizeObserver = new ResizeObserver((entries) => {
+            for (const entry of entries) {
+                x.next({ entry: entry, resizeObserver: resizeObserver });
+            }
+        });
+        for (let ele of element) {
+            if (ele)
+                resizeObserver.observe(ele);
+        }
+        //XResize 取消订阅的时候自动销毁
+        //resizeObserver.disconnect();
+    });
+};
+
+/**
+ * Fill default values
+ * @param option option
+ * @param def default
+ */
+function fillDefault(option, def) {
+    if (option && def) {
+        for (const key in def) {
+            if (typeof option[key] === 'undefined') {
+                option[key] = def[key];
+            }
+        }
+    }
+}
+
+/**
+ * 删除当前标签，保留内容
+ */
+function removeNgTag(nativeElement) {
+    const parentElement = nativeElement.parentElement;
+    if (!parentElement || !parentElement.insertBefore)
+        return;
+    while (nativeElement.firstChild) {
+        parentElement.insertBefore(nativeElement.firstChild, nativeElement);
+    }
+    parentElement.removeChild(nativeElement);
+}
+
+function warnSVGTagNotFound() {
+    console.warn(`<svg> tag not found.`);
+}
+function warnIconTypeNotFound() {
+    console.warn(`icon type not found.`);
+}
+
+function computedStyle(element, style) {
+    let computed = getComputedStyle(element);
+    let value = computed[style];
+    return value.replace(/px/g, '');
+}
+
+// tslint:disable:no-any typedef no-invalid-this
+const availablePrefixes = ['moz', 'ms', 'webkit'];
+function requestAnimationFramePolyfill() {
+    let lastTime = 0;
+    return function (callback) {
+        const currTime = new Date().getTime();
+        const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+        const id = setTimeout(() => {
+            callback(currTime + timeToCall);
+        }, timeToCall);
+        lastTime = currTime + timeToCall;
+        return id;
+    };
+}
+function getRequestAnimationFrame() {
+    if (typeof window === 'undefined') {
+        return () => 0;
+    }
+    if (window.requestAnimationFrame) {
+        return window.requestAnimationFrame.bind(window);
+    }
+    const prefix = availablePrefixes.filter((key) => `${key}RequestAnimationFrame` in window)[0];
+    return prefix ? window[`${prefix}RequestAnimationFrame`] : requestAnimationFramePolyfill();
+}
+// export function cancelRequestAnimationFrame(id: number): any {
+//   if (typeof window === "undefined") {
+//     return null;
+//   }
+//   if (window.cancelAnimationFrame) {
+//     return window.cancelAnimationFrame(id);
+//   }
+//   const prefix = availablePrefixes.filter(
+//     key =>
+//       `${key}CancelAnimationFrame` in window ||
+//       `${key}CancelRequestAnimationFrame` in window
+//   )[0];
+//   return prefix
+//     ? (
+//         (window as any)[`${prefix}CancelAnimationFrame`] ||
+//         (window as any)[`${prefix}CancelRequestAnimationFrame`]
+//       )
+//         // @ts-ignore
+//         .call(this, id)
+//     : clearTimeout(id);
+// }
+const reqAnimFrame = getRequestAnimationFrame();
+
+/**
+ * 去除HTML标签
+ */
+function stripTags(text, ...usefulTags) {
+    if (!text || typeof (text) !== 'string')
+        return text;
+    return usefulTags.length > 0
+        ? text.replace(new RegExp(`<(?!\/?(${usefulTags.join('|')})\s*\/?)[^>]+>`, 'g'), '')
+        : text.replace(/<(?:.|\s)*?>/g, '');
+}
+
+var XDuration;
+(function (XDuration) {
+    XDuration["Slow"] = "0.3s";
+    XDuration["Base"] = "0.2s";
+    XDuration["Fast"] = "0.1s";
+})(XDuration || (XDuration = {}));
+
+// 进场动画
+const XDURATION_BASE_EASE_IN$1 = `${XDuration.Fast} ease-in`;
+// 移除动画
+const XDURATION_BASE_EASE_OUT$1 = `${XDuration.Fast} ease-out`;
+const XFadeAnimation = trigger('x-fade-animation', [
+    transition(':enter', [
+        style({ opacity: 0, transform: 'scale(0.8)' }),
+        animate(`${XDURATION_BASE_EASE_IN$1}`, style({ opacity: 1, transform: 'scale(1)' }))
+    ]),
+    transition(':leave', [animate(`${XDURATION_BASE_EASE_OUT$1}`, style({ opacity: 0 }))])
+]);
+
+const XSlideAnimation = trigger('x-slide-animation', [
+    transition('void => right', [style({ transform: 'translate(100%,0)' }), animate(`${XDuration.Base} ease-in`)]),
+    transition('right => void', [animate(`${XDuration.Base} ease-out`, style({ transform: 'translate(100%,0)' }))]),
+    transition('void => left', [style({ transform: 'translate(-100%,0)' }), animate(`${XDuration.Base} ease-in`)]),
+    transition('left => void', [animate(`${XDuration.Base} ease-out`, style({ transform: 'translate(-100%,0)' }))]),
+    transition('void => top', [style({ transform: 'translate(0,-100%)' }), animate(`${XDuration.Base} ease-in`)]),
+    transition('top => void', [animate(`${XDuration.Base} ease-out`, style({ transform: 'translate(0,-100%)' }))]),
+    transition('void => bottom', [style({ transform: 'translate(0,100%)' }), animate(`${XDuration.Base} ease-in`)]),
+    transition('bottom => void', [animate(`${XDuration.Base} ease-out`, style({ transform: 'translate(0,100%)' }))])
+]);
+const XSliderAnimation = trigger('x-slider-animation', [
+    transition('void => left, void => right', [
+        style({
+            width: 0,
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            width: '*',
+            opacity: 1
+        }))
+    ]),
+    transition('left => void, right => void', [
+        style({
+            width: '*',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            width: 0,
+            opacity: 0
+        }))
+    ])
+]);
+
+const XDropAnimation = trigger('x-drop-animation', [
+    state('*', style({ opacity: 0, height: 0, border: 0, padding: 0, visibility: 'hidden' })),
+    state('false', style({ opacity: 0, height: 0, border: 0, padding: 0, visibility: 'hidden' })),
+    state('true', style({ opacity: 1, height: '*', border: '*', padding: '*', visibility: 'inherit' })),
+    transition('* => *', animate(`${XDuration.Base} ease-out`))
+]);
+
+const XMoveAnimation = trigger('x-move-animation', [
+    transition('void => top-start, void => top, void => top-end, void => center', [
+        style({
+            transform: 'translateY(-200%)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('top-start => void, top => void, top-end => void, center => void', [
+        style({
+            transform: 'translateY(0%)',
+            opacity: 1,
+            height: '*'
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(-200%)',
+            opacity: 0,
+            height: 0
+        }))
+    ]),
+    transition('void => left', [
+        style({
+            transform: 'translateX(-30%)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('left => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1,
+            height: '*'
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(-30%)',
+            opacity: 0,
+            height: 0
+        }))
+    ]),
+    transition('void => right', [
+        style({
+            transform: 'translateX(30%)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('right => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1,
+            height: '*'
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(30%)',
+            opacity: 0,
+            height: 0
+        }))
+    ]),
+    transition('void => bottom-start, void => bottom, void => bottom-end', [
+        style({
+            transform: 'translateY(200%)',
+            opacity: 0,
+            height: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(0%)',
+            opacity: 1,
+            height: '*'
+        }))
+    ]),
+    transition('bottom-start => void, bottom => void, bottom-end => void', [
+        style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(200%)',
+            opacity: 0
+        }))
+    ])
+]);
+const XMoveBoxAnimation = trigger('x-move-box-animation', [
+    transition('void => top-start, void => top, void => top-end, void => center', [
+        style({
+            transform: 'translateY(-2rem)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('top-start => void, top => void, top-end => void, center => void', [
+        style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(-2rem)',
+            opacity: 0
+        }))
+    ]),
+    transition('void => left', [
+        style({
+            transform: 'translateX(-2rem)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('left => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(-2rem)',
+            opacity: 0
+        }))
+    ]),
+    transition('void => right', [
+        style({
+            transform: 'translateX(2rem)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('right => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(2rem)',
+            opacity: 0
+        }))
+    ]),
+    transition('void => bottom-start, void => bottom, void => bottom-end', [
+        style({
+            transform: 'translateY(2rem)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('bottom-start => void, bottom => void, bottom-end => void', [
+        style({
+            transform: 'translateY(0%)',
+            opacity: 1
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateY(2rem)',
+            opacity: 0
+        }))
+    ])
+]);
+
+// 进场动画
+const XDURATION_BASE_EASE_IN = `${XDuration.Fast} ease-in`;
+// 移除动画
+const XDURATION_BASE_EASE_OUT = `${XDuration.Fast} ease-out`;
+const XConnectAnimation = trigger('x-connect-animation', [
+    transition('void => top-start, void => top, void => top-end, void => center', [
+        style({
+            opacity: 0
+            // transform: 'scaleY(0.8)',
+            // transformOrigin: '0% 100%'
+        }),
+        animate(XDURATION_BASE_EASE_IN, style({
+            opacity: 1
+            // transform: 'scaleY(1)',
+            // transformOrigin: '0% 100%'
+        }))
+    ]),
+    transition('top-start => void, top => void, top-end => void, center => void', [
+        style({
+            opacity: 1
+            // transform: 'scaleY(1)',
+            // transformOrigin: '0% 100%'
+        }),
+        animate(XDURATION_BASE_EASE_OUT, style({
+            opacity: 0
+            // transform: 'scaleY(0.8)',
+            // transformOrigin: '0% 100%'
+        }))
+    ]),
+    transition('void => left', [
+        style({
+            transform: 'translateX(-30%)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('left => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1,
+            height: '*'
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(-30%)',
+            opacity: 0,
+            height: 0
+        }))
+    ]),
+    transition('void => right', [
+        style({
+            transform: 'translateX(30%)',
+            opacity: 0
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(0%)',
+            opacity: 1
+        }))
+    ]),
+    transition('right => void', [
+        style({
+            transform: 'translateX(0%)',
+            opacity: 1,
+            height: '*'
+        }),
+        animate(`${XDuration.Base}`, style({
+            transform: 'translateX(30%)',
+            opacity: 0,
+            height: 0
+        }))
+    ]),
+    transition('void => bottom-start, void => bottom, void => bottom-end', [
+        style({
+            opacity: 0
+            // transform: 'scale(0)',
+            // transformOrigin: '0% 0%'
+        }),
+        animate(XDURATION_BASE_EASE_IN, style({
+            opacity: 1
+            // transform: 'scale(1)',
+            // transformOrigin: '30% 30%'
+        }))
+    ]),
+    transition('bottom-start => void, bottom => void, bottom-end => void', [
+        style({
+            opacity: 1
+            // transform: 'scale(1)',
+            // transformOrigin: '30% 30%'
+        }),
+        animate(XDURATION_BASE_EASE_OUT, style({
+            opacity: 0
+            // transform: 'scale(0)',
+            // transformOrigin: '0% 0%'
+        }))
+    ])
+]);
+const XConnectBaseAnimation = trigger('x-connect-base-animation', [
+    transition(':enter', [style({ opacity: 0, transform: 'scaleY(0.8)' }), animate(XDURATION_BASE_EASE_IN)]),
+    transition(':leave', [animate(XDURATION_BASE_EASE_OUT, style({ opacity: 0 }))])
+]);
+
+// 类型判断
+const XIsType = (type) => (object) => Object.prototype.toString.call(object) === `[object ${type}]`;
+// 值改变判断
+const XIsChange = (...changes) => {
+    for (let change of changes) {
+        if ((change === null || change === void 0 ? void 0 : change.currentValue) !== (change === null || change === void 0 ? void 0 : change.previousValue))
+            return true;
+    }
+    return false;
+};
+const XIsString = XIsType('String');
+const XIsArray = XIsType('Array');
+const XIsNumber = XIsType('Number');
+const XIsBoolean = XIsType('Boolean');
+const XIsObject = XIsType('Object');
+const XIsNull = XIsType('Null');
+const XIsFunction = XIsType('Function');
+const XIsDate = XIsType('Date');
+const XIsRegExp = XIsType('RegExp');
+const XIsValue = (object) => XIsString(object) || XIsNumber(object) || XIsBoolean(object) || XIsDate(object);
+const XIsUndefined = (object) => typeof object === 'undefined';
+const XIsEmpty = (object) => typeof object === 'undefined' || object === null || object === '' || object.length === 0;
+const XIsValueArray = (object) => XIsArray(object) && object.length > 0 && !XIsObject(object[0]);
+const XIsObjectArray = (object) => XIsArray(object) && object.length > 0 && XIsObject(object[0]);
+const XIsObservable = (object) => isObservable(object);
+const XIsTemplateRef = (object) => {
+    if (!XIsEmpty(object) && object.elementRef)
+        return true;
+    else
+        return false;
+};
+const XIsXTemplate = (object) => XIsString(object) || XIsNumber(object) || XIsDate(object) || XIsTemplateRef(object);
+
+// 标识对象
+class XIdentity {
+}
+
+function XToBoolean(value) {
+    // if (XIsString(value)) {
+    //   return ['', 'true'].indexOf(String(value).trim()) !== -1;
+    // } else {
+    //   return Boolean(value);
+    // }
+    return coerceBooleanProperty(value);
+}
+function XToNumber(value, fallbackValue = 0) {
+    return _isNumberValue(value) ? Number(value) : fallbackValue;
+}
+function XToDataConvert(value) {
+    if (XIsArray(value)) {
+        return value.map((x) => {
+            if (XIsValue(x)) {
+                return { label: x, id: x };
+            }
+            else if (XIsObject(x)) {
+                x.label = XIsUndefined(x.label) || XIsNull(x.label) ? x.id : x.label;
+                x.id = XIsUndefined(x.id) || XIsNull(x.id) ? x.label : x.id;
+                return x;
+            }
+        });
+    }
+    return value;
+}
+function XSetData(data, unSubject, toConvert = true, funcParam = null) {
+    return new Observable((x) => {
+        const result = (res) => {
+            x.next(res);
+            x.complete();
+        };
+        if (typeof data === 'undefined') {
+            result([]);
+        }
+        else {
+            if (XIsObservable(data)) {
+                data
+                    .pipe(map((y) => (toConvert ? XToDataConvert(y) : y)), takeUntil(unSubject))
+                    .subscribe((y) => {
+                    result(y);
+                });
+            }
+            else if (XIsFunction(data)) {
+                data(funcParam)
+                    .pipe(map((y) => (toConvert ? XToDataConvert(y) : y)), takeUntil(unSubject))
+                    .subscribe((y) => {
+                    result(y);
+                });
+            }
+            else {
+                result((toConvert ? XToDataConvert(data) : data));
+            }
+        }
+    });
+}
+function XGetChildren(nodes, node, level) {
+    var _a;
+    node.level = level;
+    node.children = nodes.filter((y) => y.pid === node.id);
+    node.leaf = ((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    if (node.leaf)
+        node.children.map((y) => XGetChildren(nodes, y, level + 1));
+    return node;
+}
+function XInvertKeyValues(obj) {
+    return Object.keys(obj).reduce((nw, key) => {
+        nw.set(obj[key], key);
+        return nw;
+    }, new Map());
+}
+function XClearClass(...classMaps) {
+    classMaps.forEach((classMap) => {
+        for (const key in classMap) {
+            classMap[key] = false;
+        }
+    });
+}
+function propDecoratorFactory(name, fallback) {
+    function propDecorator(target, propName, originalDescriptor) {
+        const privatePropName = `$$__${propName}`;
+        if (Object.prototype.hasOwnProperty.call(target, privatePropName)) {
+            console.warn(`The prop "${privatePropName}" is already exist, it will be overrided by ${name} decorator.`);
+        }
+        Object.defineProperty(target, privatePropName, {
+            configurable: true,
+            writable: true
+        });
+        return {
+            get() {
+                return originalDescriptor && originalDescriptor.get ? originalDescriptor.get.bind(this)() : this[privatePropName];
+            },
+            set(value) {
+                if (originalDescriptor && originalDescriptor.set) {
+                    originalDescriptor.set.bind(this)(fallback(value));
+                }
+                this[privatePropName] = fallback(value);
+            }
+        };
+    }
+    return propDecorator;
+}
+function XInputBoolean() {
+    return propDecoratorFactory('XInputBoolean', XToBoolean);
+}
+function XInputNumber() {
+    return propDecoratorFactory('XInputNumber', XToNumber);
+}
+function XDataConvert() {
+    return propDecoratorFactory('XDataConvert', XToDataConvert);
+}
+function XClamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+function XToDate(date) {
+    if (XIsDate(date) || XIsNumber(date)) {
+        return new Date(date);
+    }
+    else {
+        return new Date(Date.parse(date));
+    }
+}
+function XAddSeconds(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setSeconds(dt.getSeconds() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+function XAddMinutes(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setMinutes(dt.getMinutes() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+function XAddHours(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setHours(dt.getHours() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+function XAddDays(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setDate(dt.getDate() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+function XAddMonths(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setMonth(dt.getMonth() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+function XAddYears(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setFullYear(dt.getFullYear() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+
+function setFlex(ele, renderer, justify, align, direction) {
+    let result = [];
+    if (!XIsEmpty(justify)) {
+        const justifyStr = `x-justify-${justify}`;
+        result.push(justifyStr);
+        renderer.addClass(ele, justifyStr);
+    }
+    if (!XIsEmpty(align)) {
+        const alignStr = `x-align-${align}`;
+        result.push(alignStr);
+        renderer.addClass(ele, alignStr);
+    }
+    if (!XIsEmpty(direction)) {
+        const directionStr = `x-direction-${direction}`;
+        result.push(directionStr);
+        renderer.addClass(ele, directionStr);
+    }
+    return result;
+}
+
+function XDrop(array, n) {
+    if (!n)
+        return [...array];
+    if (array.length < 1 || array.length <= Math.abs(n))
+        return [];
+    return array.slice(n > 0 ? n : 0, n > 0 ? array.length : n);
+}
+
+function XRemove(array, predicate) {
+    if (typeof predicate === 'undefined')
+        return [];
+    let result = [];
+    for (let i = 0; i < array.length; i++) {
+        if (predicate(array[i])) {
+            result.push(array[i]);
+        }
+    }
+    for (let item of result) {
+        array.splice(array.indexOf(item), 1);
+    }
+    return result;
+}
+
+function XOrderBy(collection, iteratees, orders) {
+    if (!iteratees)
+        return collection;
+    if (!orders)
+        orders = [];
+    function compare(a, b, prop, order, idex) {
+        if (a[prop] == b[prop]) {
+            ++idex;
+            if (iteratees.length > idex) {
+                const odr = orders && orders.length > idex ? orders[idex] : 'asc';
+                return compare(a, b, iteratees[idex], odr, idex);
+            }
+            else {
+                return 0;
+            }
+        }
+        if (order === 'desc') {
+            return (b[prop] - a[prop]);
+        }
+        else {
+            return (a[prop] - b[prop]);
+        }
+    }
+    const iterate = iteratees.shift();
+    const order = orders.shift() || 'asc';
+    if (!iterate)
+        return collection;
+    collection.sort((a, b) => compare(a, b, iterate, order, -1));
+    return collection;
+}
+
+function XCloneDeep(value) {
+    let result = Array.isArray(value) ? [] : {};
+    if (value && typeof value === 'object') {
+        for (let key in value) {
+            if (value.hasOwnProperty(key)) {
+                result[key] = value && typeof value[key] === 'object' ? XCloneDeep(value[key]) : value[key];
+            }
+        }
+    }
+    return result;
+}
+
+function XHasIn(object, key) {
+    return object != null && key in Object(object);
+}
+
+/**
+ * 组件公共属性
+ */
+class XProperty {
+    constructor() {
+        /**
+         * 样式映射属性
+         */
+        this.classMap = {};
+    }
+}
+
+// @dynamic
+class XReuseStrategyService {
+    /**
+     * 表示对所有路由允许复用 如果你有路由不想利用可以在这加一些业务逻辑判断
+     */
+    shouldDetach(_route) {
+        return true;
+    }
+    /**
+     * 当路由离开时会触发。按path作为key存储路由快照&组件当前实例对象
+     */
+    store(route, handle) {
+        if (handle == null)
+            return;
+        if (XReuseStrategyService.waitDelete && this.getRouteUrl(route).indexOf(XReuseStrategyService.waitDelete) == 0) {
+            //如果待删除是当前路由则不存储快照
+            XReuseStrategyService.waitDelete = null;
+            return;
+        }
+        this.add(this.getRouteUrl(route), handle);
+    }
+    /**
+     * 若 path 在缓存中有的都认为允许还原路由
+     */
+    shouldAttach(route) {
+        return !!XReuseStrategyService.storages.find((x) => x.id == this.getRouteUrl(route));
+    }
+    /**
+     * 从缓存中获取快照，若无则返回nul
+     */
+    retrieve(route) {
+        if (!route.routeConfig) {
+            return {};
+        }
+        let stroage = XReuseStrategyService.storages.find((x) => x.id == this.getRouteUrl(route));
+        return stroage ? stroage.handle : {};
+    }
+    /**
+     * 进入路由触发，判断是否同一路由
+     * 解决不同的参数也会认为是同一个路由，导致会将之前的路由拿出来复用
+     */
+    shouldReuseRoute(future, curr) {
+        return future.routeConfig === curr.routeConfig && JSON.stringify(future.params) == JSON.stringify(curr.params);
+    }
+    /**
+     * 解决不同的主路由会存在相同名称的子路由
+     */
+    getRouteUrl(route) {
+        let url = route.url.map((x) => x.path).join('_');
+        return url;
+    }
+    /**
+     * 删除复用的路由
+     */
+    static deleteRouteSnapshot(name) {
+        if (name) {
+            let id = name.replace(/\//g, '_');
+            XReuseStrategyService.storages.splice(XReuseStrategyService.storages.findIndex((x) => x.id.indexOf(id) === 0), 1);
+            XReuseStrategyService.waitDelete = id;
+        }
+        else {
+            XReuseStrategyService.storages = [];
+        }
+    }
+    add(id, handle) {
+        XReuseStrategyService.storages.splice(XReuseStrategyService.storages.findIndex((x) => x.id == id), 1);
+        XReuseStrategyService.storages = [...XReuseStrategyService.storages, { id: id, handle: handle }];
+    }
+}
+// 存储的复用路由
+XReuseStrategyService.storages = [];
+
+// @dynamic
+class XPreloadingStrategyService {
+    constructor() {
+        // 需要预加载的模块
+        this.preloadedModules = [];
+    }
+    preload(route, load) {
+        if (route.data && route.data['preload']) {
+            this.preloadedModules.push(route.path);
+            return load();
+        }
+        else {
+            return of(null);
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XPreloadingStrategyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPreloadingStrategyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XPreloadingStrategyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPreloadingStrategyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPreloadingStrategyService, decorators: [{
+            type: Injectable
+        }] });
+
+// @dynamic
+class XHttpService {
+    constructor(http) {
+        this.http = http;
+        this.api = '';
+    }
+    /**
+     * get请求
+     */
+    get(url, params) {
+        return this.request('GET', url, params);
+    }
+    /**
+     * get请求
+     */
+    post(url, params) {
+        return this.request('POST', url, params);
+    }
+    /**
+     * put请求
+     */
+    put(url, params) {
+        return this.request('PUT', url, params);
+    }
+    /**
+     * delete请求
+     */
+    delete(url, params) {
+        return this.request('DELETE', url, params);
+    }
+    /**
+     * request通用请求
+     */
+    request(method, url, params, option) {
+        if (!option)
+            option = {};
+        let opt = {};
+        url = `${this.api}${url}`;
+        method = method.toUpperCase();
+        if (['POST', 'PUT', 'DELETE'].indexOf(method) > -1) {
+            opt = { body: params, observe: 'body', responseType: 'json' };
+        }
+        else if (['GET'].indexOf(method) > -1) {
+            opt = { params: params };
+        }
+        Object.assign(opt, option);
+        this.addHeader(opt);
+        return new Observable((x) => {
+            this.http.request(method, url, opt).subscribe((y) => {
+                x.next(y);
+                x.complete();
+            }, (y) => {
+                x.error(y);
+                x.complete();
+                this.handleError(y);
+            });
+        });
+    }
+    /**
+     * 错误处理
+     */
+    handleError(error) {
+        if (error.error) {
+        }
+        return throwError(error.error);
+    }
+    /**
+     * 添加头部信息
+     */
+    addHeader(_option) {
+        // let auth = this.setting.getSession("Auth");
+        // if (auth && auth["token"]) {
+        //   option["headers"] = { Authorization: `Bearer ${auth["token"]}` };
+        // }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XHttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XHttpService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XHttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XHttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XHttpService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+
+// @dynamic
+class XStorageService {
+    constructor() { }
+    /**
+     * 获取本地值
+     */
+    getLocal(key) {
+        return JSON.parse(localStorage.getItem(key) || 'null') || null;
+    }
+    /**
+     * 设置本地值
+     */
+    setLocal(key, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+    /**
+     * 获取当前会话的值
+     */
+    getSession(key) {
+        return JSON.parse(sessionStorage.getItem(key) || 'null') || null;
+    }
+    /**
+     * 设置当前会话值
+     */
+    setSession(key, value) {
+        sessionStorage.setItem(key, JSON.stringify(value));
+    }
+    /**
+     * 移除本地值
+     */
+    removeLocal(key) {
+        localStorage.removeItem(key);
+    }
+    /**
+     * 移除当前会话
+     */
+    removeSession(key) {
+        sessionStorage.removeItem(key);
+    }
+    /**
+     * 生成guid
+     */
+    guid() {
+        let S4 = () => {
+            return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+        };
+        return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XStorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+
+class XRepositoryAbstract {
+}
+class XRepositoryService extends XRepositoryAbstract {
+    constructor(http, input) {
+        super();
+        this.http = http;
+        this.input = input;
+        this.api = '';
+        this.api = typeof input.api !== 'undefined' ? input.api : '';
+    }
+    getList(index, size, query) {
+        index = index ? index : 1;
+        size = size ? size : 10;
+        return this.http.post(`${this.api}${this.input.controller.name}/${size}/${index}`, query);
+    }
+    get(id) {
+        return this.http.get(`${this.api}${this.input.controller.name}/${id}`);
+    }
+    post(entity) {
+        return this.http.post(`${this.api}${this.input.controller.name}`, entity);
+    }
+    put(entity) {
+        return this.http.put(`${this.api}${this.input.controller.name}`, entity);
+    }
+    delete(id) {
+        return this.http.delete(`${this.api}${this.input.controller.name}/${id}`);
+    }
+}
+
+const X_CONFIG = new InjectionToken('x-config');
+
+const X_THEME = new InjectionToken('x-theme');
+const X_THEME_PREFIX = '--x-';
+const X_THEME_MERGE = '#ffffff';
+const X_THEME_BLACK_MERGE = '#cccccc';
+const X_THEME_AMOUNTS = [0, -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
+const X_THEME_BACKGROUNDS = [-0.2, -0.3, -0.4];
+const X_THEME_TEXTS = [
+    [-0.5, 0],
+    [-0.6, 0.2],
+    [-0.7, 0.4]
+];
+const X_THEME_BORDERS = [
+    [-0.8, 0],
+    [-0.9, 0.2]
+];
+const X_THEME_EXCHANGES = [
+    [-0.1, -0.1],
+    [0.1, -0.1],
+    [0.2, 0.2],
+    [0.3, 0],
+    [0.4, -0.4],
+    [0.5, -0.2],
+    [0.6, 0],
+    [0.7, -0.4],
+    [0.8, -0.4],
+    [0.9, -0.2]
+];
+const X_THEME_COLORS = {
+    primary: '#1976d2',
+    success: '#67c23a',
+    warning: '#e6a23c',
+    danger: '#f56c6c',
+    info: '#909399',
+    text: '#333333',
+    border: '#dddddd',
+    background: '#ffffff'
+};
+const X_THEME_DARK_COLORS = {
+    text: '#dddddd',
+    border: '#424242',
+    background: '#1e1e1f'
+};
+const X_THEME_COLOR_KEYS = Object.keys(X_THEME_COLORS);
+
+class XThemeService {
+    constructor(doc, factory) {
+        this.doc = doc;
+        this.factory = factory;
+        this.colorsProp = {};
+        this.renderer2 = this.factory.createRenderer(null, null);
+        this.declaration = getComputedStyle(this.doc.documentElement);
+    }
+    setInitialTheme(theme) {
+        this.setColors(theme === null || theme === void 0 ? void 0 : theme.colors);
+        if (theme === null || theme === void 0 ? void 0 : theme.colors)
+            Object.assign(X_THEME_COLORS, theme.colors);
+    }
+    setTheme(theme) {
+        this.setColors(theme === null || theme === void 0 ? void 0 : theme.colors);
+    }
+    getTheme(includesAll = false) {
+        return {
+            colors: this.getColors(includesAll)
+        };
+    }
+    setColors(colors) {
+        colors = this.getColorsTheme(colors);
+        for (let key in colors) {
+            Object.assign(this.colorsProp, this.setRoot(key, colors[key]));
+        }
+        this.createColorsStyle();
+    }
+    getColors(includes = false, prefix = X_THEME_PREFIX) {
+        let result = {};
+        const keys = includes ? Object.keys(this.colorsProp) : X_THEME_COLOR_KEYS.map((x) => `${prefix}${x}`);
+        keys.forEach((x) => {
+            result[x.replace(prefix, '')] = this.declaration.getPropertyValue(`${x}`).trim();
+        });
+        return result;
+    }
+    getColorsInProperty(colors, prefix = X_THEME_PREFIX) {
+        let result = {};
+        Object.keys(colors).forEach((x) => {
+            result[x] = this.declaration.getPropertyValue(`${prefix}${x}`).trim();
+        });
+        return result;
+    }
+    getColorsTheme(colors) {
+        if (typeof colors === 'undefined')
+            colors = X_THEME_COLORS;
+        else
+            colors = Object.assign({}, X_THEME_COLORS, colors);
+        return colors;
+    }
+    setRoot(color, value, prefix = X_THEME_PREFIX) {
+        let result = {};
+        if (X_THEME_COLOR_KEYS.includes(color)) {
+            for (let amount of X_THEME_AMOUNTS) {
+                if (amount === 0) {
+                    result[`${prefix}${color}`] = value;
+                }
+                else {
+                    result[`${prefix}${color}${this.getSuffix(amount)}`] = toHex(mixColors(amount > 0 ? X_THEME_MERGE : X_THEME_BLACK_MERGE, value, Math.abs(amount)));
+                }
+            }
+        }
+        else {
+            result[`${prefix}${color}`] = value;
+        }
+        return result;
+    }
+    setDarkRoot(color, value, prefix = X_THEME_PREFIX) {
+        let result = {};
+        const allColors = this.setRoot(color, value, '');
+        if (X_THEME_COLOR_KEYS.includes(color) && !['background'].includes(color)) {
+            const allColors = this.setRoot(color, value, prefix);
+            X_THEME_EXCHANGES.forEach((x) => {
+                if (x[1] >= -0.1) {
+                    const curr = this.getSuffix(x[0]);
+                    const next = this.getSuffix(x[1]);
+                    result[`${prefix}${color}${curr}`] = allColors[`${prefix}${color}${next}`];
+                }
+            });
+        }
+        else if (['background'].includes(color)) {
+            result = this.getDefineColors(Object.assign({}, this.getColorsInProperty(X_THEME_COLORS), allColors), '', true);
+        }
+        return result;
+    }
+    getDefineColors(colors, prefix = X_THEME_PREFIX, darken = false) {
+        let result = {};
+        colors = this.getColorsTheme(colors);
+        for (let key in colors) {
+            Object.assign(result, this.setRoot(key, colors[key], prefix));
+        }
+        if (darken) {
+            const colorsFunc = (nums, callback) => {
+                for (let num of nums) {
+                    for (let color in colors) {
+                        if (X_THEME_COLOR_KEYS.includes(color) && !['background'].includes(color)) {
+                            callback(num, color);
+                        }
+                    }
+                }
+            };
+            colorsFunc(X_THEME_BACKGROUNDS, (background, color) => {
+                const theme = this.getSuffix(background);
+                result[`${prefix}${color}${theme}`] = result[`${prefix}background${theme.replace('a', '')}`];
+            });
+            colorsFunc(X_THEME_TEXTS, (text, color) => {
+                const curr = this.getSuffix(text[0]);
+                const next = this.getSuffix(text[1]);
+                result[`${prefix}${color}${curr}`] = result[`${prefix}text${next}`];
+            });
+            colorsFunc(X_THEME_BORDERS, (border, color) => {
+                const curr = this.getSuffix(border[0]);
+                const next = this.getSuffix(border[1]);
+                result[`${prefix}${color}${curr}`] = result[`${prefix}border${next}`];
+            });
+            colorsFunc(X_THEME_EXCHANGES, (exchange, color) => {
+                const curr = this.getSuffix(exchange[0]);
+                const next = this.getSuffix(exchange[1]);
+                result[`${prefix}${color}${curr}`] = result[`${prefix}${color}${next}`];
+            });
+        }
+        return result;
+    }
+    getSuffix(num) {
+        if (num > 0) {
+            return `-${Math.abs(num * 1000)}`;
+        }
+        else if (num < 0) {
+            return `-a${Math.abs(num * 1000)}`;
+        }
+        return '';
+    }
+    createColorsStyle() {
+        if (this.colorsStyleEle)
+            this.renderer2.removeChild(this.colorsStyleEle.parentNode, this.colorsStyleEle);
+        const styles = Object.entries(this.colorsProp)
+            .map((x) => `${x[0]}: ${x[1]};`)
+            .join('');
+        this.colorsStyleEle = this.renderer2.createElement('style');
+        this.colorsStyleEle.innerHTML = `.x-theme-colors{${styles}}`;
+        this.renderer2.addClass(this.doc.documentElement, 'x-theme-colors');
+        this.doc.documentElement.getElementsByTagName('head')[0].appendChild(this.colorsStyleEle);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XThemeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XThemeService, deps: [{ token: DOCUMENT }, { token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XThemeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XThemeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [DOCUMENT]
+                    }] }, { type: i0.RendererFactory2 }];
+    } });
+function mixColors(color1, color2, weight) {
+    let rgb1 = toRgb(color1);
+    let rgb2 = toRgb(color2);
+    let weight1 = weight;
+    let weight2 = 1 - weight;
+    let result;
+    const inRange = (num) => {
+        return num > 255 ? 255 : num < 0 ? 0 : num;
+    };
+    result = {
+        r: inRange(Math.round(rgb1.r * weight1 + rgb2.r * weight2)),
+        g: inRange(Math.round(rgb1.g * weight1 + rgb2.g * weight2)),
+        b: inRange(Math.round(rgb1.b * weight1 + rgb2.b * weight2))
+    };
+    return result;
+}
+function toHex(rgb) {
+    return '#' + ((1 << 24) + (rgb.r << 16) + (rgb.g << 8) + rgb.b).toString(16).slice(1);
+}
+function toRgb(hex) {
+    if (hex.indexOf('#') == 0)
+        hex = hex.slice(1);
+    let num = parseInt(hex, 16);
+    let r = num >> 16;
+    if (r > 255)
+        r = 255;
+    else if (r < 0)
+        r = 0;
+    let g = (num >> 8) & 0x00ff;
+    if (g > 255)
+        g = 255;
+    else if (g < 0)
+        g = 0;
+    let b = num & 0x0000ff;
+    if (b > 255)
+        b = 255;
+    else if (b < 0)
+        b = 0;
+    return { r: r, g: g, b: b };
+}
+
+// tslint:disable no-any
+const isDefined = function (value) {
+    return value !== undefined;
+};
+class XConfigService {
+    constructor(themeService, defaultConfig) {
+        this.componentConfigUpdated$ = new Subject();
+        this.config = defaultConfig || {};
+        if (themeService) {
+            this.themeService = themeService;
+        }
+        this.setInitialTheme(this.config.theme);
+    }
+    getConfigForComponent(componentName) {
+        var _a;
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.components) ? this.config.components[componentName] : undefined;
+    }
+    getConfigChangeEventForComponent(componentName) {
+        return this.componentConfigUpdated$.pipe(filter((n) => n === componentName), mapTo(undefined));
+    }
+    set(componentName, value) {
+        var _a;
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.components) {
+            this.config.components[componentName] = Object.assign(Object.assign({}, this.config.components[componentName]), value);
+            this.componentConfigUpdated$.next(componentName);
+        }
+    }
+    setDarkTheme(theme) {
+        let colors = theme === null || theme === void 0 ? void 0 : theme.colors;
+        if (!colors)
+            colors = X_THEME_DARK_COLORS;
+        this.setTheme({
+            colors: this.themeService.getDefineColors(Object.assign({}, this.themeService.getColorsInProperty(X_THEME_COLORS), colors), '', true)
+        });
+    }
+    setLightTheme(theme) {
+        let colors = theme === null || theme === void 0 ? void 0 : theme.colors;
+        if (!colors)
+            colors = X_THEME_COLORS;
+        this.setTheme({
+            colors: this.themeService.getDefineColors(Object.assign({}, this.themeService.getColorsInProperty(X_THEME_COLORS), colors), '', false)
+        });
+    }
+    setTheme(theme) {
+        this.themeService.setTheme(theme);
+    }
+    setInitialTheme(theme) {
+        this.themeService.setInitialTheme(theme);
+    }
+    getTheme(includesAll = false) {
+        return this.themeService.getTheme(includesAll);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XConfigService, deps: [{ token: XThemeService, optional: true }, { token: X_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: XThemeService, decorators: [{
+                        type: Optional
+                    }] }, { type: undefined, decorators: [{
+                        type: Optional
+                    }, {
+                        type: Inject,
+                        args: [X_CONFIG]
+                    }] }];
+    } });
+// tslint:disable-next-line:typedef
+function XWithConfig(componentName, innerDefaultValue) {
+    return function ConfigDecorator(target, propName, originalDescriptor) {
+        const privatePropName = `$$__assignedValue__${propName}`;
+        Object.defineProperty(target, privatePropName, {
+            configurable: true,
+            writable: true,
+            enumerable: false
+        });
+        return {
+            get() {
+                var _a;
+                const originalValue = originalDescriptor && originalDescriptor.get ? originalDescriptor.get.bind(this)() : this[privatePropName];
+                if (isDefined(originalValue)) {
+                    return originalValue;
+                }
+                const componentConfig = ((_a = this.configService) === null || _a === void 0 ? void 0 : _a.getConfigForComponent(componentName)) || {};
+                const configValue = componentConfig[propName];
+                return isDefined(configValue) ? configValue : innerDefaultValue;
+            },
+            set(value) {
+                if (originalDescriptor && originalDescriptor.set) {
+                    originalDescriptor.set.bind(this)(value);
+                }
+                else {
+                    this[privatePropName] = value;
+                }
+            },
+            configurable: true,
+            enumerable: true
+        };
+    };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { XAddDays, XAddHours, XAddMinutes, XAddMonths, XAddSeconds, XAddYears, XClamp, XClearClass, XCloneDeep, XConfigService, XConnectAnimation, XConnectBaseAnimation, XDataConvert, XDrop, XDropAnimation, XDuration, XFadeAnimation, XGetChildren, XHasIn, XHttpService, XIdentity, XInputBoolean, XInputNumber, XInvertKeyValues, XIsArray, XIsBoolean, XIsChange, XIsDate, XIsEmpty, XIsFunction, XIsNull, XIsNumber, XIsObject, XIsObjectArray, XIsObservable, XIsRegExp, XIsString, XIsTemplateRef, XIsType, XIsUndefined, XIsValue, XIsValueArray, XIsXTemplate, XMoveAnimation, XMoveBoxAnimation, XOrderBy, XPreloadingStrategyService, XProperty, XRemove, XRepositoryAbstract, XRepositoryService, XResize, XReuseStrategyService, XSetData, XSlideAnimation, XSliderAnimation, XStorageService, XThemeService, XToBoolean, XToDataConvert, XToDate, XWithConfig, X_CONFIG, X_THEME, X_THEME_AMOUNTS, X_THEME_BACKGROUNDS, X_THEME_BLACK_MERGE, X_THEME_BORDERS, X_THEME_COLORS, X_THEME_COLOR_KEYS, X_THEME_DARK_COLORS, X_THEME_EXCHANGES, X_THEME_MERGE, X_THEME_PREFIX, X_THEME_TEXTS, chunk, computedStyle, fillDefault, groupBy, guid, mixColors, removeNgTag, reqAnimFrame, setFlex, stripTags, toHex, toRgb, warnIconTypeNotFound, warnSVGTagNotFound };
+//# sourceMappingURL=ng-nest-ui-core.mjs.map