function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_without_holes(arr) {
    if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _iterable_to_array(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _to_consumable_array(arr) {
    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
/* eslint-disable @typescript-eslint/no-unused-expressions */ /* eslint-disable @typescript-eslint/ban-types */ /**
 * @fileoverview 图表插件工具函数文件
 *
 * 该文件提供了图表数据处理、格式化、转换等工具函数。
 * 包括数字格式化、数据验证、排序、查找等功能。
 *
 * @author md-editor
 * @version 1.0.0
 * @since 2024
 */ /**
 * 创建一个新的 `Intl.NumberFormat` 实例，用于将数字格式化为美国英语的十进制格式。
 *
 * @constant
 * @type {Intl.NumberFormat}
 * @default
 * @example
 * const formattedNumber = intl.format(1234567.89);
 * console.log(formattedNumber); // 输出: "1,234,567.89"
 */ var intl = new Intl.NumberFormat('en-US', {
    style: 'decimal'
});
/**
 * 将数字或字符串格式化为字符串。
 *
 * @param value - 要格式化的值，可以是字符串或数字。
 * @returns 格式化后的字符串。如果输入值为字符串，则直接返回该字符串；
 *          如果输入值为数字，则使用 `intl.format` 方法格式化后返回；
 *          如果输入值为空或格式化过程中发生错误，则返回原始值。
 */ export var stringFormatNumber = function stringFormatNumber(value) {
    if (!value) return value;
    try {
        if (typeof value === 'string') return value;
        if (typeof value === 'number') {
            return intl.format(Number(value));
        }
        return value;
    } catch (error) {
        return value;
    }
};
/**
 * 防抖函数
 *
 * 创建一个防抖函数，该函数会在调用后等待指定的延迟时间，
 * 如果在延迟时间内再次调用，则重新开始计时。
 * 常用于限制函数调用频率，如搜索输入、窗口调整等场景。
 *
 * @param {Function} func - 要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数，包含以下方法：
 *   - `flush()`: 立即执行函数并清除定时器
 *   - `cancel()`: 取消延迟执行
 *
 * @example
 * ```typescript
 * const debouncedSearch = debounce((query: string) => {
 *   console.log('搜索:', query);
 * }, 300);
 *
 * // 调用防抖函数
 * debouncedSearch('hello');
 * debouncedSearch('world'); // 只有这个会执行
 *
 * // 立即执行
 * debouncedSearch.flush();
 *
 * // 取消执行
 * debouncedSearch.cancel();
 * ```
 *
 * @since 1.0.0
 */ export function debounce(func, delay) {
    var timer = null;
    var fn = function fn() {
        var _this = this, _arguments = arguments;
        clearTimeout(timer);
        timer = setTimeout(function() {
            //@ts-ignore
            func.apply(_this, _arguments);
        }, delay);
    };
    fn.flush = function() {
        clearTimeout(timer);
        //@ts-ignore
        func.apply(this, arguments);
    };
    fn.cancel = function() {
        clearTimeout(timer);
    };
    return fn;
}
/** 1 亿（人民币口语单位）对应的「元」数量 */ var CHINESE_YI_TO_YUAN = 1e8;
/** 1 万对应的「元」数量 */ var CHINESE_WAN_TO_YUAN = 1e4;
/**
 * 将含「亿元 / 万元 / 元」的人民币口语字符串转为数值（以「元」为数值单位）。
 *
 * - `533亿元` → `533 * 1e8`
 * - `549万元` → `549 * 1e4`
 * - `128.5元` → `128.5`
 *
 * 不含上述单位且无法识别为纯数字时返回 `null`，避免误解析如 `8%`。
 *
 * @param value - 原始单元格或字段值
 * @returns 解析后的有限数字，无法解析则为 `null`
 */ export var parseChineseCurrencyToNumber = function parseChineseCurrencyToNumber(value) {
    if (value === null || value === undefined) return null;
    if (typeof value === 'number') {
        return Number.isFinite(value) ? value : null;
    }
    if (typeof value !== 'string') return null;
    var s = value.trim();
    if (!s) return null;
    s = s.replace(/,/g, '').replace(/，/g, '').replace(/[￥¥\s]/g, '');
    var yi = s.match(/(-?\d+(?:\.\d+)?)\s*亿/);
    if (yi) {
        var n = parseFloat(yi[1]);
        return Number.isFinite(n) ? n * CHINESE_YI_TO_YUAN : null;
    }
    var wan = s.match(/(-?\d+(?:\.\d+)?)\s*万/);
    if (wan) {
        var n1 = parseFloat(wan[1]);
        return Number.isFinite(n1) ? n1 * CHINESE_WAN_TO_YUAN : null;
    }
    var yuan = s.match(/(-?\d+(?:\.\d+)?)\s*元/);
    if (yuan) {
        var n2 = parseFloat(yuan[1]);
        return Number.isFinite(n2) ? n2 : null;
    }
    return null;
};
/**
 * 归一化 X 轴值
 *
 * 将字符串数字转换为数字类型，避免重复标签问题。
 * 如果输入已经是数字，直接返回；如果是字符串，尝试转换为数字。
 * 转换失败时返回原始值。
 *
 * @param {number | string} value - 原始 X 轴值
 * @returns {number | string} 归一化后的值
 *
 * @example
 * ```typescript
 * normalizeXValue(123); // 123
 * normalizeXValue('456'); // 456
 * normalizeXValue('abc'); // 'abc'
 * normalizeXValue(''); // ''
 * ```
 *
 * @since 1.0.0
 */ export var normalizeXValue = function normalizeXValue(value) {
    if (typeof value === 'number') return value;
    var s = String(value).trim();
    if (s === '') return value;
    var n = Number(s);
    if (Number.isFinite(n)) return n;
    var cn = parseChineseCurrencyToNumber(s);
    return cn !== null ? cn : value;
};
/**
 * 比较两个 X 轴值的大小
 *
 * 用于对 X 轴值进行排序，支持数字和字符串的混合比较。
 * 比较规则：
 * 1. 数字优先于字符串
 * 2. 数字按数值大小比较
 * 3. 字符串按字典序比较
 *
 * @param {number | string} a - 第一个值
 * @param {number | string} b - 第二个值
 * @returns {number} 比较结果：负数表示 a < b，0 表示 a = b，正数表示 a > b
 *
 * @example
 * ```typescript
 * compareXValues(1, 2); // -1
 * compareXValues('a', 'b'); // -1
 * compareXValues(1, 'a'); // -1 (数字优先)
 * compareXValues('a', 1); // 1 (数字优先)
 * ```
 *
 * @since 1.0.0
 */ export var compareXValues = function compareXValues(a, b) {
    var normalizedA = normalizeXValue(a);
    var normalizedB = normalizeXValue(b);
    // 如果都是数字，按数值比较
    if (typeof normalizedA === 'number' && typeof normalizedB === 'number') {
        return normalizedA - normalizedB;
    }
    // 如果一个是数字，一个是字符串，数字优先
    if (typeof normalizedA === 'number' && typeof normalizedB === 'string') {
        return -1;
    }
    if (typeof normalizedA === 'string' && typeof normalizedB === 'number') {
        return 1;
    }
    // 如果都是字符串，按字符串比较
    return String(normalizedA).localeCompare(String(normalizedB));
};
/**
 * 检查两个 X 轴值是否相等
 *
 * 比较两个 X 轴值是否相等，支持数字和字符串的混合比较。
 * 先对值进行归一化处理，然后进行比较。
 *
 * @param {number | string} a - 第一个值
 * @param {number | string} b - 第二个值
 * @returns {boolean} 是否相等
 *
 * @example
 * ```typescript
 * isXValueEqual(1, 1); // true
 * isXValueEqual('1', 1); // true
 * isXValueEqual('a', 'a'); // true
 * isXValueEqual(1, 2); // false
 * ```
 *
 * @since 1.0.0
 */ export var isXValueEqual = function isXValueEqual(a, b) {
    var normalizedA = normalizeXValue(a);
    var normalizedB = normalizeXValue(b);
    // 如果都是数字，按数值比较
    if (typeof normalizedA === 'number' && typeof normalizedB === 'number') {
        return normalizedA === normalizedB;
    }
    // 否则按字符串比较
    return String(normalizedA) === String(normalizedB);
};
/**
 * 从数据中提取并排序 X 轴值
 *
 * 从图表数据数组中提取所有唯一的 X 轴值，并进行排序。
 * 先对值进行归一化处理，然后去重并排序。
 *
 * @param {ChartDataItem[]} data - 图表数据数组
 * @returns {Array<number | string>} 排序后的唯一 X 轴值数组
 *
 * @example
 * ```typescript
 * const data = [
 *   { x: '2024-01', y: 100 },
 *   { x: '2024-02', y: 200 },
 *   { x: '2024-01', y: 150 }, // 重复值
 *   { x: 3, y: 300 }
 * ];
 * const sortedValues = extractAndSortXValues(data);
 * // ['2024-01', '2024-02', 3]
 * ```
 *
 * @since 1.0.0
 */ export var extractAndSortXValues = function extractAndSortXValues(data) {
    // 提取所有 x 值并归一化，同时过滤掉空值（null/undefined/空字符串）
    var normalizedValues = data.map(function(item) {
        return item.x;
    }).filter(function(x) {
        return x !== null && x !== undefined && x !== '' && String(x).trim() !== '';
    }).map(function(x) {
        return normalizeXValue(x);
    });
    // 去重并排序
    var uniqueValues = _to_consumable_array(new Set(normalizedValues));
    return uniqueValues.sort(compareXValues);
};
/**
 * 根据 X 轴值查找对应的数据点
 *
 * 在数据数组中查找指定 X 轴值对应的数据点。
 * 可以指定数据类型进行精确匹配。
 *
 * @param {ChartDataItem[]} data - 数据数组
 * @param {number | string} xValue - X 轴值
 * @param {string} [type] - 数据类型，可选
 * @returns {ChartDataItem | undefined} 匹配的数据点，如果未找到返回 undefined
 *
 * @example
 * ```typescript
 * const data = [
 *   { x: '2024-01', y: 100, type: 'A' },
 *   { x: '2024-01', y: 200, type: 'B' },
 *   { x: '2024-02', y: 300, type: 'A' }
 * ];
 *
 * // 查找所有类型
 * findDataPointByXValue(data, '2024-01'); // 第一个匹配项
 *
 * // 查找指定类型
 * findDataPointByXValue(data, '2024-01', 'B'); // { x: '2024-01', y: 200, type: 'B' }
 * ```
 *
 * @since 1.0.0
 */ export var findDataPointByXValue = function findDataPointByXValue(data, xValue, type) {
    if (!type) return data.find(function(item) {
        return isXValueEqual(item.x, xValue);
    });
    return data.find(function(item) {
        return item.type === type && isXValueEqual(item.x, xValue);
    });
};
/**
 * 将值转换为数字
 *
 * 安全地将任意值转换为数字类型，转换失败时返回默认值。
 * 如果输入已经是有效的数字，直接返回；否则尝试转换。
 * 字符串支持「亿元 / 万元 / 元」等人民币口语格式（见 `parseChineseCurrencyToNumber`）。
 *
 * @param {any} val - 要转换的值
 * @param {number} fallback - 转换失败时的默认值
 * @returns {number} 转换后的数字
 *
 * @example
 * ```typescript
 * toNumber('123', 0); // 123
 * toNumber(456, 0); // 456
 * toNumber('abc', 0); // 0
 * toNumber(null, 100); // 100
 * ```
 *
 * @since 1.0.0
 */ export var toNumber = function toNumber(val, fallback) {
    if (typeof val === 'number' && !Number.isNaN(val)) return val;
    var n = Number(val);
    if (Number.isFinite(n)) return n;
    if (typeof val === 'string') {
        var cn = parseChineseCurrencyToNumber(val);
        if (cn !== null && Number.isFinite(cn)) return cn;
    }
    return fallback;
};
/**
 * 检查值是否不为空
 *
 * 检查值是否不为 null 和 undefined。
 * 用于数据验证和条件判断。
 *
 * @param {any} val - 要检查的值
 * @returns {boolean} 是否不为空
 *
 * @example
 * ```typescript
 * isNotEmpty('hello'); // true
 * isNotEmpty(0); // true
 * isNotEmpty(''); // true
 * isNotEmpty(null); // false
 * isNotEmpty(undefined); // false
 * ```
 *
 * @since 1.0.0
 */ export var isNotEmpty = function isNotEmpty(val) {
    return val !== null && val !== undefined;
};
/**
 * 生成数据数组的快速哈希值
 *
 * 用于优化 useMemo 的依赖项比较，避免使用 JSON.stringify 的性能开销。
 * 通过比较数组长度和最后一个元素的引用来快速判断数据是否变化。
 * 适用于流式数据场景，当数据频繁追加时性能更好。
 *
 * @param {any[]} data - 数据数组
 * @returns {string} 哈希值字符串
 *
 * @example
 * ```typescript
 * const hash1 = getDataHash([{ x: 1, y: 2 }]);
 * const hash2 = getDataHash([{ x: 1, y: 2 }, { x: 3, y: 4 }]);
 * // hash1 !== hash2
 * ```
 *
 * @since 1.0.0
 */ export var getDataHash = function getDataHash(data) {
    if (!Array.isArray(data) || data.length === 0) {
        return "0-".concat((data === null || data === void 0 ? void 0 : data.length) || 0);
    }
    // 使用长度和最后一个元素的引用作为快速哈希
    // 对于流式数据，通常只有新增，所以比较最后一个元素即可
    var lastItem = data[data.length - 1];
    var firstItem = data[0];
    // 使用简单的哈希：长度 + 首尾元素的简单标识
    var firstKey = firstItem ? Object.keys(firstItem).join(',') : '';
    var lastKey = lastItem ? Object.keys(lastItem).join(',') : '';
    return "".concat(data.length, "-").concat(firstKey, "-").concat(lastKey);
};
/**
 * 深度比较两个配置对象的关键字段
 *
 * 用于优化 useMemo 的依赖项比较，只比较配置的关键字段，
 * 避免对整个配置对象进行深度比较的性能开销。
 *
 * @param {any} config1 - 第一个配置对象
 * @param {any} config2 - 第二个配置对象
 * @returns {boolean} 是否相等
 *
 * @example
 * ```typescript
 * const config1 = { x: 'date', y: 'value', height: 400 };
 * const config2 = { x: 'date', y: 'value', height: 400 };
 * isConfigEqual(config1, config2); // true
 * ```
 *
 * @since 1.0.0
 */ export var isConfigEqual = function isConfigEqual(config1, config2) {
    if (config1 === config2) return true;
    if (!config1 || !config2) return false;
    var keys1 = Object.keys(config1);
    var keys2 = Object.keys(config2);
    if (keys1.length !== keys2.length) return false;
    // 只比较关键字段
    var keyFields = [
        'x',
        'y',
        'height',
        'index',
        'rest'
    ];
    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
    try {
        for(var _iterator = keyFields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
            var key = _step.value;
            if (config1[key] !== config2[key]) {
                // 对于 rest 对象，进行浅比较
                if (key === 'rest' && config1[key] && config2[key]) {
                    var rest1 = config1[key];
                    var rest2 = config2[key];
                    var restKeys1 = Object.keys(rest1);
                    var restKeys2 = Object.keys(rest2);
                    if (restKeys1.length !== restKeys2.length) return false;
                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                    try {
                        for(var _iterator1 = restKeys1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
                            var restKey = _step1.value;
                            if (rest1[restKey] !== rest2[restKey]) return false;
                        }
                    } catch (err) {
                        _didIteratorError1 = true;
                        _iteratorError1 = err;
                    } finally{
                        try {
                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
                                _iterator1.return();
                            }
                        } finally{
                            if (_didIteratorError1) {
                                throw _iteratorError1;
                            }
                        }
                    }
                } else {
                    return false;
                }
            }
        }
    } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
    } finally{
        try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
            }
        } finally{
            if (_didIteratorError) {
                throw _iteratorError;
            }
        }
    }
    return true;
};
/**
 * 将 RGB/RGBA 颜色字符串转换为十六进制格式
 *
 * @param {string} rgb - RGB/RGBA 颜色字符串（如 'rgb(29, 122, 252)' 或 'rgba(29, 122, 252, 0.5)'）
 * @returns {string} 十六进制颜色值（如 '#1d7afc'）
 *
 * @since 1.0.0
 */ var rgbToHex = function rgbToHex(rgb) {
    var match = rgb.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
    if (!match) return rgb;
    var r = parseInt(match[1], 10);
    var g = parseInt(match[2], 10);
    var b = parseInt(match[3], 10);
    return "#".concat(((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1));
};
/**
 * 从浏览器 DOM 中解析 CSS 变量的实际颜色值
 *
 * @param {string} cssVar - CSS 变量表达式（如 'var(--color-blue)'）
 * @returns {string} 解析后的颜色值（如 '#1d7afc'）或原值
 *
 * @example
 * ```typescript
 * resolveCssVariable('var(--color-blue-control-fill-primary)'); // '#1d7afc'
 * resolveCssVariable('#ff0000'); // '#ff0000'
 * ```
 *
 * @since 1.0.0
 */ export var resolveCssVariable = function() {
    var cssVariableCache = new Map();
    return function(cssVar) {
        // 如果不是 CSS 变量，直接返回
        if (!cssVar.trim().startsWith('var(')) {
            return cssVar;
        }
        if (cssVariableCache.has(cssVar)) {
            return cssVariableCache.get(cssVar);
        }
        // 提取变量名，如 'var(--color-blue)' => '--color-blue'
        var match = cssVar.match(/var\((--[^)]+)\)/);
        if (!match) {
            // 无法匹配也缓存，避免重复解析
            cssVariableCache.set(cssVar, cssVar);
            return cssVar;
        }
        var resolvedColor = cssVar;
        // 从 DOM 中获取计算后的样式值
        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
            try {
                // 创建临时元素来获取计算后的颜色值
                var tempEl = document.createElement('div');
                tempEl.style.color = cssVar;
                document.body.appendChild(tempEl);
                var computedColor = window.getComputedStyle(tempEl).color;
                document.body.removeChild(tempEl);
                // 如果解析成功，将 rgb/rgba 转换为十六进制
                if (computedColor && computedColor !== cssVar) {
                    resolvedColor = rgbToHex(computedColor);
                }
            } catch (e) {
                console.warn("Failed to resolve CSS variable: ".concat(cssVar), e);
            }
        }
        cssVariableCache.set(cssVar, resolvedColor);
        return resolvedColor;
    };
}();
/**
 * 将十六进制颜色或CSS变量转换为带透明度的 RGBA 字符串
 *
 * 支持3位和6位十六进制颜色格式、CSS变量（如 var(--color-name)），并添加透明度。
 *
 * @param {string} color - 颜色值（如 '#ff0000'、'#f00' 或 'var(--color-blue)'）
 * @param {number} alpha - 透明度值（0-1之间）
 * @returns {string} RGBA 颜色字符串
 *
 * @example
 * ```typescript
 * hexToRgba('#ff0000', 0.5); // 'rgba(255, 0, 0, 0.5)'
 * hexToRgba('#f00', 0.8); // 'rgba(255, 0, 0, 0.8)'
 * hexToRgba('var(--color-blue)', 0.5); // 'rgba(29, 122, 252, 0.5)'
 * ```
 *
 * @since 1.0.0
 */ export var hexToRgba = function hexToRgba(color, alpha) {
    // 解析 CSS 变量为实际颜色值
    var resolvedColor = resolveCssVariable(color);
    // 处理十六进制颜色
    var sanitized = resolvedColor.replace('#', '');
    var isShort = sanitized.length === 3;
    var r = parseInt(isShort ? sanitized[0] + sanitized[0] : sanitized.slice(0, 2), 16);
    var g = parseInt(isShort ? sanitized[1] + sanitized[1] : sanitized.slice(2, 4), 16);
    var b = parseInt(isShort ? sanitized[2] + sanitized[2] : sanitized.slice(4, 6), 16);
    var a = Math.max(0, Math.min(1, alpha));
    return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(a, ")");
};
// 导出 Chart.js 注册相关函数
export { registerBarChartComponents, registerChartComponents, registerLineChartComponents } from "./utils/registerChart";
