@ng-nest/ui 20.3.5 → 20.3.6

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

@@ -0,0 +1,1773 @@
+import { isObservable, Observable, BehaviorSubject, Subject, of, throwError } from 'rxjs';
+import { coerceCssPixelValue } from '@angular/cdk/coercion';
+import { map, takeUntil, filter } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { booleanAttribute, numberAttribute, InjectionToken, inject, Injectable, input, computed, ChangeDetectionStrategy, ViewEncapsulation, Component } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i1 from '@angular/common/http';
+import * as i1$1 from '@angular/cdk/platform';
+import { DomSanitizer } from '@angular/platform-browser';
+
+/**
+ * @zh_CN 填充默认值
+ * @en_US Fill default values
+ */
+function XFillDefault(option, def) {
+    if (option && def) {
+        for (const key in def) {
+            if (typeof option[key] === 'undefined') {
+                option[key] = def[key];
+            }
+        }
+    }
+}
+
+/**
+ * @zh_CN 删除当前标签，保留内容
+ * @en_US Delete the current label and keep the content
+ */
+function XRemoveNgTag(nativeElement) {
+    const parentElement = nativeElement.parentElement;
+    if (!parentElement || !parentElement.insertBefore)
+        return;
+    while (nativeElement.firstChild) {
+        parentElement.insertBefore(nativeElement.firstChild, nativeElement);
+    }
+    parentElement.removeChild(nativeElement);
+}
+
+/**
+ * @zh_CN svg 标签不存在的警告信息
+ * @en_US Warning information that does not exist in SVG tags
+ */
+function XWarnSVGTagNotFound() {
+    console.warn(`<svg> tag not found.`);
+}
+/**
+ * @zh_CN icon 不存在的警告信息
+ * @en_US Warning information that does not exist in icon
+ */
+function XWarnIconTypeNotFound() {
+    console.warn(`icon type not found.`);
+}
+
+/**
+ * @zh_CN 获取元素的指定样式的计算值
+ * @en_US The calculation value of the specified style of the element
+ */
+function XComputedStyle(element, style) {
+    let computed = XComputed(element);
+    let value = computed[style];
+    return value.replace(/px/g, '');
+}
+/**
+ * @zh_CN 获取元素的计算样式
+ * @en_US Calculation style of obtaining elements
+ */
+function XComputed(element) {
+    if (typeof getComputedStyle === 'function') {
+        return getComputedStyle(element);
+    }
+    return element.style;
+}
+
+// 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();
+}
+const XRequestAnimationFrame = getRequestAnimationFrame();
+
+/**
+ * @zh_CN 去除 HTML 标签
+ * @en_US Remove the html tag
+ */
+function XStripTags(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, '');
+}
+
+/**
+ * @zh_CN 判断值不为 null 或 undefined
+ * @en_US The judgment value is not null or undefined
+ */
+function XIsNotNil(value) {
+    return typeof value !== 'undefined' && value !== null;
+}
+/**
+ * @zh_CN 判断值为 null 或 undefined
+ * @en_US The judgment value is null or undefined
+ */
+function XIsNil(value) {
+    return typeof value === 'undefined' || value === null;
+}
+
+/**
+ * @zh_CN 该函数将字符串中的驼峰命名法转换为减号命名法
+ * - 采用正则表达式匹配字符串中每个连续的大小写字母边界
+ * - 将其替换为小写字母和连字符的组合
+ * - 最后将整个字符串转换为小写
+ * - 例如，`XCamelToKebab('helloWorld')` 将返回 `hello-world`
+ * @en_US This function converts string of hump nomenclature kebab nomenclature
+ * - Use regular expression match each successive lowercase letters in the string boundary
+ * - Replace it with a lower case letters and hyphens
+ * - Finally the whole string converted to lowercase
+ * - For example, `XCamelToKebab('helloWorld')` returns the `hello-world`
+ */
+function XCamelToKebab(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+/**
+ * @zh_CN 该函数将字符串中的减号命名法转换为驼峰命名法
+ * - 使用正则表达式匹配所有连字符后的字母 ( `(\w)` )
+ * - 用 `toUpperCase()` 将这些字母转换为大写
+ * - 替换原字符串中的连字符和小写字母为大写字母
+ * - 例如，`XKebabToCamel('hello-world')` 将返回 `helloWorld`
+ * @en_US This function converts string minus nomenclature of hump nomenclature
+ * - Use a regular expression match all the letter after a hyphen ( `(\w)` )
+ * - Use `toUpperCase()` converts these letters to uppercase
+ * - Replace the original string the hyphen and lowercase letters to uppercase
+ * - For example, `XKebabToCamel('hello-world')` returns `helloWorld`
+ */
+function XKebabToCamel(str) {
+    return str.replace(/-(\w)/g, (_, char) => char.toUpperCase());
+}
+
+/**
+ * @zh_CN 延迟时间
+ * @en_US Delayed sleep
+ */
+function XSleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}
+
+/**
+ * @zh_CN 类型判断
+ * @en_US Type judgment
+ */
+function XIsType(type) {
+    return (object) => Object.prototype.toString.call(object) === `[object ${type}]`;
+}
+/**
+ * @zh_CN 值改变判断
+ * @en_US Value change judgment
+ */
+function XIsChange(...changes) {
+    for (let change of changes) {
+        if (change?.currentValue !== change?.previousValue)
+            return true;
+    }
+    return false;
+}
+const IsString = XIsType('String');
+const IsArray = XIsType('Array');
+const IsNumber = XIsType('Number');
+const IsBoolean = XIsType('Boolean');
+const IsObject = XIsType('Object');
+const IsNull = (value) => value === null;
+const IsFunction = XIsType('Function');
+const IsDate = XIsType('Date');
+const IsRegExp = XIsType('RegExp');
+/**
+ * @zh_CN 判断给定的值是否为字符串类型
+ * @en_US Determine whether the given value is a string type
+ */
+function XIsString(value) {
+    return IsString(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为数组类型
+ * @en_US Determine whether the given value is a array type
+ */
+function XIsArray(value) {
+    return IsArray(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为数字类型
+ * @en_US Determine whether the given value is a number type
+ */
+function XIsNumber(value) {
+    return IsNumber(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为布尔类型
+ * @en_US Determine whether the given value is a boolean type
+ */
+function XIsBoolean(value) {
+    return IsBoolean(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为对象类型
+ * @en_US Determine whether the given value is a object type
+ */
+function XIsObject(value) {
+    return IsObject(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为 null 类型
+ * @en_US Determine whether the given value is a null type
+ */
+function XIsNull(value) {
+    return IsNull(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为函数类型
+ * @en_US Determine whether the given value is a function type
+ */
+function XIsFunction(value) {
+    return IsFunction(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为日期类型
+ * @en_US Determine whether the given value is a date type
+ */
+function XIsDate(value) {
+    return IsDate(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为正则表达式
+ * @en_US Determine whether the given value is a regular expression
+ */
+function XIsRegExp(value) {
+    return IsRegExp(value);
+}
+/**
+ * @zh_CN 判断给定的值是否为 undefined
+ * @en_US Determine whether the given value is undefined
+ */
+function XIsUndefined(value) {
+    return typeof value === 'undefined';
+}
+/**
+ * @zh_CN 判断给定的值是否为字符串、数字、布尔值或日期
+ * @en_US Determine whether the given value is a string, number, Boolean value or date
+ */
+function XIsValue(object) {
+    return XIsString(object) || XIsNumber(object) || XIsBoolean(object) || XIsDate(object);
+}
+/**
+ * @zh_CN 判断一个对象是否为空
+ * @en_US Determine whether an object is empty
+ */
+function XIsEmpty(object) {
+    try {
+        return XIsUndefined(object) || XIsNull(object) || object === '' || object.length === 0;
+    }
+    catch (e) {
+        console.error(object, e);
+    }
+    return true;
+}
+/**
+ * @zh_CN 判断给定的对象是否为非空数组
+ * @en_US Determine whether the given object is a non -empty array
+ */
+function XIsValueArray(object) {
+    return XIsArray(object) && object.length > 0 && !XIsObject(object[0]);
+}
+/**
+ * @zh_CN 判断给定的对象是否为非空对象数组
+ * @en_US Determine whether the given object is a non -empty object array
+ */
+function XIsObjectArray(object) {
+    return XIsArray(object) && object.length > 0 && XIsObject(object[0]);
+}
+/**
+ * @zh_CN 判断给定的对象是否为 Observable
+ * @en_US Determine whether the given object is observable
+ */
+function XIsObservable(object) {
+    return isObservable(object);
+}
+/**
+ * @zh_CN 判断给定的对象是否为 TemplateRef
+ * @en_US Determine whether the given object is TemplateRef
+ */
+function XIsTemplateRef(object) {
+    if (!XIsEmpty(object) && object.elementRef)
+        return true;
+    else
+        return false;
+}
+/**
+ * @zh_CN 判断给定的对象是否为 XTemplateRef
+ * @en_US Determine whether the given object is XTemplateRef
+ */
+function XIsXTemplate(object) {
+    return XIsString(object) || XIsNumber(object) || XIsDate(object) || XIsTemplateRef(object);
+}
+/**
+ * @zh_CN 判断给定的对象是否为 InputSignal
+ * @en_US Determine whether a given object for InputSignal
+ */
+function XIsInputSignal(object) {
+    return XIsFunction(object) && object.name === 'inputValueFn';
+}
+
+/**
+ * @zh_CN 标识对象
+ * @en_US Identify object
+ */
+class XIdentity {
+}
+
+/**
+ * @zh_CN 转换 value 为 boolean 值
+ * @en_US Convert the value to boolean value
+ */
+function XToBoolean(value) {
+    return booleanAttribute(value);
+}
+/**
+ * @zh_CN 转换 value 为像素值
+ * @en_US Convert the value to pixels
+ */
+function XToCssPixelValue(value) {
+    if (!XIsNumber(value) && /^\d+(\.\d+)?$/.test(value)) {
+        return coerceCssPixelValue(Number(value));
+    }
+    else {
+        return coerceCssPixelValue(value);
+    }
+}
+function XToString(value) {
+    return `${value}`;
+}
+function XToNumber(value, fallbackValue) {
+    return numberAttribute(value, fallbackValue);
+}
+/**
+ * @zh_CN 转换 value 为指定的 list 数据 [{ label: any; id: any }, ....]
+ * @en_US Convert value as the specified list data [{ label: any; id: any }, ....]
+ */
+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 x;
+        });
+    }
+    return value;
+}
+/**
+ * @zh_CN 转换 value 为指定的 list 数据 [{ label: any; id: any }, ....]
+ * @en_US Convert value as the specified list data [{ label: any; id: any }, ....]
+ */
+function XToDataArray(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 x;
+        });
+    }
+    return [{ label: value, id: value }];
+}
+/**
+ * @zh_CN 根据 data 的类型获取实际的数据
+ * @en_US Obtain actual data based on the type of data
+ */
+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));
+            }
+        }
+    }).pipe(takeUntil(unSubject));
+}
+/**
+ * @zh_CN 根据 id、pid 获取子节点
+ * @en_US Obtain sub-nodes based on ID and PID
+ */
+function XGetChildren(nodes, node, level) {
+    node.level = level;
+    node.children = nodes.filter((y) => y.pid === node.id);
+    node.leaf = node.children?.length > 0;
+    if (node.leaf)
+        node.children.map((y) => XGetChildren(nodes, y, level + 1));
+    return node;
+}
+/**
+ * @zh_CN 递归检查并设置节点是否具有子节点
+ * @en_US Recursively checks and sets whether nodes have children
+ */
+function XHasChildren(nodes, level) {
+    for (let node of nodes) {
+        node.level = level;
+        node.leaf = node.children && node.children.length > 0;
+        if (node.leaf) {
+            XHasChildren(node.children, level + 1);
+        }
+    }
+    return nodes;
+}
+/**
+ * @zh_CN 将对象键值对反转
+ * @en_US Reversal the key value of the object
+ */
+function XInvertKeyValues(obj) {
+    return Object.keys(obj).reduce((nw, key) => {
+        nw.set(obj[key], key);
+        return nw;
+    }, new Map());
+}
+/**
+ * @zh_CN 设置样式名称为 false
+ * @en_US Set style name is false
+ */
+function XClearClass(...classMaps) {
+    classMaps.forEach((classMap) => {
+        for (const key in classMap) {
+            classMap[key] = false;
+        }
+    });
+}
+/**
+ * @zh_CN 设置样式名称为 false
+ * @en_US Set style name is false
+ */
+function XClearClassSignal(...classMaps) {
+    classMaps.forEach((classMap) => {
+        const value = classMap();
+        for (const key in value) {
+            value[key] = false;
+        }
+        classMap.set(value);
+    });
+}
+/**
+ * @zh_CN 创建属性装饰器的工厂函数
+ * @en_US Factory functions that create attribute decorators
+ */
+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;
+}
+/**
+ * @zh_CN 创建 XInputBoolean 属性装饰器
+ * @en_US Create XInputBoolean Properties
+ */
+function XInputBoolean() {
+    return propDecoratorFactory('XInputBoolean', XToBoolean);
+}
+/**
+ * @zh_CN 创建 XInputNumber 属性装饰器
+ * @en_US Create XInputNumber Properties
+ */
+function XInputNumber() {
+    return propDecoratorFactory('XInputNumber', XToNumber);
+}
+/**
+ * @zh_CN 创建 XInputNumber 属性装饰器
+ * @en_US Create XInputNumber Properties
+ */
+function XInputCssPixelValue() {
+    return propDecoratorFactory('XInputCssPixelValue', XToCssPixelValue);
+}
+/**
+ * @zh_CN 创建 XDataConvert 属性装饰器
+ * @en_US Create XDataConvert Properties
+ */
+function XDataConvert() {
+    return propDecoratorFactory('XDataConvert', XToDataConvert);
+}
+/**
+ * @zh_CN 限制给定数值 value 的范围
+ * @en_US Limit the range of the given value value
+ */
+function XClamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * @zh_CN 转换 Date
+ * @en_US Convert to date
+ */
+function XToDate(date) {
+    if (XIsDate(date) || XIsNumber(date)) {
+        return new Date(date);
+    }
+    else {
+        return new Date(Date.parse(date));
+    }
+}
+/**
+ * @zh_CN 日期添加毫秒数，负数为减少
+ * @en_US Add milliseconds to the date, the negative number is reduced
+ */
+function XAddMilliseconds(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        return new Date(dt.getTime() + amount);
+    }
+    else {
+        return date;
+    }
+}
+/**
+ * @zh_CN 日期添加秒数，负数为减少
+ * @en_US Date adds seconds, the negative number is reduced
+ */
+function XAddSeconds(date, amount) {
+    return XAddMilliseconds(date, amount * 1000);
+}
+/**
+ * @zh_CN 日期添加分钟数，负数为减少
+ * @en_US Date adds minutes, the negative number is reduced
+ */
+function XAddMinutes(date, amount) {
+    return XAddMilliseconds(date, amount * 60000);
+}
+/**
+ * @zh_CN 日期添加小时数，负数为减少
+ * @en_US Date adds hours, the negative number is reduced
+ */
+function XAddHours(date, amount) {
+    return XAddMilliseconds(date, amount * 3600000);
+}
+/**
+ * @zh_CN 日期添加天数，负数为减少
+ * @en_US Date adds days, the negative number is reduced
+ */
+function XAddDays(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        dt.setDate(dt.getDate() + amount);
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+/**
+ * @zh_CN 日期添加月数，负数为减少
+ * @en_US Date adds monthly number, negative number is reduced
+ */
+function XAddMonths(date, amount) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf()) && amount) {
+        const day = dt.getDate();
+        const month = dt.getMonth();
+        const endMonth = new Date(dt);
+        endMonth.setMonth(month + amount + 1, 0);
+        const endDay = endMonth.getDate();
+        if (day >= endDay) {
+            return endMonth;
+        }
+        else {
+            dt.setFullYear(endMonth.getFullYear(), endMonth.getMonth(), day);
+        }
+        return dt;
+    }
+    else {
+        return date;
+    }
+}
+/**
+ * @zh_CN 日期添加年数，负数为减少
+ * @en_US The number of years of date, the negative number is reduced
+ */
+function XAddYears(date, amount) {
+    return XAddMonths(date, amount * 12);
+}
+/**
+ * @zh_CN 获取给定日期的 ISO 周数
+ * @en_US Get the number of ISO weeks of the given date
+ */
+function XDateWeek(date) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf())) {
+        return getISOWeek(dt);
+    }
+    return;
+}
+/**
+ * @zh_CN 获取指定日期的 ISO 周年份
+ * @en_US Get the ISO anniversary of the specified date
+ */
+function XDateWeekYear(date) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf())) {
+        return getISOWeekYear(dt);
+    }
+    return;
+}
+/**
+ * @zh_CN 获取指定日期的年份和周数
+ * @en_US Get the year and week of the specified date
+ */
+function XDateYearWeek(date) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf())) {
+        return `${getISOWeekYear(dt)}-${getISOWeek(dt)}`;
+    }
+    return '';
+}
+/**
+ * @zh_CN 获取指定日期的年份和季度
+ * @en_US Get the year and quarter of the specified date
+ */
+function XDateYearQuarter(date) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf())) {
+        return `${dt.getFullYear()}-${XDateQuarter(dt)}`;
+    }
+    return '';
+}
+/**
+ * @zh_CN 获取指定日期所属的季度
+ * @en_US Get the season when the specified date belongs
+ */
+function XDateQuarter(date) {
+    let dt = XToDate(date);
+    if (!isNaN(dt.valueOf())) {
+        return `Q${Math.ceil((dt.getMonth() + 1) / 3)}`;
+    }
+    return '';
+}
+/**
+ * @zh_CN 获取给定日期的 ISO 周数
+ * @en_US Get the number of ISO weeks of the given date
+ */
+function getISOWeek(date) {
+    const diff = startOfISOWeek(date).getTime() - startOfISOWeekYear(date).getTime();
+    return Math.round(diff / 604800000) + 1;
+}
+/**
+ * @zh_CN 获取给定日期所在 ISO 周的开始日期
+ * @en_US The start date of the ISO week where the given date is located
+ */
+function startOfISOWeek(date) {
+    return startOfWeek(date, { weekStartsOn: 1 });
+}
+/**
+ * @zh_CN 获取给定日期所在周的开始日期
+ * @en_US The start date of the ISO week where the given date is located
+ */
+function startOfWeek(date, options) {
+    const weekStartsOn = options?.weekStartsOn || 0;
+    const day = date.getDay();
+    const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+    date.setDate(date.getDate() - diff);
+    date.setHours(0, 0, 0, 0);
+    return date;
+}
+/**
+ * @zh_CN 获取给定日期所在 ISO 周年的起始日期
+ * @en_US The start date of the ISO anniversary where the given date is located
+ */
+function startOfISOWeekYear(date) {
+    const year = getISOWeekYear(date);
+    const fourthOfJanuary = constructFrom(date, 0);
+    fourthOfJanuary.setFullYear(year, 0, 4);
+    fourthOfJanuary.setHours(0, 0, 0, 0);
+    const result = startOfISOWeek(fourthOfJanuary);
+    return result;
+}
+/**
+ * @zh_CN 返回一个与传入的 date 参数类型相同的对象
+ * @en_US Return to an object of the same type of Date parameter.
+ */
+function constructFrom(date, value) {
+    if (date instanceof Date) {
+        return new date.constructor(value);
+    }
+    else {
+        return new Date(value);
+    }
+}
+/**
+ * @zh_CN 获取给定日期的 ISO 周年份
+ * @en_US Obtain the ISO anniversary of the given date
+ */
+function getISOWeekYear(date) {
+    const year = date.getFullYear();
+    const fourthOfJanuaryOfNextYear = constructFrom(date, 0);
+    fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
+    fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
+    const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
+    const fourthOfJanuaryOfThisYear = constructFrom(date, 0);
+    fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
+    fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
+    const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
+    if (date.getTime() >= startOfNextYear.getTime()) {
+        return year + 1;
+    }
+    else if (date.getTime() >= startOfThisYear.getTime()) {
+        return year;
+    }
+    else {
+        return year - 1;
+    }
+}
+
+/**
+ * @zh_CN 用于设置元素的 flex 样式
+ * @en_US Flex style for setting elements
+ */
+function XSetFlex(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;
+}
+
+/**
+ * @zh_CN 通过参数 n 来截取数组
+ * 如果 n 未定义或为 0，则返回与原数组相同的数组
+ * 如果原数组长度小于 1 或小于等于 n 的绝对值，则返回一个空数组
+ * 如果 n 大于 0，则截取从第 n 个元素开始到数组末尾的子数组
+ * 如果 n 小于等于 0，则截取从第 0 个元素到倒数第 n 个元素
+ * @en_US Send the array by parameter n
+ * If n is not defined or 0, returns the same array as the original array
+ * If the original array length is less than 1 or less than equal to N, return a empty array
+ * If n is greater than 0, cut off the sub-array starting from the nn element to the end of the array
+ * If n is less than or equal to 0, cut off from the 0th element to the countless nary element
+ */
+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);
+}
+
+/**
+ * @zh_CN 从数组中移除满足条件的元素，并返回被移除的元素组成的数组
+ * @en_US Remove elements that meet the conditions from the array and return the array of the removal element
+ */
+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;
+}
+
+/**
+ * @zh_CN 根据指定元素来排序
+ * @en_US Sort by specified elements
+ */
+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;
+            }
+        }
+        let isNumber = !isNaN(a[prop]);
+        if (order === 'desc') {
+            if (isNumber) {
+                return (b[prop] - a[prop]);
+            }
+            else {
+                if (b[prop] > a[prop]) {
+                    return 1;
+                }
+                else {
+                    return -1;
+                }
+            }
+        }
+        else {
+            if (isNumber) {
+                return (a[prop] - b[prop]);
+            }
+            else {
+                if (a[prop] > b[prop]) {
+                    return 1;
+                }
+                else {
+                    return -1;
+                }
+            }
+        }
+    }
+    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;
+}
+
+/**
+ * @zh_CN 该函数是一个深拷贝函数，用于克隆一个对象或数组
+ * 它会递归地复制对象的所有属性，包括嵌套对象和数组，生成一个全新的独立副本。
+ * 对于非对象和非数组类型的值，直接返回该值。
+ * 函数接受一个参数 value，表示需要进行深拷贝的值。
+ * 首先创建一个空的结果对象 result，如果 value 是数组，则 result 也是一个空数组。
+ * 遍历 value 的所有属性，如果属性是对象，则递归调用 XCloneDeep 函数进行深拷贝，并将结果赋值给 result 对应的属性。
+ * 最后返回 result，即深拷贝后的对象或数组。
+ * @en_US This function is a deep copy function that is used for a cloning object or array
+ * It will recover all the attributes of the object, including nested objects and array, and generate a new independent copy.
+ * For non object and non -array type values, return that value directly.
+ * The function accepts a parameter Value, indicating that the value of deep copy needs to be performed.
+ * First create a empty result object Result. If Value is an array, Result is also an empty array.
+ * It traverses all the attributes of Value. If the attribute is an object, the recursively calls the XCLONEDEEP function for deep copy, and assign the result to the corresponding attributes corresponding to Result.
+ * Finally return to Result, that is, the object or array after the deep copy.
+ */
+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;
+}
+
+/**
+ * @zh_CN 判断一个对象是否包含指定的属性
+ * @en_US Determine whether an object contains the specified attribute
+ */
+function XHasIn(object, key) {
+    return object != null && key in Object(object);
+}
+
+/**
+ * @zh_CN 该函数用于将给定的数组拆分成多个小数组
+ * 每个小数组的长度由函数的第二个参数指定，默认为 1。
+ * 如果给定的数组为空或者小数组长度小于等于 0，则函数返回一个空数组。
+ * 函数通过循环遍历给定的数组，并使用 slice 方法将数组拆分成小数组，然后将小数组添加到结果数组中，最后返回结果数组。
+ * @en_US This function is used to split the given array into multiple decimal arrays
+ * The length of each decimal array is specified by the second parameter of the function, and the default is 1.
+ * If the given array is empty or the length of the decimal array is less than equal to 0, the function returns a empty array.
+ * The function traverses the given array by circulating, and uses the Slice method to split the array into a decimal array,
+ * then add the decimal array to the result array, and finally return the result array.
+ */
+function XChunk(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;
+}
+
+/**
+ * @zh_CN 生成 GUID
+ * @en_US GUID
+ */
+function XGuid() {
+    let S4 = () => {
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    };
+    return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+}
+
+/**
+ * @zh_CN 根据属性 name 或迭代函数来对数组分组
+ * @en_US Groups the elements of an array based on a property name or iteratee function
+ * @param array 需要分组的数组
+ * @param key 属性名或迭代函数
+ * @returns 分组后的对象，键为分组依据的值，值为属于该组的元素数组
+ */
+function XGroupBy(array, key) {
+    const groups = {};
+    array.forEach((item) => {
+        const groupKey = typeof key === 'function' ? String(key(item)) : String(item[key]);
+        if (!groups[groupKey]) {
+            groups[groupKey] = [];
+        }
+        groups[groupKey].push(item);
+    });
+    return groups;
+}
+
+/**
+ * @zh_CN 这个函数的功能是创建一个Observable，用于监听多个元素的尺寸变化
+ * @en_US The function of this function is to create an Observable to monitor the size changes of multiple elements.
+ */
+function XResize(...element) {
+    return new Observable((x) => {
+        if (typeof ResizeObserver !== 'function') {
+            return;
+        }
+        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);
+        }
+    });
+}
+
+/**
+ * @zh_CN 获取元素的父节点路径
+ * @en_US The parent node of the element
+ */
+function XParentPath(ele) {
+    let path = [];
+    let nowEle = ele;
+    while (nowEle.parentNode != null) {
+        path.push(nowEle.localName);
+        nowEle = nowEle.parentNode;
+    }
+    return path;
+}
+/**
+ * @zh_CN 获取元素的父元素路径
+ * @en_US The parent element path of obtaining elements
+ */
+function XParents(ele) {
+    let res = [];
+    let nowEle = ele;
+    while (nowEle.parentElement != null) {
+        res.push(nowEle.parentElement);
+        nowEle = nowEle.parentNode;
+    }
+    return res;
+}
+
+const X_CONFIG = new InjectionToken('x-config');
+
+const X_THEME = new InjectionToken('xTheme');
+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_LIGHT_COLORS = {
+    text: '#333333',
+    border: '#efefef',
+    background: '#ffffff'
+};
+const X_THEME_DARK_COLORS = {
+    text: '#dddddd',
+    border: '#363636',
+    background: '#1e1e1e'
+};
+const X_THEME_COLORS = {
+    primary: '#3B82F6',
+    success: '#67c23a',
+    warning: '#e6a23c',
+    danger: '#f56c6c',
+    info: '#909399',
+    ...X_THEME_LIGHT_COLORS
+};
+const X_THEME_VARS = {
+    black: '#000000',
+    white: '#ffffff',
+    fontSize: '0.875rem',
+    fontSizeMini: '0.75rem',
+    fontSizeSmall: '0.875rem',
+    fontSizeMedium: '1rem',
+    fontSizeLarge: '1.25rem',
+    fontSizeBig: '1.5rem',
+    fontVariant: 'tabular-nums',
+    fontFamily: '-appleSystem, SF UI Text, Arial, PingFang SC, Hiragino Sans GB, Microsoft YaHei, WenQuanYi Micro Hei, sansSerif',
+    fontCodeFamily: 'SFMono-Regular, Consolas, Liberation Mono, Menlo, Courier, monospace',
+    lineHeight: '1.75rem',
+    heightBig: '2.75rem',
+    heightLarge: '2.5rem',
+    heightMedium: '2.25rem',
+    heightSmall: '2rem',
+    heightMini: '1.75rem',
+    paddingBig: '1.5rem',
+    paddingLarge: '1.25rem',
+    paddingMedium: '1rem',
+    paddingSmall: '0.75rem',
+    paddingMini: '0.5rem',
+    borderStyle: 'solid',
+    borderRadius: '0.75rem',
+    borderSmallRadius: '0.5rem',
+    borderWidth: '0.0625rem',
+    borderDeepWidth: '0.125rem',
+    boxShadow: '0 0.0625rem 0.25rem 0.0625rem rgba(0, 0, 0, 0.15)',
+    boxShadowHover: '0 0.0625rem 0.25rem 0.0625rem rgba(0, 0, 0, 0.3)',
+    boxShadowTop: '0 -0.0625rem 0.25rem rgba(0, 0, 0, 0.15)',
+    boxShadowRight: '0.0625rem 0 0.25rem rgba(0, 0, 0, 0.15)',
+    boxShadowBottom: '0 0.0625rem 0.25rem rgba(0, 0, 0, 0.15)',
+    boxShadowLeft: '-0.0625rem 0 0.25rem rgba(0, 0, 0, 0.15)',
+    animationDurationSlow: '0.3s',
+    animationDurationBase: '0.2s',
+    animationDurationFast: '0.1s'
+};
+const X_THEME_COLOR_KEYS = Object.keys(X_THEME_COLORS);
+const X_THEME_VARS_KEYS = Object.keys(X_THEME_VARS);
+
+class XThemeService {
+    constructor(factory) {
+        this.factory = factory;
+        this.colorsProp = {};
+        this.varsProp = {};
+        this.doc = inject(DOCUMENT);
+        this.changed = new BehaviorSubject('light');
+        this.renderer2 = this.factory.createRenderer(null, null);
+        this.declaration = XComputed(this.doc.documentElement);
+    }
+    setInitialTheme(theme) {
+        this.setVars(theme?.vars);
+        if (theme?.vars)
+            Object.assign(X_THEME_VARS, theme.vars);
+        this.setColors(theme?.colors);
+        if (theme?.colors)
+            Object.assign(X_THEME_COLORS, theme.colors);
+        if (theme?.dark) {
+            this.setDark(true);
+        }
+    }
+    setTheme(theme) {
+        this.setColors(theme?.colors);
+        this.setVars(theme?.vars);
+        this.setDark(theme?.dark);
+    }
+    getTheme(includesAll = false) {
+        return {
+            colors: this.getColors(includesAll),
+            vars: this.getVars()
+        };
+    }
+    setColors(colors) {
+        colors = this.getColorsTheme(colors);
+        for (let key in colors) {
+            Object.assign(this.colorsProp, this.setColorRoot(key, colors[key]));
+        }
+        this.createColorsStyle();
+    }
+    setDark(dark) {
+        const colors = this.getColors();
+        if (dark === true) {
+            Object.assign(colors, X_THEME_DARK_COLORS);
+            this.setDarkColors(colors);
+            this.changed.next('dark');
+        }
+        else if (dark === false) {
+            Object.assign(colors, X_THEME_LIGHT_COLORS);
+            this.setColors(colors);
+            this.changed.next('light');
+        }
+        return colors;
+    }
+    setDarkColors(colors) {
+        this.colorsProp = this.getDefineColors(colors, X_THEME_PREFIX, true);
+        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) => {
+            const key = x.replace(prefix, '');
+            result[x.replace(prefix, '')] = this.declaration.getPropertyValue(`${x}`).trim() ?? X_THEME_COLORS[key];
+        });
+        return result;
+    }
+    getVars(prefix = X_THEME_PREFIX) {
+        let result = {};
+        const keys = Object.keys(this.varsProp);
+        keys.forEach((x) => {
+            result[XKebabToCamel(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;
+    }
+    setColorRoot(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)}`] = XToHex(XMixColors(amount > 0 ? X_THEME_MERGE : X_THEME_BLACK_MERGE, value, Math.abs(amount)));
+                }
+            }
+        }
+        else {
+            result[`${prefix}${color}`] = value;
+        }
+        return result;
+    }
+    setDarkColorRoot(color, value, prefix = X_THEME_PREFIX) {
+        let result = {};
+        let allColors = this.setColorRoot(color, value, '');
+        if (X_THEME_COLOR_KEYS.includes(color)) {
+            allColors = this.setColorRoot(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.setColorRoot(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 '';
+    }
+    setVarRoot(va, value, prefix = X_THEME_PREFIX) {
+        let result = {};
+        result[`${prefix}${XCamelToKebab(va)}`] = value;
+        return result;
+    }
+    setVars(vars) {
+        if (typeof vars === 'undefined')
+            vars = X_THEME_VARS;
+        else
+            vars = Object.assign({}, X_THEME_VARS, vars);
+        for (let key in vars) {
+            Object.assign(this.varsProp, this.setVarRoot(key, vars[key]));
+        }
+        this.createVarsStyle();
+    }
+    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);
+    }
+    createVarsStyle() {
+        if (this.varsStyleEle)
+            this.renderer2.removeChild(this.varsStyleEle.parentNode, this.varsStyleEle);
+        const styles = Object.entries(this.varsProp)
+            .map((x) => `${x[0]}: ${x[1]};`)
+            .join('');
+        this.varsStyleEle = this.renderer2.createElement('style');
+        this.varsStyleEle.innerHTML = `:root{${styles}}`;
+        this.doc.documentElement.getElementsByTagName('head')[0].appendChild(this.varsStyleEle);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XThemeService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XThemeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }] });
+/**
+ * @zh_CN 根据权重混合2种颜色
+ * @en_US Mix 2 colors according to heavy weights
+ */
+function XMixColors(color1, color2, weight) {
+    let rgb1 = XToRgb(color1);
+    let rgb2 = XToRgb(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;
+}
+/**
+ * @zh_CN RGB 颜色转换为 Hex
+ * @en_US RGB color converts to hex
+ */
+function XToHex(rgb) {
+    return '#' + ((1 << 24) + (rgb.r << 16) + (rgb.g << 8) + rgb.b).toString(16).slice(1);
+}
+/**
+ * @zh_CN Hex 颜色转换为 RGB
+ * @en_US Hex color converts to RGB
+ */
+function XToRgb(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 };
+}
+
+class XConfigService {
+    constructor() {
+        this.componentConfigUpdated$ = new Subject();
+        this.defaultConfig = inject(X_CONFIG, { optional: true });
+        this.themeService = inject(XThemeService, { optional: true });
+        this.config = this.defaultConfig || {};
+        this.setInitialTheme(this.config.theme);
+    }
+    getConfigForComponent(componentName) {
+        return this.config?.components ? this.config.components[componentName] : undefined;
+    }
+    getConfigChangeEventForComponent(componentName) {
+        return this.componentConfigUpdated$.pipe(filter((n) => n === componentName), map(() => undefined));
+    }
+    set(componentName, value) {
+        if (this.config?.components) {
+            this.config.components[componentName] = {
+                ...this.config.components[componentName],
+                ...value
+            };
+            this.componentConfigUpdated$.next(componentName);
+        }
+    }
+    setDarkTheme() {
+        return this.themeService.setDark(true);
+    }
+    setLightTheme() {
+        return this.themeService.setDark(false);
+    }
+    setTheme(theme) {
+        this.themeService.setTheme(theme);
+    }
+    setInitialTheme(theme) {
+        this.themeService.setInitialTheme(theme);
+    }
+    getTheme(includesAll = false) {
+        return this.themeService.getTheme(includesAll);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * @zh_CN 组件公共属性
+ * @en_US Component of public properties
+ */
+class XProperty {
+}
+/**
+ * @zh_CN 组件公共属性，通过函数返回，注入全局配置
+ * @en_US Component of public properties, through the function returns, into the global configuration
+ */
+function XPropertyFunction(configName) {
+    return class XPropertyFun {
+        constructor() {
+            this.config = inject(XConfigService).getConfigForComponent(configName);
+        }
+    };
+}
+
+/**
+ * @zh_CN 转换 csspx 为像素宽度
+ * @en_US Convert CSS PX to pixel width
+ */
+function XToCssPx(csspx, fontSize) {
+    if (csspx === '0')
+        return 0;
+    if (XIsNumber(csspx))
+        return Number(csspx);
+    else if (csspx.endsWith('rem'))
+        return Number(csspx.replace(/rem/g, '')) * fontSize;
+    else if (csspx.endsWith('px'))
+        return Number(csspx.replace(/px/g, ''));
+    return 0;
+}
+
+/**
+ * @zh_CN 转换 css 为 rem 宽度
+ * @en_US Convert CSS to pixel width
+ */
+function XToCssRem(css, fontSize) {
+    if (css === '0')
+        return 0;
+    if (XIsNumber(css))
+        return Number(css);
+    else if (css.endsWith('rem'))
+        return Number(css.replace(/rem/g, ''));
+    else if (css.endsWith('px'))
+        return Number(css.replace(/px/g, '')) / fontSize;
+    return 0;
+}
+
+/**
+ * @zh_CN 将字节大小转换为人类可读的文件大小格式
+ * @en_US Convert byte size to a human-readable file size format
+ * @param bytes - 文件大小的字节数，可以是数字或字符串类型
+ * @param options - 配置选项对象
+ * @param options.precision - 转换后数值的小数位数，默认为2位
+ * @returns 格式化后的文件大小字符串，如 "1.25 MB"，如果输入无效则返回 "Invalid size"
+ */
+function XFileSize(bytes, options = {}) {
+    const { precision = 2 } = options;
+    const byteUnits = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    if (!bytes || bytes === 0) {
+        return `0 ${'B'}`;
+    }
+    const bytesValue = typeof bytes === 'string' ? parseFloat(bytes) : bytes;
+    if (isNaN(bytesValue) || bytesValue < 0) {
+        return 'Invalid size';
+    }
+    const value = bytesValue;
+    const base = 1024;
+    const units = byteUnits;
+    const i = Math.floor(Math.log(value) / Math.log(base));
+    const unitIndex = Math.min(Math.max(i, 0), units.length - 1);
+    const formattedValue = (value / Math.pow(base, unitIndex)).toFixed(precision);
+    const cleanValue = parseFloat(formattedValue).toString();
+    return `${cleanValue} ${units[unitIndex]}`;
+}
+
+class XReuseStrategyService {
+    static { this.storages = []; }
+    shouldDetach(_route) {
+        return true;
+    }
+    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);
+    }
+    shouldAttach(route) {
+        return !!XReuseStrategyService.storages.find((x) => x.id == this.getRouteUrl(route));
+    }
+    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 }];
+    }
+}
+
+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 */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XPreloadingStrategyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XPreloadingStrategyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XPreloadingStrategyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class XHttpService {
+    constructor(http) {
+        this.http = http;
+        this.api = '';
+    }
+    get(url, params) {
+        return this.request('GET', url, params);
+    }
+    post(url, params) {
+        return this.request('POST', url, params);
+    }
+    put(url, params) {
+        return this.request('PUT', url, params);
+    }
+    delete(url, params) {
+        return this.request('DELETE', url, params);
+    }
+    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);
+        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);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XHttpService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XHttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XHttpService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+class XStorageService {
+    constructor(platform) {
+        this.platform = platform;
+    }
+    getLocal(key) {
+        if (this.platform.isBrowser) {
+            let str = localStorage.getItem(key);
+            try {
+                return JSON.parse(localStorage.getItem(key) || 'null') || null;
+            }
+            catch (_e) {
+                return str;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    setLocal(key, value) {
+        if (this.platform.isBrowser) {
+            if (XIsString(value)) {
+                localStorage.setItem(key, value);
+            }
+            else {
+                localStorage.setItem(key, JSON.stringify(value));
+            }
+        }
+    }
+    getSession(key) {
+        if (this.platform.isBrowser) {
+            let str = localStorage.getItem(key);
+            try {
+                return JSON.parse(sessionStorage.getItem(key) || 'null') || null;
+            }
+            catch (_e) {
+                return str;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    setSession(key, value) {
+        if (this.platform.isBrowser) {
+            sessionStorage.setItem(key, JSON.stringify(value));
+        }
+    }
+    removeLocal(key) {
+        if (this.platform.isBrowser) {
+            localStorage.removeItem(key);
+        }
+    }
+    removeSession(key) {
+        if (this.platform.isBrowser) {
+            sessionStorage.removeItem(key);
+        }
+    }
+    guid() {
+        let S4 = () => {
+            return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+        };
+        return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XStorageService, deps: [{ token: i1$1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1$1.Platform }] });
+
+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}`);
+    }
+}
+
+class XInnerHTMLComponent {
+    constructor() {
+        this.html = input.required(...(ngDevMode ? [{ debugName: "html" }] : []));
+        this.style = input(...(ngDevMode ? [undefined, { debugName: "style" }] : []));
+        this.innerHtml = computed(() => this.domSanitizer.bypassSecurityTrustHtml(this.html()), ...(ngDevMode ? [{ debugName: "innerHtml" }] : []));
+        this.domSanitizer = inject(DomSanitizer);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XInnerHTMLComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.5", type: XInnerHTMLComponent, isStandalone: true, selector: "[x-inner-html], x-inner-html", inputs: { html: { classPropertyName: "html", publicName: "html", isSignal: true, isRequired: true, transformFunction: null }, style: { classPropertyName: "style", publicName: "style", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<div class="x-inner-html" [innerHTML]="innerHtml()" [style]="style()"></div>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.5", ngImport: i0, type: XInnerHTMLComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: `[x-inner-html], x-inner-html`,
+                    template: '<div class="x-inner-html" [innerHTML]="innerHtml()" [style]="style()"></div>',
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { html: [{ type: i0.Input, args: [{ isSignal: true, alias: "html", required: true }] }], style: [{ type: i0.Input, args: [{ isSignal: true, alias: "style", required: false }] }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { XAddDays, XAddHours, XAddMilliseconds, XAddMinutes, XAddMonths, XAddSeconds, XAddYears, XCamelToKebab, XChunk, XClamp, XClearClass, XClearClassSignal, XCloneDeep, XComputed, XComputedStyle, XConfigService, XDataConvert, XDateQuarter, XDateWeek, XDateWeekYear, XDateYearQuarter, XDateYearWeek, XDrop, XFileSize, XFillDefault, XGetChildren, XGroupBy, XGuid, XHasChildren, XHasIn, XHttpService, XIdentity, XInnerHTMLComponent, XInputBoolean, XInputCssPixelValue, XInputNumber, XInvertKeyValues, XIsArray, XIsBoolean, XIsChange, XIsDate, XIsEmpty, XIsFunction, XIsInputSignal, XIsNil, XIsNotNil, XIsNull, XIsNumber, XIsObject, XIsObjectArray, XIsObservable, XIsRegExp, XIsString, XIsTemplateRef, XIsType, XIsUndefined, XIsValue, XIsValueArray, XIsXTemplate, XKebabToCamel, XMixColors, XOrderBy, XParentPath, XParents, XPreloadingStrategyService, XProperty, XPropertyFunction, XRemove, XRemoveNgTag, XRepositoryAbstract, XRepositoryService, XRequestAnimationFrame, XResize, XReuseStrategyService, XSetData, XSetFlex, XSleep, XStorageService, XStripTags, XThemeService, XToBoolean, XToCssPixelValue, XToCssPx, XToCssRem, XToDataArray, XToDataConvert, XToDate, XToHex, XToNumber, XToRgb, XToString, XWarnIconTypeNotFound, XWarnSVGTagNotFound, 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_LIGHT_COLORS, X_THEME_MERGE, X_THEME_PREFIX, X_THEME_TEXTS, X_THEME_VARS, X_THEME_VARS_KEYS };
+//# sourceMappingURL=ng-nest-ui-core.mjs.map