@visactor/vutils 1.0.24 → 1.0.26

package/dist/index.js

@@ -325,8 +325,27 @@
 	var eventemitter3Exports = eventemitter3.exports;
 	var index$1 = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
+	/**
+	 * check value type
+	 * @param value the value to check
+	 * @param type type
+	 * @returns
+	 */
 	const isType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
 
+	/**
+	 * Checks if `value` is classified as a boolean primitive or object.
+	 * @param {*} value The value to check.
+	 * @param {boolean} fuzzy Whether to perform fuzzy judgment, for better performance，default to `false`.
+	 * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
+	 * @example
+	 *
+	 * isBoolean(false)
+	 * // => true
+	 *
+	 * isBoolean(null)
+	 * // => false
+	 */
 	const isBoolean = (value, fuzzy = false) => {
 	    if (fuzzy) {
 	        return typeof value === 'boolean';
@@ -334,6 +353,32 @@
 	    return value === true || value === false || isType(value, 'Boolean');
 	};
 
+	/**
+	 * Checks if `value` is classified as a `Function` object.
+	 *
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	 * @example
+	 *
+	 * isFunction(class Any{})
+	 * // => true
+	 *
+	 * isFunction(() => {})
+	 * // => true
+	 *
+	 * isFunction(async () => {})
+	 * // => true
+	 *
+	 * isFunction(function * Any() {})
+	 * // => true
+	 *
+	 * isFunction(Math.round)
+	 * // => true
+	 *
+	 * isFunction(/abc/)
+	 * // => false
+	 */
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	const isFunction = (value) => {
 	    return typeof value === 'function';
 	};
@@ -350,15 +395,84 @@
 	    return value !== null && value !== undefined;
 	};
 
+	/**
+	 * Checks if `value` is the
+	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	 *
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	 * @example
+	 *
+	 * isObject({})
+	 * // => true
+	 *
+	 * isObject([1, 2, 3])
+	 * // => true
+	 *
+	 * isObject(Function)
+	 * // => true
+	 *
+	 * isObject(null)
+	 * // => false
+	 */
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	const isObject = (value) => {
 	    const type = typeof value;
 	    return (value !== null && type === 'object') || type === 'function';
 	};
 
+	/**
+	 * Checks if `value` is object-like. A value is object-like if it's not `null`
+	 * and has a `typeof` result of "object".
+	 *
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	 * @example
+	 *
+	 * isObjectLike({})
+	 * // => true
+	 *
+	 * isObjectLike([1, 2, 3])
+	 * // => true
+	 *
+	 * isObjectLike(Function)
+	 * // => false
+	 *
+	 * isObjectLike(null)
+	 * // => false
+	 */
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	const isObjectLike = (value) => {
 	    return typeof value === 'object' && value !== null;
 	};
 
+	/**
+	 * @see https://github.com/lodash/lodash/blob/master/isPlainObject.js
+	 * Checks if `value` is a plain object, that is, an object created by the
+	 * `Object` constructor or one with a `[[Prototype]]` of `null`.
+	 *
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+	 * @example
+	 *
+	 * function Foo() {
+	 *   this.a = 1
+	 * }
+	 *
+	 * isPlainObject(new Foo)
+	 * // => false
+	 *
+	 * isPlainObject([1, 2, 3])
+	 * // => false
+	 *
+	 * isPlainObject({ 'x': 0, 'y': 0 })
+	 * // => true
+	 *
+	 * isPlainObject(Object.create(null))
+	 * // => true
+	 */
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	const isPlainObject = function (value) {
 	    if (!isObjectLike(value) || !isType(value, 'Object')) {
 	        return false;
@@ -377,6 +491,19 @@
 	    return value === undefined;
 	};
 
+	/**
+	 * Checks if `value` is classified as a `String` primitive or object.
+	 * @param {*} value The value to check.
+	 * @param {boolean} fuzzy Whether to perform fuzzy judgment, for better performance，default to `false`.
+	 * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+	 * @example
+	 *
+	 * isString('abc')
+	 * // => true
+	 *
+	 * isString(1)
+	 * // => false
+	 */
 	const isString = (value, fuzzy = false) => {
 	    const type = typeof value;
 	    if (fuzzy) {
@@ -397,6 +524,29 @@
 	    return isType(value, 'Date');
 	};
 
+	/**
+	 * Checks if `value` is classified as a `Number` primitive or object.
+	 *
+	 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
+	 * classified as numbers, use the `Number.isFinite` method.
+	 *
+	 * @param {*} value The value to check.
+	 * @param {boolean} fuzzy Whether to perform fuzzy judgment, for better performance，default to `false`.
+	 * @returns {boolean} Returns `true` if `value` is a number, else `false`.
+	 * @example
+	 *
+	 * isNumber(3)
+	 * // => true
+	 *
+	 * isNumber(Number.MIN_VALUE)
+	 * // => true
+	 *
+	 * isNumber(Infinity)
+	 * // => true
+	 *
+	 * isNumber('3')
+	 * // => false
+	 */
 	const isNumber = (value, fuzzy = false) => {
 	    const type = typeof value;
 	    if (fuzzy) {
@@ -405,6 +555,31 @@
 	    return type === 'number' || isType(value, 'Number');
 	};
 
+	/**
+	 * Checks if `value` is classified as a legal string number
+	 *
+	 * @param {*} value The string value to check.
+	 * @returns {boolean} Returns `true` if `value` is a legal string number, else `false`.
+	 * @example
+	 *
+	 * isNumeric(1)
+	 * // => false
+	 *
+	 * isNumeric('2.0')
+	 * // => true
+	 *
+	 * isNumeric('3a')
+	 * // => false
+	 *
+	 * isNumeric('4.a')
+	 * // => false
+	 *
+	 * isNumeric(Infinity)
+	 * // => false
+	 *
+	 * isNumeric('01')
+	 * // => true
+	 */
 	const isNumeric = (value) => {
 	    if (typeof value !== 'string') {
 	        return false;
@@ -413,10 +588,12 @@
 	};
 
 	const isValidNumber = (value) => {
+	    // isFinate 包含来 isNaN 的判断
 	    return isNumber(value) && Number.isFinite(value);
 	};
 
 	const isValidUrl = (value) => {
+	    // TODO: 匹配其他形式的 url
 	    const exp = /^(http(s)?:\/\/)\w+[^\s]+(\.[^\s]+){1,}$/;
 	    const urlPattern = new RegExp(exp);
 	    return urlPattern.test(value);
@@ -426,6 +603,12 @@
 	    return isType(value, 'RegExp');
 	};
 
+	/**
+	 * 迁移至 sirius
+	 * Checks if `value` is classified as a `Base64` string;
+	 * @param {string} The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
+	 */
 	const isBase64 = (value) => {
 	    const exp = /^data:image\/(?:gif|png|jpeg|bmp|webp|svg\+xml)(?:;charset=utf-8)?;base64,(?:[A-Za-z0-9]|[+/])+={0,2}/g;
 	    const urlPattern = new RegExp(exp);
@@ -448,12 +631,22 @@
 
 	const hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 	function isEmpty(value) {
+	    /**
+	     * isEmpty(null) => true
+	     * isEmpty() => true
+	     * isEmpty(true) => true
+	     * isEmpty(1) => true
+	     * isEmpty([1, 2, 3]) => false
+	     * isEmpty('abc') => false
+	     * isEmpty({ a: 1 }) => false
+	     */
 	    if (isNil(value)) {
 	        return true;
 	    }
 	    if (isArrayLike(value)) {
 	        return !value.length;
 	    }
+	    // TODO: 这里需要优化下
 	    const type = getType(value);
 	    if (type === 'Map' || type === 'Set') {
 	        return !value.size;
@@ -477,7 +670,25 @@
 	    return obj === undefined ? defaultValue : obj;
 	};
 
+	/** Used to check objects for own properties. */
 	const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+	/**
+	 * Checks if `key` is a direct property of `object`.
+	 *
+	 * @param {Object} object The object to query.
+	 * @param {string} key The key to check.
+	 * @returns {boolean} Returns `true` if `key` exists, else `false`.
+	 * @example
+	 *
+	 * const object = { 'a': { 'b': 2 } }
+	 * const other = create({ 'a': create({ 'b': 2 }) })
+	 *
+	 * has(object, 'a')
+	 * // => true
+	 *
+	 * has(other, 'a')
+	 * // => false
+	 */
 	const has = (object, key) => {
 	    return object != null && hasOwnProperty$1.call(object, key);
 	};
@@ -489,7 +700,11 @@
 	    re.multiline && (flags += 'm');
 	    return flags;
 	}
+	// Adapted from https://github.com/pvorb/clone by Paul Vorbach
+	// License: https://github.com/pvorb/clone/blob/master/LICENSE
 	function clone(parent, circular = false, depth = 0, prototype = undefined) {
+	    // maintain two arrays for circular references, where corresponding parents
+	    // and children have the same index
 	    const allParents = [];
 	    const allChildren = [];
 	    if (typeof circular === 'undefined') {
@@ -498,7 +713,9 @@
 	    if (typeof depth === 'undefined') {
 	        depth = Infinity;
 	    }
+	    // recurse this function so we don't reset allParents and allChildren
 	    function _clone(parent, depth) {
+	        // cloning null always returns null
 	        if (parent === null) {
 	            return null;
 	        }
@@ -552,21 +769,27 @@
 	    }
 	    const isArr = isArray(value);
 	    const length = value.length;
+	    // 不考虑特殊数组的额外处理
 	    if (isArr) {
 	        result = new Array(length);
 	    }
+	    // 不考虑 buffer / arguments 类型的处理以及 prototype 的额外处理
 	    else if (typeof value === 'object') {
 	        result = {};
 	    }
+	    // 不建议使用作为 Boolean / Number / String 作为构造器
 	    else if (isBoolean(value) || isNumber(value) || isString(value)) {
 	        result = value;
 	    }
 	    else if (isDate(value)) {
 	        result = new Date(+value);
 	    }
+	    // 不考虑 ArrayBuffer / DataView / TypedArray / map / set / regexp / symbol 类型
 	    else {
 	        result = undefined;
 	    }
+	    // 不考虑 map / set / TypedArray 类型的赋值
+	    // 不考虑对象的 symbol 属性
 	    const props = isArr ? undefined : Object.keys(Object(value));
 	    let index = -1;
 	    if (result) {
@@ -590,8 +813,10 @@
 	            return;
 	        }
 	        if (isValid(source) && typeof source === 'object') {
+	            // baseFor
 	            const iterable = Object(source);
 	            const props = [];
+	            // keysIn
 	            for (const key in iterable) {
 	                props.push(key);
 	            }
@@ -599,6 +824,7 @@
 	            let propIndex = -1;
 	            while (length--) {
 	                const key = props[++propIndex];
+	                // skipArray 这个是vchart spec的特有逻辑
 	                if (isValid(iterable[key]) &&
 	                    typeof iterable[key] === 'object' &&
 	                    (!skipTargetArray || !isArray(target[key]))) {
@@ -611,19 +837,24 @@
 	        }
 	    }
 	}
+	// 由于目前 ChartSpace 内部对 spec 会先执行一次深拷贝，merge 暂时不考虑 source 中有环的问题
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	function baseMergeDeep(target, source, key, shallowArray = false, skipTargetArray = false) {
 	    const objValue = target[key];
 	    const srcValue = source[key];
 	    let newValue = source[key];
 	    let isCommon = true;
+	    // 不考虑 buffer / typedArray 类型
 	    if (isArray(srcValue)) {
 	        if (shallowArray) {
+	            // 依据参数对数组做浅拷贝
 	            newValue = [];
 	        }
 	        else if (isArray(objValue)) {
 	            newValue = objValue;
 	        }
 	        else if (isArrayLike(objValue)) {
+	            // 如果 source 为数组，则 target 的 arrayLike 对象也视作为数组处理
 	            newValue = new Array(objValue.length);
 	            let index = -1;
 	            const length = objValue.length;
@@ -632,8 +863,13 @@
 	            }
 	        }
 	    }
+	    // else if (isArray(srcValue) && shallowArray) {
+	    //   newValue = [];
+	    // }
+	    // 不考虑 argument 类型
 	    else if (isPlainObject(srcValue)) {
 	        newValue = objValue !== null && objValue !== void 0 ? objValue : {};
+	        // 不考虑 prototype 的额外处理
 	        if (typeof objValue === 'function' || typeof objValue !== 'object') {
 	            newValue = {};
 	        }
@@ -641,19 +877,24 @@
 	    else {
 	        isCommon = false;
 	    }
+	    // 对 class 等复杂对象或者浅拷贝的 array 不做拷贝处理
 	    if (isCommon) {
 	        baseMerge(newValue, srcValue, shallowArray, skipTargetArray);
 	    }
 	    assignMergeValue(target, key, newValue);
 	}
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	function assignMergeValue(target, key, value) {
 	    if ((value !== undefined && !eq(target[key], value)) || (value === undefined && !(key in target))) {
+	        // 不考虑 __proto__ 的赋值处理
 	        target[key] = value;
 	    }
 	}
 	function eq(value, other) {
 	    return value === other || (Number.isNaN(value) && Number.isNaN(other));
 	}
+	// 与原生的 lodash merge 差异在于对数组是否应用最后一个 source 的结果
+	// 例如 lineDash 等 spec 的 merge 使用这一操作更合适
 	function merge(target, ...sources) {
 	    let sourceIndex = -1;
 	    const length = sources.length;
@@ -707,6 +948,8 @@
 	function objectKeys(obj) {
 	    return Object.keys(obj);
 	}
+	// Adapted from https://github.com/antvis/F2/blob/master/packages/f2/src/base/equal.ts by zengyue
+	// License: https://github.com/antvis/F2/blob/master/packages/f2/LICENSE
 	function isEqual(a, b, options) {
 	    if (a === b) {
 	        return true;
@@ -714,18 +957,22 @@
 	    if (typeof a !== typeof b) {
 	        return false;
 	    }
+	    // null 和 undefined
 	    if (a == null || b == null) {
 	        return false;
 	    }
+	    // 特殊处理NaN
 	    if (Number.isNaN(a) && Number.isNaN(b)) {
 	        return true;
 	    }
 	    if (objToString(a) !== objToString(b)) {
 	        return false;
 	    }
+	    // 如果是function，则不相等
 	    if (isFunction(a)) {
 	        return !!(options === null || options === void 0 ? void 0 : options.skipFunction);
 	    }
+	    // 值类型，Number String Boolean
 	    if (typeof a !== 'object') {
 	        return false;
 	    }
@@ -745,16 +992,21 @@
 	    }
 	    const ka = objectKeys(a);
 	    const kb = objectKeys(b);
+	    // having the same number of owned properties (keys incorporates hasOwnProperty)
 	    if (ka.length !== kb.length) {
 	        return false;
 	    }
+	    // the same set of keys (although not necessarily the same order),
 	    ka.sort();
 	    kb.sort();
+	    // ~~~cheap key test
 	    for (let i = ka.length - 1; i >= 0; i--) {
+	        // eslint-disable-next-line eqeqeq
 	        if (ka[i] != kb[i]) {
 	            return false;
 	        }
 	    }
+	    // equivalent values for every corresponding key, and ~~~possibly expensive deep test
 	    for (let i = ka.length - 1; i >= 0; i--) {
 	        const key = ka[i];
 	        if (!isEqual(a[key], b[key], options)) {
@@ -768,7 +1020,8 @@
 	    if (x === y) {
 	        return x !== 0 || y !== 0 || 1 / x === 1 / y;
 	    }
-	    return x !== x && y !== y;
+	    // eslint-disable-next-line no-self-compare
+	    return x !== x && y !== y; //  NaN == NaN
 	}
 	function length(obj) {
 	    if (isArray(obj)) {
@@ -804,6 +1057,7 @@
 	    return ret;
 	}
 
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
 	function keys(obj) {
 	    if (!obj) {
 	        return [];
@@ -813,6 +1067,7 @@
 	    }
 	    const keyList = [];
 	    for (const key in obj) {
+	        // eslint-disable-next-line no-prototype-builtins
 	        if (obj.hasOwnProperty(key)) {
 	            keyList.push(key);
 	        }
@@ -829,9 +1084,16 @@
 	    }
 	    return target;
 	}
+	// eslint-disable-next-line @typescript-eslint/ban-types
 	function mixin(target, source, override = true) {
+	    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+	    // @ts-ignore
 	    target = 'prototype' in target ? target.prototype : target;
+	    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+	    // @ts-ignore
 	    source = 'prototype' in source ? source.prototype : source;
+	    // If build target is ES6 class. prototype methods is not enumerable. Use getOwnPropertyNames instead
+	    // TODO: Determine if source is ES6 class?
 	    if (Object.getOwnPropertyNames) {
 	        const keyList = Object.getOwnPropertyNames(source);
 	        for (let i = 0; i < keyList.length; i++) {
@@ -848,12 +1110,22 @@
 	    }
 	}
 
+	/**
+	 * 将传入数据转换为数组格式
+	 * @param arr 入参。
+	 * @returns 数组
+	 */
 	function array(arr) {
 	    if (isValid(arr)) {
 	        return isArray(arr) ? arr : [arr];
 	    }
 	    return [];
 	}
+	/**
+	 * 获取数组的最后一个值，如果传入的参数为非数组，则返回 undefined
+	 * @param val any
+	 * @returns
+	 */
 	function last(val) {
 	    if (isArrayLike(val)) {
 	        const arr = val;
@@ -861,12 +1133,23 @@
 	    }
 	    return undefined;
 	}
+	/**
+	 * 获取数组第一项与最后一项的差值，如果数组为空则返回 0
+	 * @param arr
+	 * @returns
+	 */
 	const span = (arr) => {
 	    if (arr.length <= 1) {
 	        return 0;
 	    }
 	    return last(arr) - arr[0];
 	};
+	/**
+	 * 获取数组中的最大值
+	 * @param arr 数组
+	 * @param compareFn 比较函数，返回正数表示 a > b，返回负数表示 a < b，返回 0 表示相等
+	 * @returns
+	 */
 	const maxInArray = (arr, compareFn) => {
 	    var _a;
 	    if (arr.length === 0) {
@@ -881,6 +1164,12 @@
 	    }
 	    return max;
 	};
+	/**
+	 * 获取数组中的最小值
+	 * @param arr 数组
+	 * @param compareFn 比较函数，返回正数表示 a > b，返回负数表示 a < b，返回 0 表示相等
+	 * @returns
+	 */
 	const minInArray = (arr, compareFn) => {
 	    var _a;
 	    if (arr.length === 0) {
@@ -895,6 +1184,12 @@
 	    }
 	    return min;
 	};
+	/**
+	 * 判断两个数组是否相同
+	 * @param a
+	 * @param b
+	 * @returns
+	 */
 	function arrayEqual(a, b) {
 	    if (!isArray(a) || !isArray(b)) {
 	        return false;
@@ -909,12 +1204,18 @@
 	    }
 	    return true;
 	}
+	/**
+	 * 封装并返回无重复的数组
+	 * @param arr
+	 * @returns
+	 */
 	function uniqArray(arr) {
 	    if (!arr || !isArray(arr)) {
 	        return arr;
 	    }
 	    return Array.from(new Set(array(arr)));
 	}
+	// Based on http://jsfromhell.com/array/shuffle
 	function shuffleArray(arr, random = Math.random) {
 	    let j;
 	    let x;
@@ -927,6 +1228,11 @@
 	    }
 	    return arr;
 	}
+	/**
+	 * 展开多层数组，非数组内容将变为 [input]
+	 * @param arr
+	 * @returns
+	 */
 	function flattenArray(arr) {
 	    if (!isArray(arr)) {
 	        return [arr];
@@ -981,11 +1287,74 @@
 	    return value0 + (value1 - value0) * (i - i0);
 	}
 
+	/**
+	 * Approximate inverse normal CDF (probit) using Acklam's algorithm.
+	 * Returns z such that P(Z <= z) = p for standard normal Z.
+	 */
+	function normalQuantile(p) {
+	    if (p === 0) {
+	        return -Infinity;
+	    }
+	    if (p === 1) {
+	        return Infinity;
+	    }
+	    if (!Number.isFinite(p) || p < 0 || p > 1) {
+	        return NaN;
+	    }
+	    const a1 = -39.6968302866538;
+	    const a2 = 220.946098424521;
+	    const a3 = -275.928510446969;
+	    const a4 = 138.357751867269;
+	    const a5 = -30.6647980661472;
+	    const a6 = 2.50662827745924;
+	    const b1 = -54.4760987982241;
+	    const b2 = 161.585836858041;
+	    const b3 = -155.698979859887;
+	    const b4 = 66.8013118877197;
+	    const b5 = -13.2806815528857;
+	    const c1 = -0.00778489400243029;
+	    const c2 = -0.322396458041136;
+	    const c3 = -2.40075827716184;
+	    const c4 = -2.54973253934373;
+	    const c5 = 4.37466414146497;
+	    const c6 = 2.93816398269878;
+	    const d1 = 0.00778469570904146;
+	    const d2 = 0.32246712907004;
+	    const d3 = 2.445134137143;
+	    const d4 = 3.75440866190742;
+	    const pLow = 0.02425;
+	    const pHigh = 1 - pLow;
+	    let q;
+	    let r;
+	    if (p < pLow) {
+	        q = Math.sqrt(-2 * Math.log(p));
+	        return (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
+	    }
+	    if (p <= pHigh) {
+	        q = p - 0.5;
+	        r = q * q;
+	        return (((((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q) /
+	            (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1));
+	    }
+	    q = Math.sqrt(-2 * Math.log(1 - p));
+	    return -((((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1));
+	}
+
+	/* Adapted from vega by University of Washington Interactive Data Lab
+	 * https://vega.github.io/vega/
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/vega/vega/blob/main/packages/vega-util/src/logger.js
+	 * License: https://github.com/vega/vega/blob/main/LICENSE
+	 * @license
+	 */
+	// check console
 	const hasConsole = typeof console !== 'undefined';
 	function log(method, level, input) {
 	    const args = [level].concat([].slice.call(input));
 	    if (hasConsole) {
-	        console[method].apply(console, args);
+	        // eslint-disable-next-line prefer-spread, no-undef
+	        console[method].apply(console, args); // eslint-disable-line no-console
 	    }
 	}
 	exports.LoggerLevel = void 0;
@@ -1093,6 +1462,14 @@
 	}
 	Logger._instance = null;
 
+	/**
+	 * 通过二分法，查找数组a中大于数值x的第一个元素的序号
+	 * @param a
+	 * @param x
+	 * @param lo
+	 * @param hi
+	 * @returns
+	 */
 	function bisect(a, x, lo = 0, hi) {
 	    if (isNil(hi)) {
 	        hi = a.length;
@@ -1108,6 +1485,16 @@
 	    }
 	    return lo;
 	}
+	/* Adapted from fmin by Ben Frederickson
+	 * https://github.com/benfred/fmin
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/benfred/fmin/blob/master/src/bisect.js
+	 * License: https://github.com/benfred/fmin/blob/master/LICENSE
+	 * @license
+	 */
+	/** finds the zeros of a function, given two starting points (which must
+	 * have opposite signs */
 	function findZeroOfFunction(f, a, b, parameters) {
 	    var _a, _b;
 	    const maxIterations = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.maxIterations) !== null && _a !== void 0 ? _a : 100;
@@ -1139,16 +1526,27 @@
 	    }
 	    return a + delta;
 	}
+	/**
+	 * 二分靠近框架，返回数组中第一个大于等于目标值的数的索引
+	 * @param arr 数组
+	 * @param compareFn 比较函数，返回(当前值-目标值)
+	 */
 	const binaryFuzzySearch = (arr, compareFn) => {
 	    return binaryFuzzySearchInNumberRange(0, arr.length, value => compareFn(arr[value]));
 	};
+	/**
+	 * 二分靠近框架，返回数字区间中第一个大于等于目标值的数字
+	 * @param x1 区间上界
+	 * @param x2 区间下界（不包含）
+	 * @param compareFn 比较函数，返回(当前值-目标值)
+	 */
 	const binaryFuzzySearchInNumberRange = (x1, x2, compareFn) => {
 	    let left = x1;
 	    let right = x2;
 	    while (left < right) {
 	        const mid = Math.floor((left + right) / 2);
 	        if (compareFn(mid) >= 0) {
-	            right = mid;
+	            right = mid; // 第一个大于等于目标值的数
 	        }
 	        else {
 	            left = mid + 1;
@@ -1219,16 +1617,40 @@
 	    return stop < start ? -step1 : step1;
 	}
 
+	/**
+	 * @description 处理数值相关的方法
+	 */
 	const DEFAULT_ABSOLUTE_TOLERATE = 1e-10;
 	const DEFAULT_RELATIVE_TOLERATE = 1e-10;
+	/**
+	 * 判断两数是否接近相等，函数参数参照 python isClose 方法
+	 * @param {number} a
+	 * @param {number} b
+	 * @param refTol 指定的相对容差比例，将乘以两数的最大值作为相对容差
+	 * @param absTol 指定的绝对容差
+	 */
 	function isNumberClose(a, b, relTol = DEFAULT_RELATIVE_TOLERATE, absTol = DEFAULT_ABSOLUTE_TOLERATE) {
 	    const abs = absTol;
 	    const rel = relTol * Math.max(a, b);
 	    return Math.abs(a - b) <= Math.max(abs, rel);
 	}
+	/**
+	 * 判断 a 是否大于 b，并排除容差范围
+	 * @param a
+	 * @param b
+	 * @param relTol 指定的相对容差比例，将乘以两数的最大值作为相对容差
+	 * @param absTol 指定的绝对容差
+	 */
 	function isGreater(a, b, relTol, absTol) {
 	    return a > b && !isNumberClose(a, b, relTol, absTol);
 	}
+	/**
+	 * 判断 a 是否小于 b，并排除容差范围
+	 * @param a
+	 * @param b
+	 * @param relTol 指定的相对容差比例，将乘以两数的最大值作为相对容差
+	 * @param absTol 指定的绝对容差
+	 */
 	function isLess(a, b, relTol, absTol) {
 	    return a < b && !isNumberClose(a, b, relTol, absTol);
 	}
@@ -1263,6 +1685,27 @@
 	    }
 	    return s;
 	};
+	/**
+	 * Pads `string` on the left and right, left or right sides if it's shorter than `length`.
+	 * Padding characters are truncated if they can't be evenly divided by `length`.
+	 *
+	 * @since 3.0.0
+	 * @category String
+	 * @param {string} [string=''] The string to pad.
+	 * @param {number} [length=0] The padding length.
+	 * @param {string} [chars=' '] The string used as padding.
+	 * @returns {string} Returns the padded string.
+	 * @example
+	 *
+	 * pad('abc', 8)
+	 * // => '  abc   '
+	 *
+	 * pad('abc', 8, '_-')
+	 * // => '_-abc_-_'
+	 *
+	 * pad('abc', 2)
+	 * // => 'abc'
+	 */
 	const pad = (str, length, padChar = ' ', align = 'right') => {
 	    const c = padChar;
 	    const s = str + '';
@@ -1290,20 +1733,33 @@
 	    return align === 'center' ? s.slice(0, Math.ceil(l / 2)) + e + s.slice(n - Math.floor(l / 2)) : s.slice(0, l) + e;
 	};
 
+	// TODO: 性能不是很好，需要优化，后续升级到最新版本的 canvas 之后就可以删除了
+	/**
+	 * 生成uuid字符串.
+	 * 参考https://github.com/yangjunning/issues/issues/56
+	 * @param len
+	 * @param radix
+	 * @returns
+	 */
 	const uuid = (len, radix) => {
 	    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
 	    const uuid = [];
 	    let i;
 	    radix = radix || chars.length;
 	    if (len) {
+	        // Compact form
 	        for (i = 0; i < len; i++) {
 	            uuid[i] = chars[0 | (Math.random() * radix)];
 	        }
 	    }
 	    else {
+	        // rfc4122, version 4 form
 	        let r;
+	        // rfc4122 requires these characters
 	        uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
 	        uuid[14] = '4';
+	        // Fill in random data.  At i==19 set the high bits of clock sequence as
+	        // per rfc4122, sec. 4.1.5
 	        for (i = 0; i < 36; i++) {
 	            if (!uuid[i]) {
 	                r = 0 | (Math.random() * 16);
@@ -1350,6 +1806,9 @@
 	    };
 	}
 
+	/**
+	 * @see https://github.com/lodash/lodash/blob/master/debounce.js
+	 */
 	let hasRaf = false;
 	try {
 	    hasRaf = typeof requestAnimationFrame === 'function' && typeof cancelAnimationFrame === 'function';
@@ -1363,12 +1822,14 @@
 	    let lastThis;
 	    let maxWait;
 	    let result;
+	    // eslint-disable-next-line no-undef
 	    let timerId;
 	    let lastCallTime;
 	    let lastInvokeTime = 0;
 	    let leading = false;
 	    let maxing = false;
 	    let trailing = true;
+	    // Bypass `requestAnimationFrame` by explicitly setting `wait=0`.
 	    const useRAF = !wait && wait !== 0 && hasRaf;
 	    if (typeof func !== 'function') {
 	        throw new TypeError('Expected a function');
@@ -1404,8 +1865,11 @@
 	        clearTimeout(id);
 	    }
 	    function leadingEdge(time) {
+	        // Reset any `maxWait` timer.
 	        lastInvokeTime = time;
+	        // Start the timer for the trailing edge.
 	        timerId = startTimer(timerExpired, wait);
+	        // Invoke the leading edge.
 	        return leading ? invokeFunc(time) : result;
 	    }
 	    function remainingWait(time) {
@@ -1417,6 +1881,9 @@
 	    function shouldInvoke(time) {
 	        const timeSinceLastCall = time - lastCallTime;
 	        const timeSinceLastInvoke = time - lastInvokeTime;
+	        // Either this is the first call, activity has stopped and we're at the
+	        // trailing edge, the system time has gone backwards and we're treating
+	        // it as the trailing edge, or we've hit the `maxWait` limit.
 	        return (lastCallTime === undefined ||
 	            timeSinceLastCall >= wait ||
 	            timeSinceLastCall < 0 ||
@@ -1427,10 +1894,13 @@
 	        if (shouldInvoke(time)) {
 	            return trailingEdge(time);
 	        }
+	        // Restart the timer.
 	        timerId = startTimer(timerExpired, remainingWait(time));
 	    }
 	    function trailingEdge(time) {
 	        timerId = undefined;
+	        // Only invoke if we have `lastArgs` which means `func` has been
+	        // debounced at least once.
 	        if (trailing && lastArgs) {
 	            return invokeFunc(time);
 	        }
@@ -1454,6 +1924,7 @@
 	        const time = Date.now();
 	        const isInvoking = shouldInvoke(time);
 	        lastArgs = args;
+	        // @ts-ignore
 	        lastThis = this;
 	        lastCallTime = time;
 	        if (isInvoking) {
@@ -1461,6 +1932,7 @@
 	                return leadingEdge(lastCallTime);
 	            }
 	            if (maxing) {
+	                // Handle invocations in a tight loop.
 	                timerId = startTimer(timerExpired, wait);
 	                return invokeFunc(lastCallTime);
 	            }
@@ -1476,6 +1948,9 @@
 	    return debounced;
 	}
 
+	/**
+	 * @see https://github.com/lodash/lodash/blob/master/throttle.js
+	 */
 	function throttle(func, wait, options) {
 	    let leading = true;
 	    let trailing = true;
@@ -1525,47 +2000,55 @@
 	    };
 	}
 	function interpolateString(a, b) {
-	    let bi = (reA.lastIndex = reB.lastIndex = 0);
-	    let am;
-	    let bm;
-	    let bs;
-	    let i = -1;
-	    const s = [];
-	    const q = [];
+	    let bi = (reA.lastIndex = reB.lastIndex = 0); // scan index for next number in b
+	    let am; // current match in a
+	    let bm; // current match in b
+	    let bs; // string preceding current number in b, if any
+	    let i = -1; // index in s
+	    const s = []; // string constants and placeholders
+	    const q = []; // number interpolators
+	    // Coerce inputs to strings.
 	    (a = a + ''), (b = b + '');
+	    // Interpolate pairs of numbers in a & b.
 	    while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
 	        if ((bs = bm.index) > bi) {
+	            // a string precedes the next number in b
 	            bs = b.slice(bi, bs);
 	            if (s[i]) {
 	                s[i] += bs;
-	            }
+	            } // coalesce with previous string
 	            else {
 	                s[++i] = bs;
 	            }
 	        }
 	        if ((am = am[0]) === (bm = bm[0])) {
+	            // numbers in a & b match
 	            if (s[i]) {
 	                s[i] += bm;
-	            }
+	            } // coalesce with previous string
 	            else {
 	                s[++i] = bm;
 	            }
 	        }
 	        else {
+	            // interpolate non-matching numbers
 	            s[++i] = null;
 	            q.push({ i: i, x: interpolateNumber(am, bm) });
 	        }
 	        bi = reB.lastIndex;
 	    }
+	    // Add remains of b.
 	    if (bi < b.length) {
 	        bs = b.slice(bi);
 	        if (s[i]) {
 	            s[i] += bs;
-	        }
+	        } // coalesce with previous string
 	        else {
 	            s[++i] = bs;
 	        }
 	    }
+	    // Special optimization for only a single match.
+	    // Otherwise, interpolate each of the numbers and rejoin the string.
 	    return s.length < 2
 	        ? q[0]
 	            ? one(q[0].x)
@@ -1579,19 +2062,36 @@
 	            });
 	}
 
-	const TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/;
+	// eslint-disable-next-line no-useless-escape
+	const TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // eslint-disable-line
 	function toDate(val) {
 	    if (val instanceof Date) {
 	        return val;
 	    }
 	    else if (isString(val)) {
+	        // Different browsers parse date in different way, so we parse it manually.
+	        // Some other issues:
+	        // new Date('1970-01-01') is UTC,
+	        // new Date('1970/01/01') and new Date('1970-1-01') is local.
+	        // See issue #3623
 	        const match = TIME_REG.exec(val);
 	        if (!match) {
+	            // return Invalid Date.
 	            return new Date(NaN);
 	        }
+	        // Use local time when no timezone offset specifed.
 	        if (!match[8]) {
+	            // match[n] can only be string or undefined.
+	            // But take care of '12' + 1 => '121'.
 	            return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0);
 	        }
+	        // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
+	        // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
+	        // For example, system timezone is set as "Time Zone: America/Toronto",
+	        // then these code will get different result:
+	        // `new Date(1478411999999).getTimezoneOffset();  // get 240`
+	        // `new Date(1478412000000).getTimezoneOffset();  // get 300`
+	        // So we should not use `new Date`, but use `Date.UTC`.
 	        let hour = +match[4] || 0;
 	        if (match[8].toUpperCase() !== 'Z') {
 	            hour -= +match[8].slice(0, 3);
@@ -1635,13 +2135,25 @@
 	function seedRandom(seed) {
 	    return parseFloat('0.' + Math.sin(seed).toString().substring(6));
 	}
+	/* Adapted from vega by University of Washington Interactive Data Lab
+	 * https://vega.github.io/vega/
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/vega/vega/blob/main/packages/vega-statistics/src/lcg.js
+	 * License: https://github.com/vega/vega/blob/main/LICENSE
+	 * @license
+	 */
+	// https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use
 	const a = 1664525;
 	const c = 1013904223;
-	const m = 4294967296;
+	const m = 4294967296; // 2^32
 	function randomLCG(initS = 1) {
 	    let s = initS;
 	    return () => (s = (a * s + c) % m) / m;
 	}
+	/**
+	 * 随机拟合
+	 */
 	const fakeRandom = () => {
 	    let i = -1;
 	    const arr = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9];
@@ -1670,6 +2182,9 @@
 	    }
 	    return fieldSingle(fieldStr, opt);
 	};
+	/**
+	 * 取数逻辑
+	 */
 	const simpleField = (option) => {
 	    if (!option) {
 	        return null;
@@ -1692,12 +2207,17 @@
 
 	const zero = (_) => 0;
 
+	/**
+	 * Return an array with minimum and maximum values, in the
+	 * form [min, max]. Ignores null, undefined, and NaN values.
+	 */
 	const extent = (array, func) => {
 	    const valueGetter = isFunction(func) ? func : (val) => val;
 	    let min;
 	    let max;
 	    if (array && array.length) {
 	        const n = array.length;
+	        // find first valid value
 	        for (let i = 0; i < n; i += 1) {
 	            let value = valueGetter(array[i]);
 	            if (!isNil(value) && isNumber((value = +value)) && !Number.isNaN(value)) {
@@ -1716,49 +2236,233 @@
 	    return [min, max];
 	};
 
-	function invNorm(p) {
-	    if (p <= 0 || p >= 1) {
-	        return 0;
+	function regressionPoints(data, x, y) {
+	    const points = [];
+	    data.forEach(d => {
+	        const a = x(d);
+	        const b = y(d);
+	        // 保留既有 accessor 对缺失观测的排除行为；无穷大不是可拟合观测。
+	        if (a != null && b != null && Number.isFinite(+a) && Number.isFinite(+b)) {
+	            points.push({ x: +a, y: +b });
+	        }
+	    });
+	    return points;
+	}
+	function normalizeRegression(value, center, scale) {
+	    const delta = value - center;
+	    return Number.isFinite(delta) ? delta / scale : value / scale - center / scale;
+	}
+	function regressionBasis(points) {
+	    let xMin = Infinity;
+	    let xMax = -Infinity;
+	    let yMin = Infinity;
+	    let yMax = -Infinity;
+	    for (const p of points) {
+	        xMin = Math.min(xMin, p.x);
+	        xMax = Math.max(xMax, p.x);
+	        yMin = Math.min(yMin, p.y);
+	        yMax = Math.max(yMax, p.y);
+	    }
+	    if (!points.length) {
+	        return { xCenter: 0, xScale: 1, yCenter: 0, yScale: 1 };
+	    }
+	    const xCenter = xMin / 2 + xMax / 2;
+	    const yCenter = yMin / 2 + yMax / 2;
+	    return {
+	        xCenter,
+	        yCenter,
+	        xScale: Math.max(Math.abs(xMin - xCenter), Math.abs(xMax - xCenter)) || 1,
+	        yScale: Math.max(Math.abs(yMin - yCenter), Math.abs(yMax - yCenter)) || 1
+	    };
+	}
+	/** 秩不足时对 QR 的小型 R 做单边 Jacobi SVD，获得明确的最小范数解。 */
+	function minimumNorm(r, rhs) {
+	    const p = rhs.length;
+	    const a = r.map(row => row.slice());
+	    const v = Array.from({ length: p }, (_, i) => Array.from({ length: p }, (_, j) => +(i === j)));
+	    for (let sweep = 0; sweep < 50; sweep++) {
+	        let changed = false;
+	        for (let j = 0; j < p - 1; j++) {
+	            for (let k = j + 1; k < p; k++) {
+	                let aa = 0;
+	                let bb = 0;
+	                let ab = 0;
+	                for (let i = 0; i < p; i++) {
+	                    aa += a[i][j] ** 2;
+	                    bb += a[i][k] ** 2;
+	                    ab += a[i][j] * a[i][k];
+	                }
+	                if (Math.abs(ab) <= Number.EPSILON * 8 * Math.sqrt(aa * bb)) {
+	                    continue;
+	                }
+	                changed = true;
+	                const tau = (bb - aa) / (2 * ab);
+	                const t = (tau >= 0 ? 1 : -1) / (Math.abs(tau) + Math.hypot(1, tau));
+	                const c = 1 / Math.hypot(1, t);
+	                const s = c * t;
+	                for (let i = 0; i < p; i++) {
+	                    const aj = a[i][j];
+	                    const ak = a[i][k];
+	                    const vj = v[i][j];
+	                    const vk = v[i][k];
+	                    a[i][j] = c * aj - s * ak;
+	                    a[i][k] = s * aj + c * ak;
+	                    v[i][j] = c * vj - s * vk;
+	                    v[i][k] = s * vj + c * vk;
+	                }
+	            }
+	        }
+	        if (!changed) {
+	            break;
+	        }
 	    }
-	    const a1 = -39.6968302866538;
-	    const a2 = 220.946098424521;
-	    const a3 = -275.928510446969;
-	    const a4 = 138.357751867269;
-	    const a5 = -30.6647980661472;
-	    const a6 = 2.50662827745924;
-	    const b1 = -54.4760987982241;
-	    const b2 = 161.585836858041;
-	    const b3 = -155.698979859887;
-	    const b4 = 66.8013118877197;
-	    const b5 = -13.2806815528857;
-	    const c1 = -0.00778489400243029;
-	    const c2 = -0.322396458041136;
-	    const c3 = -2.40075827716184;
-	    const c4 = -2.54973253934373;
-	    const c5 = 4.37466414146497;
-	    const c6 = 2.93816398269878;
-	    const d1 = 0.00778469570904146;
-	    const d2 = 0.32246712907004;
-	    const d3 = 2.445134137143;
-	    const d4 = 3.75440866190742;
-	    const pLow = 0.02425;
-	    const pHigh = 1 - pLow;
-	    let q;
-	    let r;
-	    if (p < pLow) {
-	        q = Math.sqrt(-2 * Math.log(p));
-	        return (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
+	    const norms = Array.from({ length: p }, (_, j) => Math.hypot(...a.map(row => row[j])));
+	    const tolerance = Math.max(...norms) * Number.EPSILON * p * 64;
+	    const coef = new Array(p).fill(0);
+	    let rank = 0;
+	    for (let j = 0; j < p; j++) {
+	        if (norms[j] <= tolerance) {
+	            continue;
+	        }
+	        rank++;
+	        let projection = 0;
+	        for (let i = 0; i < p; i++) {
+	            projection += a[i][j] * rhs[i];
+	        }
+	        projection /= norms[j] ** 2;
+	        for (let i = 0; i < p; i++) {
+	            coef[i] += v[i][j] * projection;
+	        }
 	    }
-	    if (p <= pHigh) {
-	        q = p - 0.5;
-	        r = q * q;
-	        return (((((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q) /
-	            (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1));
+	    return { coef, rank };
+	}
+	function fitRegression(points, degree, basis = regressionBasis(points)) {
+	    const p = degree + 1;
+	    if (degree === 1) {
+	        let mx = 0;
+	        let my = 0;
+	        let n = 0;
+	        for (const row of points) {
+	            n++;
+	            mx += (normalizeRegression(row.x, basis.xCenter, basis.xScale) - mx) / n;
+	            my += (normalizeRegression(row.y, basis.yCenter, basis.yScale) - my) / n;
+	        }
+	        let sxx = 0;
+	        let sxy = 0;
+	        for (const row of points) {
+	            const dx = normalizeRegression(row.x, basis.xCenter, basis.xScale) - mx;
+	            sxx += dx * dx;
+	            sxy += dx * (normalizeRegression(row.y, basis.yCenter, basis.yScale) - my);
+	        }
+	        const b = sxx === 0 ? 0 : sxy / sxx;
+	        const coef = sxx === 0 ? [my / (1 + mx * mx), (mx * my) / (1 + mx * mx)] : [my - b * mx, b];
+	        return { coef, rank: n === 0 ? 0 : sxx === 0 ? 1 : 2, basis };
+	    }
+	    const r = Array.from({ length: p }, () => new Array(p).fill(0));
+	    const rhs = new Array(p).fill(0);
+	    const row = new Array(p);
+	    for (const point of points) {
+	        const z = normalizeRegression(point.x, basis.xCenter, basis.xScale);
+	        row[0] = 1;
+	        for (let j = 1; j < p; j++) {
+	            row[j] = row[j - 1] * z;
+	        }
+	        let value = normalizeRegression(point.y, basis.yCenter, basis.yScale);
+	        // 增量 Givens QR 仅保留 p×p 的 R，bootstrap 不分配 N×p 矩阵。
+	        for (let j = 0; j < p; j++) {
+	            const norm = Math.hypot(r[j][j], row[j]);
+	            if (norm === 0) {
+	                continue;
+	            }
+	            const c = r[j][j] / norm;
+	            const s = row[j] / norm;
+	            r[j][j] = norm;
+	            for (let k = j + 1; k < p; k++) {
+	                const previous = r[j][k];
+	                r[j][k] = c * previous + s * row[k];
+	                row[k] = -s * previous + c * row[k];
+	            }
+	            const previous = rhs[j];
+	            rhs[j] = c * previous + s * value;
+	            value = -s * previous + c * value;
+	        }
+	    }
+	    const tolerance = Math.max(...r.map((row, i) => Math.abs(row[i]))) * Number.EPSILON * p * 64;
+	    if (r.some((row, i) => Math.abs(row[i]) <= tolerance)) {
+	        return Object.assign(Object.assign({}, minimumNorm(r, rhs)), { basis });
+	    }
+	    const coef = new Array(p);
+	    for (let i = p - 1; i >= 0; i--) {
+	        let value = rhs[i];
+	        for (let j = i + 1; j < p; j++) {
+	            value -= r[i][j] * coef[j];
+	        }
+	        coef[i] = value / r[i][i];
+	    }
+	    return { coef, rank: p, basis };
+	}
+	function regressionPrediction(model, x) {
+	    const z = normalizeRegression(x, model.basis.xCenter, model.basis.xScale);
+	    let value = 0;
+	    for (let j = model.coef.length - 1; j >= 0; j--) {
+	        value = value * z + model.coef[j];
+	    }
+	    return model.basis.yCenter + model.basis.yScale * value;
+	}
+	/** 保留公开的升幂 coef；预测始终使用稳定基底。 */
+	function regressionCoefficients(model) {
+	    let coef = [model.coef[model.coef.length - 1]];
+	    const a = -model.basis.xCenter / model.basis.xScale;
+	    const b = 1 / model.basis.xScale;
+	    for (let j = model.coef.length - 2; j >= 0; j--) {
+	        const next = new Array(coef.length + 1).fill(0);
+	        coef.forEach((c, i) => {
+	            next[i] += a * c;
+	            next[i + 1] += b * c;
+	        });
+	        next[0] += model.coef[j];
+	        coef = next;
 	    }
-	    q = Math.sqrt(-2 * Math.log(1 - p));
-	    return -((((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1));
+	    coef = coef.map(c => c * model.basis.yScale);
+	    coef[0] += model.basis.yCenter;
+	    if (coef.some(c => !Number.isFinite(c))) {
+	        throw new RangeError('Regression coefficients are not finite');
+	    }
+	    return coef;
 	}
+	function regressionGrid(min, max, count, predict) {
+	    if (!Number.isInteger(count) || count <= 0 || !Number.isFinite(min) || !Number.isFinite(max)) {
+	        return [];
+	    }
+	    const width = max - min;
+	    const step = count === 1 ? 0 : width / (count - 1);
+	    return Array.from({ length: count }, (_, i) => {
+	        const t = count === 1 ? 0 : i / (count - 1);
+	        const x = i === 0 ? min : i === count - 1 ? max : Number.isFinite(width) ? min + i * step : (1 - t) * min + t * max;
+	        return { x, y: predict(x) };
+	    });
+	}
+
+	/** Compute a two-sided normal critical value without subtracting a small tail probability from one. */
+	function confidenceCriticalValue(alpha) {
+	    if (!Number.isFinite(alpha) || alpha < 0 || alpha > 1) {
+	        return NaN;
+	    }
+	    return -normalQuantile(alpha / 2);
+	}
+	/** A zero standard error gives a degenerate interval even when the critical value is infinite. */
+	function confidenceHalfWidth(z, standardError) {
+	    if (Number.isNaN(z)) {
+	        return NaN;
+	    }
+	    return standardError === 0 ? 0 : z * standardError;
+	}
+	/**
+	 * Compute basic components used for linear regression confidence / prediction intervals.
+	 * - scans data to compute min/max of x, n, mean X, SSE and Sxx (sum (xi - X)^2).
+	 */
 	function computeLinearCIComponents(data, x, y, predict) {
+	    // simple local scanner to avoid circular imports
 	    let min = Infinity;
 	    let max = -Infinity;
 	    let n = 0;
@@ -1797,6 +2501,9 @@
 	    }
 	    return { min, max, n, X, SSE, Sxx };
 	}
+	/**
+	 * Compute standard errors for mean and prediction at px using components.
+	 */
 	function stdErrorsAt(px, comps) {
 	    const { n, X, Sxx, SSE } = comps;
 	    const s2 = n > 2 ? SSE / (n - 2) : 0;
@@ -1805,6 +2512,10 @@
 	    return { seMean, sePred };
 	}
 
+	/**
+	 * Linear regression utilities (single clean implementation).
+	 * Exports: ordinaryLeastSquares, visitPoints, rSquared, regressionLinear
+	 */
 	function ordinaryLeastSquares(uX, uY, uXY, uX2) {
 	    const denom = uX2 - uX * uX;
 	    if (Math.abs(denom) < Number.EPSILON) {
@@ -1843,56 +2554,39 @@
 	function regressionLinear(data, x = d => d.x, y = d => d.y, options) {
 	    var _a;
 	    const alpha = (_a = options === null || options === void 0 ? void 0 : options.alpha) !== null && _a !== void 0 ? _a : 0.05;
-	    let n = 0;
-	    let meanX = 0;
+	    const points = regressionPoints(data, x, y);
+	    const model = fitRegression(points, 1);
+	    const coef = regressionCoefficients(model);
+	    const a = coef[0];
+	    const b = coef[1];
+	    const predict = (xx) => regressionPrediction(model, xx);
+	    const comps = computeLinearCIComponents(data, x, y, predict);
 	    let meanY = 0;
-	    let meanXY = 0;
-	    let meanX2 = 0;
-	    visitPoints(data, x, y, (xi, yi) => {
-	        n++;
-	        meanX += (xi - meanX) / n;
-	        meanY += (yi - meanY) / n;
-	        meanXY += (xi * yi - meanXY) / n;
-	        meanX2 += (xi * xi - meanX2) / n;
+	    points.forEach((p, i) => {
+	        meanY += (p.y - meanY) / (i + 1);
 	    });
-	    const { a, b } = ordinaryLeastSquares(meanX, meanY, meanXY, meanX2);
-	    const predict = (xx) => a + b * xx;
-	    const comps = computeLinearCIComponents(data, x, y, predict);
 	    function evaluateGrid(N) {
-	        const out = [];
-	        if (comps.n === 0 || N <= 0) {
-	            return out;
-	        }
-	        if (comps.min === comps.max) {
-	            for (let i = 0; i < N; i++) {
-	                out.push({ x: comps.min, y: predict(comps.min) });
-	            }
-	            return out;
-	        }
-	        const step = (comps.max - comps.min) / (N - 1);
-	        for (let i = 0; i < N; i++) {
-	            const px = i === N - 1 ? comps.max : comps.min + step * i;
-	            out.push({ x: px, y: predict(px) });
-	        }
-	        return out;
+	        return regressionGrid(comps.min, comps.max, N, predict);
 	    }
 	    function confidenceInterval(N = 50) {
 	        const out = [];
 	        if (comps.n === 0 || N <= 0) {
 	            return out;
 	        }
-	        const z = invNorm(1 - alpha / 2);
+	        const z = confidenceCriticalValue(alpha);
 	        if (comps.min === comps.max) {
 	            const m = predict(comps.min);
 	            const errs = stdErrorsAt(comps.min, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            for (let i = 0; i < N; i++) {
 	                out.push({
 	                    x: comps.min,
 	                    mean: m,
-	                    lower: m - z * errs.seMean,
-	                    upper: m + z * errs.seMean,
-	                    predLower: m - z * errs.sePred,
-	                    predUpper: m + z * errs.sePred
+	                    lower: m - meanHalfWidth,
+	                    upper: m + meanHalfWidth,
+	                    predLower: m - predHalfWidth,
+	                    predUpper: m + predHalfWidth
 	                });
 	            }
 	            return out;
@@ -1902,19 +2596,22 @@
 	            const px = i === N - 1 ? comps.max : comps.min + step * i;
 	            const m = predict(px);
 	            const errs = stdErrorsAt(px, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            out.push({
 	                x: px,
 	                mean: m,
-	                lower: m - z * errs.seMean,
-	                upper: m + z * errs.seMean,
-	                predLower: m - z * errs.sePred,
-	                predUpper: m + z * errs.sePred
+	                lower: m - meanHalfWidth,
+	                upper: m + meanHalfWidth,
+	                predLower: m - predHalfWidth,
+	                predUpper: m + predHalfWidth
 	            });
 	        }
 	        return out;
 	    }
 	    return {
 	        coef: { a, b },
+	        rank: model.rank,
 	        predict,
 	        rSquared: rSquared(data, x, y, meanY, predict),
 	        evaluateGrid,
@@ -1922,11 +2619,18 @@
 	    };
 	}
 
+	/**
+	 * Simple logistic regression (binary) using Newton-Raphson (IRLS).
+	 * Returns { coef, predict, evaluateGrid }
+	 * - coef: [intercept, beta]
+	 * - predict(x): probability p(y=1|x)
+	 */
 	function regressionLogistic(data, x = d => d.x, y = d => d.y, options) {
 	    var _a, _b, _c;
 	    const maxIter = (_a = options === null || options === void 0 ? void 0 : options.maxIteration) !== null && _a !== void 0 ? _a : 25;
 	    const tol = (_b = options === null || options === void 0 ? void 0 : options.tol) !== null && _b !== void 0 ? _b : 1e-6;
 	    const alpha = (_c = options === null || options === void 0 ? void 0 : options.alpha) !== null && _c !== void 0 ? _c : 0.05;
+	    // build arrays
 	    const xs = [];
 	    const ys = [];
 	    visitPoints(data, x, y, (dx, dy) => {
@@ -1942,6 +2646,7 @@
 	            confidenceInterval: (N = 50) => []
 	        };
 	    }
+	    // initial coef via linear regression rough guess
 	    let intercept = 0;
 	    let beta = 0;
 	    for (let iter = 0; iter < maxIter; iter++) {
@@ -1952,6 +2657,7 @@
 	            const pi = 1 / (1 + Math.exp(-z));
 	            p[i] = pi;
 	        }
+	        // compute gradient and hessian
 	        let g0 = 0;
 	        let g1 = 0;
 	        let h00 = 0;
@@ -1966,6 +2672,7 @@
 	            h01 += wi * xs[i];
 	            h11 += wi * xs[i] * xs[i];
 	        }
+	        // solve 2x2 system H * delta = g
 	        const det = h00 * h11 - h01 * h01;
 	        if (Math.abs(det) < 1e-12) {
 	            break;
@@ -2026,18 +2733,20 @@
 	        if (comps.n === 0) {
 	            return out;
 	        }
-	        const z = Math.abs(invNorm(1 - alpha / 2));
+	        const z = confidenceCriticalValue(alpha);
 	        if (comps.min === comps.max) {
 	            const v = predict(comps.min);
 	            const errs = stdErrorsAt(comps.min, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            for (let i = 0; i < N; i++) {
 	                out.push({
 	                    x: comps.min,
 	                    mean: v,
-	                    lower: v - z * errs.seMean,
-	                    upper: v + z * errs.seMean,
-	                    predLower: v - z * errs.sePred,
-	                    predUpper: v + z * errs.sePred
+	                    lower: v - meanHalfWidth,
+	                    upper: v + meanHalfWidth,
+	                    predLower: v - predHalfWidth,
+	                    predUpper: v + predHalfWidth
 	                });
 	            }
 	            return out;
@@ -2047,13 +2756,15 @@
 	            const px = i === N - 1 ? comps.max : comps.min + step * i;
 	            const yh = predict(px);
 	            const errs = stdErrorsAt(px, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            out.push({
 	                x: px,
 	                mean: yh,
-	                lower: yh - z * errs.seMean,
-	                upper: yh + z * errs.seMean,
-	                predLower: yh - z * errs.sePred,
-	                predUpper: yh + z * errs.sePred
+	                lower: yh - meanHalfWidth,
+	                upper: yh + meanHalfWidth,
+	                predLower: yh - predHalfWidth,
+	                predUpper: yh + predHalfWidth
 	            });
 	        }
 	        return out;
@@ -2066,193 +2777,226 @@
 	    };
 	}
 
-	function tricube(u) {
-	    const uu = Math.abs(u);
-	    if (uu >= 1) {
-	        return 0;
-	    }
-	    const t = 1 - uu * uu * uu;
-	    return t * t * t;
-	}
-	function stratifiedSample(sortedData, maxSamples) {
-	    const n = sortedData.length;
-	    if (n <= maxSamples) {
-	        return sortedData;
-	    }
-	    const sampled = [];
-	    const step = n / maxSamples;
-	    for (let i = 0; i < maxSamples; i++) {
-	        const idx = Math.min(Math.floor(i * step), n - 1);
-	        sampled.push(sortedData[idx]);
-	    }
-	    return sampled;
-	}
+	/**
+	 * 局部线性 LOWESS。默认全量观测、span=2/3、三次稳健重加权。
+	 * delta 显式插值加速；maxSamples 仅保留显式选择的历史抽样用途。
+	 * predict 与 evaluateGrid 查询构建时固定的同一模型，不触发再拟合。
+	 */
 	function regressionLowess(data, x = d => d.x, y = d => d.y, options = {}) {
-	    var _a;
-	    const span = options.span || 0.3;
-	    const degree = options.degree === 0 ? 0 : 1;
-	    const alpha = (_a = options.alpha) !== null && _a !== void 0 ? _a : 0.05;
-	    const iterations = options.iterations == null ? 2 : options.iterations;
-	    const maxSamples = options.maxSamples || 1000;
-	    const rawPoints = [];
-	    visitPoints(data, x, y, (dx, dy, index) => {
-	        rawPoints.push({ x: dx, y: dy, index });
-	    });
-	    rawPoints.sort((a, b) => a.x - b.x);
-	    const sampledPoints = stratifiedSample(rawPoints, maxSamples);
-	    const n = sampledPoints.length;
-	    const ptsX = new Array(n);
-	    const ptsY = new Array(n);
-	    for (let i = 0; i < n; i++) {
-	        ptsX[i] = sampledPoints[i].x;
-	        ptsY[i] = sampledPoints[i].y;
-	    }
-	    function predictSingle(x0, robustWeights) {
-	        if (n === 0) {
+	    var _a, _b, _c, _d, _e;
+	    const span = (_a = options.span) !== null && _a !== void 0 ? _a : 2 / 3;
+	    const degree = (_b = options.degree) !== null && _b !== void 0 ? _b : 1;
+	    const iterations = (_c = options.iterations) !== null && _c !== void 0 ? _c : 3;
+	    const delta = (_d = options.delta) !== null && _d !== void 0 ? _d : 0;
+	    const alpha = (_e = options.alpha) !== null && _e !== void 0 ? _e : 0.05;
+	    if (!(span > 0 && span <= 1) ||
+	        !Number.isInteger(iterations) ||
+	        iterations < 0 ||
+	        !Number.isFinite(delta) ||
+	        delta < 0 ||
+	        (degree !== 0 && degree !== 1) ||
+	        (options.maxSamples != null && (!Number.isInteger(options.maxSamples) || options.maxSamples < 2))) {
+	        throw new RangeError('Invalid LOWESS span, degree, iterations, delta or maxSamples');
+	    }
+	    let pts = regressionPoints(data, x, y).sort((a, b) => a.x - b.x || a.y - b.y);
+	    if (options.maxSamples != null && pts.length > options.maxSamples) {
+	        const full = pts;
+	        const count = options.maxSamples;
+	        pts = Array.from({ length: count }, (_, i) => full[Math.floor((i * (full.length - 1)) / (count - 1))]);
+	    }
+	    const n = pts.length;
+	    const ptsX = pts.map(p => p.x);
+	    const ptsY = pts.map(p => p.y);
+	    const basis = regressionBasis(pts);
+	    const normalizedX = ptsX.map(v => normalizeRegression(v, basis.xCenter, basis.xScale));
+	    const normalizedY = ptsY.map(v => normalizeRegression(v, basis.yCenter, basis.yScale));
+	    const count = Math.min(n, Math.max(2, Math.floor(span * n + 1e-10)));
+	    let robustWeights;
+	    function exact(x0) {
+	        if (!n) {
 	            return 0;
 	        }
+	        const query = normalizeRegression(x0, basis.xCenter, basis.xScale);
+	        // 找到连续的最近邻窗口；相等距离选择较小的 x（ties 的 y 已排序）。
 	        let left = 0;
-	        let right = n;
+	        let right = n - count;
 	        while (left < right) {
-	            const mid = (left + right) >> 1;
-	            if (ptsX[mid] < x0) {
+	            const mid = (left + right) >>> 1;
+	            const lowerDistance = x0 - ptsX[mid];
+	            const upperDistance = ptsX[mid + count] - x0;
+	            if (Number.isFinite(lowerDistance) && Number.isFinite(upperDistance)
+	                ? lowerDistance > upperDistance
+	                : query - normalizedX[mid] > normalizedX[mid + count] - query) {
 	                left = mid + 1;
 	            }
 	            else {
 	                right = mid;
 	            }
 	        }
-	        const m = Math.min(n, Math.max(2, Math.floor(span * n)));
-	        let lo = left - 1;
-	        let hi = left;
-	        for (let count = 0; count < m; count++) {
-	            if (lo >= 0 && (hi >= n || x0 - ptsX[lo] <= ptsX[hi] - x0)) {
-	                lo--;
+	        let start = left;
+	        let end = left + count;
+	        if (ptsX[start] === ptsX[end - 1]) {
+	            while (start > 0 && ptsX[start - 1] === ptsX[start]) {
+	                start--;
 	            }
-	            else {
-	                hi++;
-	            }
-	        }
-	        const actualStart = lo + 1;
-	        const end = hi;
-	        let maxDist = 0;
-	        const windowSize = end - actualStart;
-	        const distances = new Array(windowSize);
-	        for (let i = actualStart; i < end; i++) {
-	            const dist = Math.abs(ptsX[i] - x0);
-	            distances[i - actualStart] = dist;
-	            if (dist > maxDist) {
-	                maxDist = dist;
-	            }
-	        }
-	        let sumw = 0;
-	        const w = new Array(windowSize);
-	        for (let i = 0; i < windowSize; i++) {
-	            const u = maxDist === 0 ? 0 : distances[i] / maxDist;
-	            let wi = tricube(u);
-	            if (robustWeights && robustWeights[actualStart + i] != null) {
-	                wi *= robustWeights[actualStart + i];
-	            }
-	            w[i] = wi;
-	            sumw += wi;
-	        }
-	        if (sumw === 0) {
-	            let nearestIdx = 0;
-	            let nearestDistance = Math.abs(ptsX[0] - x0);
-	            for (let i = 1; i < n; i++) {
-	                const distance = Math.abs(ptsX[i] - x0);
-	                if (distance < nearestDistance ||
-	                    (distance === nearestDistance && sampledPoints[i].index < sampledPoints[nearestIdx].index)) {
-	                    nearestIdx = i;
-	                    nearestDistance = distance;
-	                }
+	            while (end < n && ptsX[end] === ptsX[start]) {
+	                end++;
 	            }
-	            return ptsY[nearestIdx];
 	        }
-	        if (degree === 0) {
-	            let s = 0;
-	            for (let i = 0; i < w.length; i++) {
-	                s += w[i] * ptsY[actualStart + i];
-	            }
-	            return s / sumw;
+	        const rawRadius = Math.max(Math.abs(ptsX[start] - x0), Math.abs(ptsX[end - 1] - x0));
+	        const scaled = !Number.isFinite(rawRadius);
+	        const radius = scaled
+	            ? Math.max(Math.abs(normalizedX[start] - query), Math.abs(normalizedX[end - 1] - query))
+	            : rawRadius;
+	        // 局部响应坐标不能由远处、未参与该邻域的观测决定精度。
+	        let yMin = Infinity;
+	        let yMax = -Infinity;
+	        for (let i = start; i < end; i++) {
+	            yMin = Math.min(yMin, ptsY[i]);
+	            yMax = Math.max(yMax, ptsY[i]);
 	        }
+	        const yCenter = yMin / 2 + yMax / 2;
+	        const yScale = Math.max(Math.abs(yMin - yCenter), Math.abs(yMax - yCenter)) || 1;
 	        let sw = 0;
 	        let sx = 0;
 	        let sy = 0;
 	        let sxx = 0;
 	        let sxy = 0;
-	        for (let i = actualStart; i < end; i++) {
-	            const idx = i - actualStart;
-	            const xi = ptsX[i];
-	            const yi = ptsY[i];
-	            const wi = w[idx];
-	            sw += wi;
-	            sx += wi * xi;
-	            sy += wi * yi;
-	            sxx += wi * xi * xi;
-	            sxy += wi * xi * yi;
-	        }
-	        const meanX = sx / sw;
-	        const meanY = sy / sw;
-	        const denom = sxx - sx * meanX;
-	        const slope = Math.abs(denom) < 1e-12 ? 0 : (sxy - sx * meanY) / denom;
-	        const intercept = meanY - slope * meanX;
-	        return intercept + slope * x0;
+	        for (let i = start; i < end; i++) {
+	            const z = radius === 0 ? 0 : (scaled ? normalizedX[i] - query : ptsX[i] - x0) / radius;
+	            const u = Math.abs(z);
+	            const t = u >= 1 ? 0 : 1 - u * u * u;
+	            const w = t * t * t * (robustWeights ? robustWeights[i] : 1);
+	            sw += w;
+	            sx += w * z;
+	            const response = normalizeRegression(ptsY[i], yCenter, yScale);
+	            sy += w * response;
+	            sxx += w * z * z;
+	            sxy += w * z * response;
+	        }
+	        if (sw === 0) {
+	            // 核边界零权重时使用最近有效观测的加权常数；等距离取均值。
+	            let distance = Infinity;
+	            let weight = 0;
+	            let value = 0;
+	            for (let i = 0; i < n; i++) {
+	                const w = robustWeights ? robustWeights[i] : 1;
+	                if (w === 0) {
+	                    continue;
+	                }
+	                const d = Math.abs(scaled ? normalizedX[i] - query : ptsX[i] - x0);
+	                if (d < distance) {
+	                    distance = d;
+	                    weight = w;
+	                    value = ptsY[i];
+	                }
+	                else if (d === distance) {
+	                    value = value * (weight / (weight + w)) + ptsY[i] * (w / (weight + w));
+	                    weight += w;
+	                }
+	            }
+	            if (weight === 0) {
+	                throw new RangeError('LOWESS has no effective local observations');
+	            }
+	            return value;
+	        }
+	        const mx = sx / sw;
+	        const my = sy / sw;
+	        const variance = sxx / sw - mx * mx;
+	        const slope = degree === 0 || variance <= Number.EPSILON * 32 ? 0 : (sxy / sw - mx * my) / variance;
+	        return yCenter + yScale * (my - slope * mx);
+	    }
+	    // delta 不删除观测。只减少局部回归求值位置，全部残差参与重加权。
+	    const anchors = [];
+	    for (let i = 0; i < n;) {
+	        anchors.push(i);
+	        if (i === n - 1) {
+	            break;
+	        }
+	        let next = i + 1;
+	        if (delta > 0) {
+	            while (next + 1 < n && ptsX[next + 1] - ptsX[i] <= delta) {
+	                next++;
+	            }
+	        }
+	        // 重复 x 一起使用同一预测；端点不能丢失。
+	        while (next + 1 < n && ptsX[next + 1] === ptsX[next]) {
+	            next++;
+	        }
+	        i = next;
 	    }
-	    function predict(x0) {
-	        if (Array.isArray(x0)) {
-	            const len = x0.length;
-	            const out = new Array(len);
-	            for (let i = 0; i < len; i++) {
-	                out[i] = predictSingle(x0[i]);
+	    let fits = new Array(n);
+	    function fitObservations() {
+	        const out = new Array(n);
+	        for (let a = 0; a < anchors.length; a++) {
+	            const index = anchors[a];
+	            out[index] = exact(ptsX[index]);
+	            if (a === 0) {
+	                continue;
+	            }
+	            const previous = anchors[a - 1];
+	            const rawWidth = ptsX[index] - ptsX[previous];
+	            const width = Number.isFinite(rawWidth) ? rawWidth : normalizedX[index] - normalizedX[previous];
+	            for (let i = previous + 1; i < index; i++) {
+	                const t = width === 0
+	                    ? 0
+	                    : (Number.isFinite(rawWidth) ? ptsX[i] - ptsX[previous] : normalizedX[i] - normalizedX[previous]) / width;
+	                out[i] = out[previous] * (1 - t) + out[index] * t;
 	            }
-	            return out;
 	        }
-	        return predictSingle(x0);
+	        return out;
 	    }
-	    function evaluateGrid(N) {
-	        if (N <= 0) {
-	            return [];
+	    for (let iteration = 0; iteration <= iterations; iteration++) {
+	        fits = fitObservations();
+	        if (iteration === iterations) {
+	            break;
 	        }
-	        if (n === 0) {
-	            return [];
+	        const residuals = fits.map((v, i) => {
+	            const residual = ptsY[i] - v;
+	            return Number.isFinite(residual)
+	                ? Math.abs(residual / basis.yScale)
+	                : Math.abs(normalizedY[i] - normalizeRegression(v, basis.yCenter, basis.yScale));
+	        });
+	        const med = median(residuals.slice());
+	        const currentFits = fits;
+	        robustWeights = residuals.map((r, i) => {
+	            if (med === 0) {
+	                const tolerance = Number.EPSILON * 64 * (Math.max(Math.abs(ptsY[i]), Math.abs(currentFits[i])) / basis.yScale);
+	                return r <= tolerance ? 1 : 0;
+	            }
+	            const u = r / (6 * med);
+	            return u >= 1 ? 0 : (1 - u * u) ** 2;
+	        });
+	    }
+	    function predictSingle(x0) {
+	        if (delta === 0 || n < 2 || x0 < ptsX[0] || x0 > ptsX[n - 1]) {
+	            return exact(x0);
 	        }
-	        const out = new Array(N);
-	        const min = ptsX[0];
-	        const max = ptsX[n - 1];
-	        if (min === max) {
-	            const v = predictSingle(min);
-	            for (let i = 0; i < N; i++) {
-	                out[i] = { x: min, y: v };
+	        let lo = 0;
+	        let hi = n - 1;
+	        while (hi - lo > 1) {
+	            const mid = (lo + hi) >>> 1;
+	            if (ptsX[mid] <= x0) {
+	                lo = mid;
 	            }
-	            return out;
-	        }
-	        const step = (max - min) / (N - 1);
-	        let robustWeights;
-	        const effectiveIterations = options.iterations != null ? iterations : n > 500 ? 0 : iterations;
-	        if (effectiveIterations > 0) {
-	            for (let iter = 0; iter < effectiveIterations; iter++) {
-	                const fits = new Array(n);
-	                const res = new Array(n);
-	                for (let i = 0; i < n; i++) {
-	                    fits[i] = predictSingle(ptsX[i], robustWeights);
-	                    res[i] = Math.abs(ptsY[i] - fits[i]);
-	                }
-	                const sortedRes = res.slice().sort((a, b) => a - b);
-	                const med = sortedRes[Math.floor(n / 2)] || 0;
-	                robustWeights = new Array(n);
-	                for (let i = 0; i < n; i++) {
-	                    const u = med === 0 ? 0 : res[i] / (6 * med);
-	                    const w = Math.abs(u) >= 1 ? 0 : (1 - u * u) * (1 - u * u);
-	                    robustWeights[i] = w;
-	                }
+	            else {
+	                hi = mid;
 	            }
 	        }
-	        for (let i = 0; i < N; i++) {
-	            const px = i === N - 1 ? max : min + step * i;
-	            out[i] = { x: px, y: predictSingle(px, robustWeights) };
+	        if (ptsX[hi] === ptsX[lo]) {
+	            return fits[lo];
 	        }
-	        return out;
+	        const width = ptsX[hi] - ptsX[lo];
+	        const t = Number.isFinite(width)
+	            ? (x0 - ptsX[lo]) / width
+	            : (normalizeRegression(x0, basis.xCenter, basis.xScale) - normalizedX[lo]) / (normalizedX[hi] - normalizedX[lo]);
+	        return fits[lo] * (1 - t) + fits[hi] * t;
+	    }
+	    function predict(x0) {
+	        return Array.isArray(x0) ? x0.map(predictSingle) : predictSingle(x0);
+	    }
+	    function evaluateGrid(N) {
+	        return regressionGrid(ptsX[0], ptsX[n - 1], N, predictSingle);
 	    }
 	    function confidenceInterval(N = 50) {
 	        const out = [];
@@ -2262,6 +3006,7 @@
 	        if (n === 0) {
 	            return out;
 	        }
+	        // use data x-range (already sorted)
 	        const min = ptsX[0];
 	        const max = ptsX[n - 1];
 	        if (min === undefined || max === undefined || min === Infinity || max === -Infinity) {
@@ -2271,18 +3016,20 @@
 	        if (comps.n === 0) {
 	            return out;
 	        }
-	        const z = Math.abs(invNorm(1 - alpha / 2));
+	        const z = confidenceCriticalValue(alpha);
 	        if (comps.min === comps.max) {
 	            const v = predictSingle(comps.min);
 	            const errs = stdErrorsAt(comps.min, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            for (let i = 0; i < N; i++) {
 	                out.push({
 	                    x: comps.min,
 	                    mean: v,
-	                    lower: v - z * errs.seMean,
-	                    upper: v + z * errs.seMean,
-	                    predLower: v - z * errs.sePred,
-	                    predUpper: v + z * errs.sePred
+	                    lower: v - meanHalfWidth,
+	                    upper: v + meanHalfWidth,
+	                    predLower: v - predHalfWidth,
+	                    predUpper: v + predHalfWidth
 	                });
 	            }
 	            return out;
@@ -2292,13 +3039,15 @@
 	            const px = i === N - 1 ? max : min + step * i;
 	            const yh = predictSingle(px);
 	            const errs = stdErrorsAt(px, comps);
+	            const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	            const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	            out.push({
 	                x: px,
 	                mean: yh,
-	                lower: yh - z * errs.seMean,
-	                upper: yh + z * errs.seMean,
-	                predLower: yh - z * errs.sePred,
-	                predUpper: yh + z * errs.sePred
+	                lower: yh - meanHalfWidth,
+	                upper: yh + meanHalfWidth,
+	                predLower: yh - predHalfWidth,
+	                predUpper: yh + predHalfWidth
 	            });
 	        }
 	        return out;
@@ -2307,106 +3056,30 @@
 	        predict,
 	        evaluate: predict,
 	        evaluateGrid,
-	        confidenceInterval
+	        confidenceInterval,
+	        // 节点值按 x 排序，重复观测仍保持其统计权重。
+	        fitted: pts.map((p, i) => ({ x: p.x, y: fits[i] }))
 	    };
 	}
 
-	function solveLinearSystem(A, b) {
-	    const n = b.length;
-	    const M = new Array(n);
-	    for (let i = 0; i < n; i++) {
-	        M[i] = A[i].slice();
-	        M[i].push(b[i]);
-	    }
-	    for (let k = 0; k < n; k++) {
-	        let maxRow = k;
-	        let maxVal = Math.abs(M[k][k]);
-	        for (let i = k + 1; i < n; i++) {
-	            const v = Math.abs(M[i][k]);
-	            if (v > maxVal) {
-	                maxVal = v;
-	                maxRow = i;
-	            }
-	        }
-	        if (maxRow !== k) {
-	            const tmp = M[k];
-	            M[k] = M[maxRow];
-	            M[maxRow] = tmp;
-	        }
-	        if (Math.abs(M[k][k]) < 1e-12) {
-	            const res = new Array(n).fill(0);
-	            return res;
-	        }
-	        for (let j = k + 1; j <= n; j++) {
-	            M[k][j] = M[k][j] / M[k][k];
-	        }
-	        M[k][k] = 1;
-	        for (let i = 0; i < n; i++) {
-	            if (i === k) {
-	                continue;
-	            }
-	            const factor = M[i][k];
-	            if (factor === 0) {
-	                continue;
-	            }
-	            for (let j = k + 1; j <= n; j++) {
-	                M[i][j] -= factor * M[k][j];
-	            }
-	            M[i][k] = 0;
-	        }
-	    }
-	    const x = new Array(n);
-	    for (let i = 0; i < n; i++) {
-	        x[i] = M[i][n];
-	    }
-	    return x;
-	}
 	function regressionPolynomial(data, x = d => d.x, y = d => d.y, options = {}) {
 	    var _a, _b;
-	    let degree = (_a = options.degree) !== null && _a !== void 0 ? _a : 0;
-	    if (degree < 0) {
-	        degree = 0;
+	    const degree = (_a = options.degree) !== null && _a !== void 0 ? _a : 0;
+	    if (!Number.isInteger(degree) || degree < 0) {
+	        throw new RangeError('Polynomial degree must be an nonnegative integer');
 	    }
 	    const alpha = (_b = options.alpha) !== null && _b !== void 0 ? _b : 0.05;
-	    const m = degree + 1;
-	    const sums = new Array(2 * degree + 1).fill(0);
-	    visitPoints(data, x, y, (dx, dy) => {
-	        let xp = 1;
-	        for (let k = 0; k < sums.length; k++) {
-	            sums[k] += xp;
-	            xp *= dx;
-	        }
-	    });
-	    const A = new Array(m);
-	    for (let i = 0; i < m; i++) {
-	        A[i] = new Array(m).fill(0);
-	        for (let j = 0; j < m; j++) {
-	            A[i][j] = sums[i + j];
-	        }
-	    }
-	    const B = new Array(m).fill(0);
-	    visitPoints(data, x, y, (dx, dy) => {
-	        let xp = 1;
-	        for (let k = 0; k < m; k++) {
-	            B[k] += dy * xp;
-	            xp *= dx;
-	        }
-	    });
-	    const coef = solveLinearSystem(A, B);
-	    const predict = (xx) => {
-	        let xp = 1;
-	        let v = 0;
-	        for (let k = 0; k < coef.length; k++) {
-	            v += coef[k] * xp;
-	            xp *= xx;
-	        }
-	        return v;
-	    };
+	    const points = regressionPoints(data, x, y);
+	    const model = fitRegression(points, degree);
+	    const coef = regressionCoefficients(model);
+	    const predict = (xx) => regressionPrediction(model, xx);
 	    return {
 	        degree,
+	        rank: model.rank,
 	        coef,
 	        predict,
 	        rSquared: rSquared(data, x, y, (() => {
+	            // compute mean y
 	            let sum = 0;
 	            let cnt = 0;
 	            visitPoints(data, x, y, (_dx, dy) => {
@@ -2416,38 +3089,13 @@
 	            return cnt === 0 ? 0 : sum / cnt;
 	        })(), predict),
 	        evaluateGrid(N) {
-	            const out = [];
-	            if (N <= 0) {
-	                return out;
-	            }
 	            let min = Infinity;
 	            let max = -Infinity;
-	            visitPoints(data, x, y, dx => {
-	                if (!isNil(dx)) {
-	                    if (dx < min) {
-	                        min = dx;
-	                    }
-	                    if (dx > max) {
-	                        max = dx;
-	                    }
-	                }
+	            points.forEach(p => {
+	                min = Math.min(min, p.x);
+	                max = Math.max(max, p.x);
 	            });
-	            if (min === Infinity || max === -Infinity) {
-	                return out;
-	            }
-	            if (min === max) {
-	                const v = predict(min);
-	                for (let i = 0; i < N; i++) {
-	                    out.push({ x: min, y: v });
-	                }
-	                return out;
-	            }
-	            const step = (max - min) / (N - 1);
-	            for (let i = 0; i < N; i++) {
-	                const px = i === N - 1 ? max : min + step * i;
-	                out.push({ x: px, y: predict(px) });
-	            }
-	            return out;
+	            return regressionGrid(min, max, N, predict);
 	        },
 	        confidenceInterval(N = 50) {
 	            const out = [];
@@ -2458,18 +3106,20 @@
 	            if (comps.n === 0) {
 	                return out;
 	            }
-	            const z = Math.abs(invNorm(1 - alpha / 2));
+	            const z = confidenceCriticalValue(alpha);
 	            if (comps.min === comps.max) {
 	                const v = predict(comps.min);
 	                const errs = stdErrorsAt(comps.min, comps);
+	                const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	                const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	                for (let i = 0; i < N; i++) {
 	                    out.push({
 	                        x: comps.min,
 	                        mean: v,
-	                        lower: v - z * errs.seMean,
-	                        upper: v + z * errs.seMean,
-	                        predLower: v - z * errs.sePred,
-	                        predUpper: v + z * errs.sePred
+	                        lower: v - meanHalfWidth,
+	                        upper: v + meanHalfWidth,
+	                        predLower: v - predHalfWidth,
+	                        predUpper: v + predHalfWidth
 	                    });
 	                }
 	                return out;
@@ -2479,13 +3129,15 @@
 	                const px = i === N - 1 ? comps.max : comps.min + step * i;
 	                const yh = predict(px);
 	                const errs = stdErrorsAt(px, comps);
+	                const meanHalfWidth = confidenceHalfWidth(z, errs.seMean);
+	                const predHalfWidth = confidenceHalfWidth(z, errs.sePred);
 	                out.push({
 	                    x: px,
 	                    mean: yh,
-	                    lower: yh - z * errs.seMean,
-	                    upper: yh + z * errs.seMean,
-	                    predLower: yh - z * errs.sePred,
-	                    predUpper: yh + z * errs.sePred
+	                    lower: yh - meanHalfWidth,
+	                    upper: yh + meanHalfWidth,
+	                    predLower: yh - predHalfWidth,
+	                    predUpper: yh + predHalfWidth
 	                });
 	            }
 	            return out;
@@ -2493,14 +3145,29 @@
 	    };
 	}
 
+	/**
+	 * Kernel Density Estimation (KDE) utilities
+	 *
+	 * Exports:
+	 * - Kernel functions: gaussian, epanechnikov
+	 * - bandwidth selectors: scott, silverman
+	 * - kde: main function to compute density estimates at provided points
+	 */
+	/** Gaussian kernel (standard normal) */
 	const gaussian = (u) => {
 	    const invSqrt2Pi = 1 / Math.sqrt(2 * Math.PI);
 	    return invSqrt2Pi * Math.exp(-0.5 * u * u);
 	};
+	/** Epanechnikov kernel (compact support) */
 	const epanechnikov = (u) => {
 	    const absu = Math.abs(u);
 	    return absu <= 1 ? 0.75 * (1 - u * u) : 0;
 	};
+	/**
+	 * Bandwidth selectors
+	 * - scott: h = n^{-1/(d+4)} * std
+	 * - silverman: h = ( (4/(d+2))^{1/(d+4)} ) * n^{-1/(d+4)} * std
+	 */
 	function scott(n, std, dim = 1) {
 	    if (n <= 0 || std === 0) {
 	        return 0;
@@ -2514,6 +3181,9 @@
 	    const factor = Math.pow(4 / (dim + 2), 1 / (dim + 4));
 	    return factor * std * Math.pow(n, -1 / (dim + 4));
 	}
+	/**
+	 * Compute standard deviation for numeric array
+	 */
 	function std(values) {
 	    const n = values.length;
 	    if (n === 0) {
@@ -2531,6 +3201,10 @@
 	    }
 	    return Math.sqrt(s / n);
 	}
+	/**
+	 * Factory: create a KDE evaluator for given data and options.
+	 * Usage: const model = kde(data, options); model.evaluate(x) or model.evaluate([x1,x2])
+	 */
 	function kde(data, options = {}) {
 	    const n = data.length;
 	    const kernel = options.kernel || gaussian;
@@ -2545,6 +3219,7 @@
 	            h = scott(n, sd, 1);
 	        }
 	    }
+	    // if still zero (constant data), evaluator returns zeros
 	    if (!h || h <= 0) {
 	        const zerosEval = (x) => {
 	            if (Array.isArray(x)) {
@@ -2561,6 +3236,7 @@
 	            if (N <= 0) {
 	                return out;
 	            }
+	            // compute data min (use data range if available)
 	            let min = Infinity;
 	            let max = -Infinity;
 	            for (let j = 0; j < n; j++) {
@@ -2617,6 +3293,7 @@
 	            if (N <= 0) {
 	                return out;
 	            }
+	            // compute data range
 	            let min = Infinity;
 	            let max = -Infinity;
 	            for (let i = 0; i < n; i++) {
@@ -2632,6 +3309,7 @@
 	                return out;
 	            }
 	            if (min === max) {
+	                // single point repeated
 	                for (let i = 0; i < N; i++) {
 	                    out.push({ x: min, y: evalPoint(min) });
 	                }
@@ -2647,6 +3325,14 @@
 	    };
 	}
 
+	/**
+	 * Empirical Cumulative Distribution Function (ECDF)
+	 * Returns a factory that builds an evaluator over provided samples.
+	 * The evaluator exposes:
+	 * - evaluate(x:number) => proportion of samples <= x
+	 * - evaluate(xs:number[]) => number[]
+	 * - evaluateGrid(N:number) => { points: number[], cdf: number[] } over sample range
+	 */
 	function ecdf(data) {
 	    const n = data.length;
 	    const sorted = data.slice().sort((a, b) => a - b);
@@ -2654,8 +3340,9 @@
 	        if (n === 0) {
 	            return 0;
 	        }
+	        // count of values <= x (upper bound index)
 	        let lo = 0;
-	        let hi = n;
+	        let hi = n; // exclusive
 	        while (lo < hi) {
 	            const mid = (lo + hi) >>> 1;
 	            if (sorted[mid] <= x) {
@@ -2707,8 +3394,241 @@
 	    };
 	}
 
+	function pearson(x, y) {
+	    let sx = 0;
+	    let sy = 0;
+	    for (let i = 0; i < x.length; i++) {
+	        sx = Math.max(sx, Math.abs(x[i]));
+	        sy = Math.max(sy, Math.abs(y[i]));
+	    }
+	    if (!sx || !sy) {
+	        return undefined;
+	    }
+	    let mx = 0;
+	    let my = 0;
+	    let cx = 0;
+	    let cy = 0;
+	    for (let i = 0; i < x.length; i++) {
+	        const vx = x[i] / sx - cx;
+	        const vy = y[i] / sy - cy;
+	        const tx = mx + vx;
+	        const ty = my + vy;
+	        cx = tx - mx - vx;
+	        cy = ty - my - vy;
+	        mx = tx;
+	        my = ty;
+	    }
+	    mx /= x.length;
+	    my /= x.length;
+	    let xx = 0;
+	    let yy = 0;
+	    let xy = 0;
+	    for (let i = 0; i < x.length; i++) {
+	        const dx = x[i] / sx - mx;
+	        const dy = y[i] / sy - my;
+	        xx += dx * dx;
+	        yy += dy * dy;
+	        xy += dx * dy;
+	    }
+	    if (xx === 0 || yy === 0) {
+	        return undefined;
+	    }
+	    const result = xy / Math.sqrt(xx * yy);
+	    // 仅修正浮点舍入越过理论端点的几个 ulp。
+	    if (Math.abs(result) > 1 && Math.abs(result) <= 1 + 8 * Number.EPSILON) {
+	        return Math.sign(result);
+	    }
+	    return result;
+	}
+	function ranks(values) {
+	    const order = values.map((value, index) => ({ value, index })).sort((a, b) => a.value - b.value);
+	    const result = new Array(values.length);
+	    for (let start = 0; start < order.length;) {
+	        let end = start + 1;
+	        while (end < order.length && order[end].value === order[start].value) {
+	            end++;
+	        }
+	        const rank = (start + end + 1) / 2;
+	        for (let i = start; i < end; i++) {
+	            result[order[i].index] = rank;
+	        }
+	        start = end;
+	    }
+	    return result;
+	}
+	function kendall(x, y) {
+	    const pairs = x.map((value, index) => ({ x: value, y: y[index] })).sort((a, b) => a.x - b.x || a.y - b.y);
+	    const sortedY = [...y].sort((a, b) => a - b);
+	    const yRanks = new Map();
+	    let tiesY = 0;
+	    for (let start = 0; start < sortedY.length;) {
+	        let end = start + 1;
+	        while (end < sortedY.length && sortedY[end] === sortedY[start]) {
+	            end++;
+	        }
+	        tiesY += ((end - start) * (end - start - 1)) / 2;
+	        yRanks.set(sortedY[start], yRanks.size + 1);
+	        start = end;
+	    }
+	    const tree = new Float64Array(yRanks.size + 1);
+	    let tiesX = 0;
+	    let tiesBoth = 0;
+	    let discordant = 0;
+	    for (let start = 0; start < pairs.length;) {
+	        let end = start + 1;
+	        while (end < pairs.length && pairs[end].x === pairs[start].x) {
+	            end++;
+	        }
+	        tiesX += ((end - start) * (end - start - 1)) / 2;
+	        for (let i = start; i < end;) {
+	            let j = i + 1;
+	            while (j < end && pairs[j].y === pairs[i].y) {
+	                j++;
+	            }
+	            tiesBoth += ((j - i) * (j - i - 1)) / 2;
+	            i = j;
+	        }
+	        // 同 x 组先查询再更新，避免将 x ties 算成逆序。
+	        for (let i = start; i < end; i++) {
+	            let lessOrEqual = 0;
+	            for (let rank = yRanks.get(pairs[i].y); rank > 0; rank -= rank & -rank) {
+	                lessOrEqual += tree[rank];
+	            }
+	            discordant += start - lessOrEqual;
+	        }
+	        for (let i = start; i < end; i++) {
+	            for (let rank = yRanks.get(pairs[i].y); rank < tree.length; rank += rank & -rank) {
+	                tree[rank]++;
+	            }
+	        }
+	        start = end;
+	    }
+	    const total = (x.length * (x.length - 1)) / 2;
+	    if (total === tiesX || total === tiesY) {
+	        return undefined;
+	    }
+	    return (total - tiesX - tiesY + tiesBoth - 2 * discordant) / Math.sqrt((total - tiesX) * (total - tiesY));
+	}
+	/** 等长有限样本的相关系数；常量/不足两条返回 undefined，不修改数组。 */
+	function correlation(x, y, method = 'pearson') {
+	    if (x.length !== y.length ||
+	        !['pearson', 'spearman', 'kendall'].includes(method) ||
+	        x.some(value => !Number.isFinite(value)) ||
+	        y.some(value => !Number.isFinite(value))) {
+	        throw new RangeError('correlation requires equal finite arrays and a supported method');
+	    }
+	    if (x.length < 2) {
+	        return undefined;
+	    }
+	    return method === 'kendall' ? kendall(x, y) : method === 'spearman' ? pearson(ranks(x), ranks(y)) : pearson(x, y);
+	}
+
+	/** 有限数值的均值；空输入没有均值，不修改输入。 */
+	function mean(values) {
+	    if (!values.length) {
+	        return undefined;
+	    }
+	    let scale = 0;
+	    for (const value of values) {
+	        if (!Number.isFinite(value)) {
+	            throw new RangeError('mean requires finite numbers');
+	        }
+	        scale = Math.max(scale, Math.abs(value));
+	    }
+	    if (scale === 0) {
+	        return 0;
+	    }
+	    let sum = 0;
+	    let correction = 0;
+	    for (const value of values) {
+	        const next = value / scale;
+	        const total = sum + next;
+	        // Neumaier compensation retains small contributions even when larger values cancel.
+	        correction += Math.abs(sum) >= Math.abs(next) ? sum - total + next : next - total + sum;
+	        sum = total;
+	    }
+	    return ((sum + correction) / values.length) * scale;
+	}
+
+	/** 有放回重采样；回调不得修改或持有复用的只读样本缓冲区。 */
+	function bootstrapEstimate(values, estimator, options) {
+	    if (!values.length ||
+	        values.some(value => !Number.isFinite(value)) ||
+	        !Number.isInteger(options.resamples) ||
+	        options.resamples < 1 ||
+	        !Number.isInteger(options.seed) ||
+	        options.seed < 0 ||
+	        options.seed > 0xffffffff) {
+	        throw new RangeError('bootstrap requires finite observations, positive resamples and a uint32 seed');
+	    }
+	    const random = randomLCG(options.seed);
+	    const sample = new Array(values.length);
+	    const estimates = new Array(options.resamples);
+	    for (let b = 0; b < options.resamples; b++) {
+	        for (let i = 0; i < sample.length; i++) {
+	            sample[i] = values[Math.floor(random() * values.length)];
+	        }
+	        const estimate = estimator(sample);
+	        if (!Number.isFinite(estimate)) {
+	            throw new RangeError('bootstrap estimator must return a finite number');
+	        }
+	        estimates[b] = estimate;
+	    }
+	    return estimates;
+	}
+
+	/** 成对 percentile bootstrap；每次重采样仅拟合一次，固定原始坐标基底。 */
+	function regressionBootstrap(data, options) {
+	    var _a;
+	    const degree = options.method === 'linear' ? 1 : (_a = options.degree) !== null && _a !== void 0 ? _a : NaN;
+	    if ((options.method !== 'linear' && options.method !== 'polynomial') ||
+	        !Number.isInteger(degree) ||
+	        degree < 1 ||
+	        !data.length ||
+	        data.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y)) ||
+	        options.grid.some(x => !Number.isFinite(x)) ||
+	        !(options.level > 0 && options.level < 1) ||
+	        !Number.isInteger(options.resamples) ||
+	        options.resamples < 1 ||
+	        !Number.isInteger(options.seed) ||
+	        options.seed < 0 ||
+	        options.seed > 0xffffffff) {
+	        throw new RangeError('Invalid paired regression bootstrap inputs');
+	    }
+	    if (data.length <= degree + 1) {
+	        throw new RangeError('Regression bootstrap requires positive residual degrees of freedom');
+	    }
+	    const sorted = data.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+	    const basis = regressionBasis(sorted);
+	    if (fitRegression(sorted, degree, basis).rank < degree + 1) {
+	        throw new RangeError('Original regression design is rank deficient');
+	    }
+	    const random = randomLCG(options.seed);
+	    const sample = new Array(sorted.length);
+	    const values = options.grid.map(() => new Array(options.resamples));
+	    for (let b = 0; b < options.resamples; b++) {
+	        for (let i = 0; i < sample.length; i++) {
+	            sample[i] = sorted[Math.floor(random() * sorted.length)];
+	        }
+	        const model = fitRegression(sample, degree, basis);
+	        for (let j = 0; j < options.grid.length; j++) {
+	            const value = regressionPrediction(model, options.grid[j]);
+	            if (!Number.isFinite(value)) {
+	                throw new RangeError('Regression bootstrap prediction is not finite');
+	            }
+	            values[j][b] = value;
+	        }
+	    }
+	    const tail = (1 - options.level) / 2;
+	    return options.grid.map((x, j) => {
+	        values[j].sort((a, b) => a - b);
+	        return { x, lower: quantileSorted(values[j], tail), upper: quantileSorted(values[j], 1 - tail) };
+	    });
+	}
+
 	class HashValue {
 	}
+	// 基于 array 和 object的 HashTable
 	class HashTable {
 	    constructor() {
 	        this.items = {};
@@ -2744,6 +3664,10 @@
 	            this.resetIndex();
 	        }
 	    }
+	    /**
+	     * 不包含当前index
+	     * @param index
+	     */
 	    delFrom(index) {
 	        for (let i = index + 1; i < this.count(); i++) {
 	            const key = this.itemList[i].key;
@@ -2787,6 +3711,7 @@
 	    getKeyByIndex(index) {
 	        return this.itemList[index].key;
 	    }
+	    //遍历 扩展
 	    foreach(callback) {
 	        for (const key in this.items) {
 	            const returnVal = callback(key, this.items[key].value);
@@ -2813,12 +3738,14 @@
 	        }
 	        return false;
 	    }
+	    //获取index
 	    indexOf(key) {
 	        if (this.has(key)) {
 	            return this.items[key].index;
 	        }
 	        return -1;
 	    }
+	    //插入
 	    insertAt(index, value, key) {
 	        const hashV = new HashValue();
 	        hashV.index = index;
@@ -2851,6 +3778,7 @@
 	        return returnArr;
 	    }
 	    toImmutableMap() {
+	        // do nothing
 	    }
 	}
 
@@ -2877,6 +3805,15 @@
 	function asin(x) {
 	    return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
 	}
+	/**
+	 * 根据比例获直线上的点
+	 * @param {number} x1 起始点 x
+	 * @param {number} y1 起始点 y
+	 * @param {number} x2 结束点 x
+	 * @param {number} y2 结束点 y
+	 * @param {number} t 指定比例
+	 * @return {object} 包含 x, y 的点
+	 */
 	function pointAt(x1, y1, x2, y2, t) {
 	    let x = x2;
 	    let y = y2;
@@ -2892,6 +3829,7 @@
 	    };
 	}
 	function lengthFromPointToLine(point, point1, point2) {
+	    // 面积
 	    const dir1X = point2.x - point1.x;
 	    const dir1Y = point2.y - point1.y;
 	    const dir2X = point.x - point1.x;
@@ -2936,6 +3874,9 @@
 
 	class Point {
 	    constructor(x = 0, y = 0, x1, y1) {
+	        /**
+	         * 面积图的下点
+	         */
 	        this.x = 0;
 	        this.y = 0;
 	        this.x = x;
@@ -2988,6 +3929,7 @@
 	    }
 	}
 	class PointService {
+	    /* distance */
 	    static distancePP(p1, p2) {
 	        return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
 	    }
@@ -2997,6 +3939,7 @@
 	    static distancePN(point, x, y) {
 	        return sqrt(pow(x - point.x, 2) + pow(y - point.y, 2));
 	    }
+	    /* point at */
 	    static pointAtPP(p1, p2, t) {
 	        return new Point((p2.x - p1.x) * t + p1.x, (p2.y - p1.y) * t + p1.y);
 	    }
@@ -3045,12 +3988,30 @@
 	    return new ImageData(flipClampBuffer, width, height);
 	};
 
+	/**
+	 * 处理角度相关的数据计算
+	 */
+	/**
+	 * degree -> radian
+	 * @param degree
+	 * @returns radian
+	 */
 	function degreeToRadian(degree) {
 	    return degree * (Math.PI / 180);
 	}
+	/**
+	 * radian -> degree
+	 * @param radian
+	 * @returns
+	 */
 	function radianToDegree(radian) {
 	    return (radian * 180) / Math.PI;
 	}
+	/**
+	 * 对弧度进行格式化
+	 * @param a 传入的弧度
+	 * @returns
+	 */
 	const clampRadian = (angle = 0) => {
 	    if (angle < 0) {
 	        while (angle < -tau) {
@@ -3064,14 +4025,28 @@
 	    }
 	    return angle;
 	};
+	// alias of clampRadian
 	const clampAngleByRadian = clampRadian;
+	/**
+	 * 对角度进行格式化
+	 * @param a 角度
+	 * @returns
+	 */
 	const clampDegree = (a = 0) => {
 	    if (a > 360 || a < -360) {
 	        return a % 360;
 	    }
 	    return a;
 	};
+	// alias of clampDegree
 	const clampAngleByDegree = clampDegree;
+	/**
+	 * 根据弧度及半径计算极坐标系下的坐标点
+	 * @param centerX 圆心坐标
+	 * @param radius 半径
+	 * @param angleInRadian 弧度
+	 * @returns 返回笛卡尔坐标点
+	 */
 	function polarToCartesian(center, radius, angleInRadian) {
 	    if (!radius) {
 	        return { x: center.x, y: center.y };
@@ -3081,6 +4056,14 @@
 	        y: center.y + radius * Math.sin(angleInRadian)
 	    };
 	}
+	/**
+	 * 根据笛卡尔坐标系坐标计算极坐标坐标点
+	 * @param point
+	 * @param center 极坐标系中心点坐标
+	 * @param startAngle 极坐标系起始角度
+	 * @param endAngle 极坐标系结束角度
+	 * @returns 极坐标系坐标点
+	 */
 	function cartesianToPolar(point, center = { x: 0, y: 0 }, startAngle = 0, endAngle = 2 * Math.PI) {
 	    const { x, y } = point;
 	    const { x: centerX, y: centerY } = center;
@@ -3111,9 +4094,19 @@
 	        angle: radian
 	    };
 	}
+	/**
+	 * 根据点的笛卡尔坐标获取该点与圆心的连线同正 x 轴方向的夹角
+	 * @param center 圆心坐标
+	 * @param point 待求的点坐标
+	 * @returns 返回夹角对应的弧度值
+	 */
 	function getAngleByPoint(center, point) {
 	    return Math.atan2(point.y - center.y, point.x - center.x);
 	}
+	/**
+	 * 角度标准化处理
+	 * @param angle 弧度角
+	 */
 	function normalizeAngle(angle) {
 	    while (angle < 0) {
 	        angle += Math.PI * 2;
@@ -3123,6 +4116,14 @@
 	    }
 	    return angle;
 	}
+	/**
+	 * 指定开始角度和结束角度，计算这个范围内的边界角度，
+	 * 即起始角度以及经过的东、南、西、北四个方向的角度
+	 * 计算这个角度，可以用于计算一个弧度的bounding box 等
+	 * @param startAngle 起始角度的弧度值
+	 * @param endAngle    结束角度的弧度值
+	 * @returns 边界角度数组
+	 */
 	function findBoundaryAngles(startAngle, endAngle) {
 	    const deltaAngle = Math.abs(endAngle - startAngle);
 	    if (deltaAngle >= 2 * Math.PI || 2 * Math.PI - deltaAngle < 1e-6) {
@@ -3141,6 +4142,14 @@
 	    }
 	    return steps;
 	}
+	/**
+	 * 计算指定范围内，指定中心的情况下，不超出边界的最大可用半径
+	 * @param rect 矩形的大小
+	 * @param center 中心点
+	 * @param startAngle 起始角度的弧度值
+	 * @param endAngle 结束角度的弧度值
+	 * @returns 最大半径
+	 */
 	function calculateMaxRadius(rect, center, startAngle, endAngle) {
 	    const { x, y } = center;
 	    const steps = findBoundaryAngles(startAngle, endAngle);
@@ -3192,10 +4201,18 @@
 	    return 1;
 	}
 
+	/* 用于判断2d相交 */
 	function sub(out, v1, v2) {
 	    out[0] = v1[0] - v2[0];
 	    out[1] = v1[1] - v2[1];
 	}
+	/**
+	 * 判断直线是否相交，投影法
+	 * @param left1
+	 * @param right1
+	 * @param left2
+	 * @param right2
+	 */
 	function isIntersect(left1, right1, left2, right2) {
 	    let min1 = left1[0];
 	    let max1 = right1[0];
@@ -3222,6 +4239,15 @@
 	    }
 	    return true;
 	}
+	/**
+	 * 获取直线交点
+	 * 不相交返回false，共线返回true，相交返回交点
+	 * https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect/565282#565282
+	 * @param left1
+	 * @param right1
+	 * @param left2
+	 * @param right2
+	 */
 	function getIntersectPoint(left1, right1, left2, right2) {
 	    if (!isIntersect(left1, right1, left2, right2)) {
 	        return false;
@@ -3231,9 +4257,16 @@
 	    const tempVec = [0, 0];
 	    sub(dir1, right1, left1);
 	    sub(dir2, right2, left2);
+	    // 判断共线
 	    if (fuzzyEqualVec(dir1, dir2)) {
 	        return true;
 	    }
+	    // https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect/565282#565282
+	    // line1: left1 + dir1 * t
+	    // line2: left2 + dir2 * u
+	    // 当 left1 + dir1 * t = left2 + dir2 * u => (left1 + dir1 * t) x dir2 = (left2 + dir2 * u) x dir2
+	    // => dir1 x dir2 * t = (left2 - left1) x dir2 => t = (left2 - left1) x dir2 / (dir1 x dir2)
+	    // 直线不平行，dir1 x dir2 ≠ 0，当0 <= t <= 1时，可以求出交点
 	    sub(tempVec, left2, left1);
 	    const t = crossProduct(tempVec, dir2) / crossProduct(dir1, dir2);
 	    if (t >= 0 && t <= 1) {
@@ -3241,6 +4274,13 @@
 	    }
 	    return false;
 	}
+	/**
+	 * 获取两个rect的相交部分
+	 * 如果有bbox为null，返回null，如果不相交返回{x1: 0, y1: 0, x2: 0, y2: 0}
+	 * @param bbox1
+	 * @param bbox2
+	 * @param format
+	 */
 	function getRectIntersect(bbox1, bbox2, format) {
 	    if (bbox1 === null) {
 	        return bbox2;
@@ -3285,19 +4325,35 @@
 	    }
 	    return { x11, x12, y11, y12, x21, x22, y21, y22 };
 	};
+	/**
+	 * 矩形是否在另一个矩形内部
+	 * 返回InnerBBox
+	 * @param bbox1
+	 * @param bbox2
+	 * @param format
+	 */
 	function rectInsideAnotherRect(bbox1, bbox2, format) {
 	    if (!bbox1 || !bbox2) {
 	        return exports.InnerBBox.NONE;
 	    }
 	    const { x11, x12, y11, y12, x21, x22, y21, y22 } = formatTwoBBox(bbox1, bbox2, format);
+	    // bbox1在bbox2内部
 	    if (x11 > x21 && x12 < x22 && y11 > y21 && y12 < y22) {
 	        return exports.InnerBBox.BBOX1;
 	    }
+	    // bbox2在bbox1内部
 	    if (x21 > x11 && x22 < x12 && y21 > y11 && y22 < y12) {
 	        return exports.InnerBBox.BBOX2;
 	    }
 	    return exports.InnerBBox.NONE;
 	}
+	/**
+	 * 两个矩形是否相交
+	 * 如果有矩形为null，判断为相交
+	 * @param bbox1
+	 * @param bbox2
+	 * @param format
+	 */
 	function isRectIntersect(bbox1, bbox2, format) {
 	    if (bbox1 && bbox2) {
 	        if (!format) {
@@ -3314,6 +4370,12 @@
 	    }
 	    return true;
 	}
+	/**
+	 * 点在box内部
+	 * 如果bbox为null返回true
+	 * @param point
+	 * @param bbox
+	 */
 	function pointInRect(point, bbox, format) {
 	    if (!bbox) {
 	        return true;
@@ -3333,9 +4395,20 @@
 	    }
 	    return point.x >= x11 && point.x <= x12 && point.y >= y11 && point.y <= y12;
 	}
+	// 参考https://github.com/francecil/leetcode/issues/1
+	/**
+	 * 计算投影半径
+	 * @param {Array(Number)} checkAxis 检测轴 [cosθ,sinθ]
+	 * @param {Array} axis 目标轴 [x,y]
+	 */
 	function getProjectionRadius(checkAxis, axis) {
 	    return Math.abs(axis[0] * checkAxis[0] + axis[1] * checkAxis[1]);
 	}
+	/**
+	 * 逆时针旋转矩阵（从正 x 轴开始，旋转到正 y 轴的方向）
+	 * [ cos(θ)  -sin(θ) ]
+	 * [ sin(θ)  cos(θ) ]
+	 */
 	function rotatePoint({ x, y }, rad, origin = { x: 0, y: 0 }) {
 	    return {
 	        x: (x - origin.x) * Math.cos(rad) - (y - origin.y) * Math.sin(rad) + origin.x,
@@ -3348,6 +4421,10 @@
 	        y: (box.y1 + box.y2) / 2
 	    };
 	}
+	/**
+	 * 转化为顶点坐标数组
+	 * @param {Object} box
+	 */
 	function toRect(box, isDeg) {
 	    const deg = isDeg ? degreeToRadian(box.angle) : box.angle;
 	    const cp = getCenterPoint(box);
@@ -3376,15 +4453,21 @@
 	    const vector = (start, end) => {
 	        return [end.x - start.x, end.y - start.y];
 	    };
+	    // 两个矩形的中心点
 	    const p1 = getCenterPoint(box1);
 	    const p2 = getCenterPoint(box2);
+	    // 向量 p1p2
 	    const vp1p2 = vector(p1, p2);
+	    //矩形1的两边向量
 	    const AB = vector(rect1[0], rect1[1]);
 	    const BC = vector(rect1[1], rect1[2]);
+	    //矩形2的两边向量
 	    const A1B1 = vector(rect2[0], rect2[1]);
 	    const B1C1 = vector(rect2[1], rect2[2]);
+	    // 矩形1 的两个弧度
 	    const deg11 = isDeg ? degreeToRadian(box1.angle) : box1.angle;
 	    let deg12 = isDeg ? degreeToRadian(90 - box1.angle) : box1.angle + halfPi;
+	    // 矩形2 的两个弧度
 	    const deg21 = isDeg ? degreeToRadian(box2.angle) : box2.angle;
 	    let deg22 = isDeg ? degreeToRadian(90 - box2.angle) : box2.angle + halfPi;
 	    if (deg12 > pi2) {
@@ -3393,10 +4476,12 @@
 	    if (deg22 > pi2) {
 	        deg22 -= pi2;
 	    }
+	    // 投影重叠
 	    const isCover = (checkAxisRadius, deg, targetAxis1, targetAxis2) => {
 	        const checkAxis = [Math.cos(deg), Math.sin(deg)];
 	        const targetAxisRadius = (getProjectionRadius(checkAxis, targetAxis1) + getProjectionRadius(checkAxis, targetAxis2)) / 2;
 	        const centerPointRadius = getProjectionRadius(checkAxis, vp1p2);
+	        // console.log('abc', `checkAxis:${checkAxis},三个投影:${checkAxisRadius}, ${targetAxisRadius}, ${centerPointRadius}`)
 	        return checkAxisRadius + targetAxisRadius > centerPointRadius;
 	    };
 	    return (isCover((box1.x2 - box1.x1) / 2, deg11, A1B1, B1C1) &&
@@ -3411,6 +4496,7 @@
 	let y2;
 	function getAABBFromPoints(points) {
 	    (x1 = Infinity), (y1 = Infinity), (x2 = -Infinity), (y2 = -Infinity);
+	    // todo 有优化空间
 	    points.forEach(point => {
 	        if (x1 > point.x) {
 	            x1 = point.x;
@@ -3462,6 +4548,7 @@
 	            y22 = temp;
 	        }
 	    }
+	    // 不相交直接跳过
 	    if (x11 >= x22 || x12 <= x21 || y11 >= y22 || y12 <= y21) {
 	        return [bounds1, bounds2];
 	    }
@@ -3483,6 +4570,7 @@
 	        const l = [];
 	        list.forEach(b => {
 	            let arr;
+	            // 相交
 	            if ((arr = unionAABB(baseBound, b)).length > 1) {
 	                l.push(b);
 	                return;
@@ -3596,8 +4684,10 @@
 	        };
 	    }
 	    estimate({ text, fontSize }) {
-	        let eCharLen = 0;
-	        let cCharLen = 0;
+	        // 假设只有英文和中文字符
+	        let eCharLen = 0; // 英文字符
+	        let cCharLen = 0; // 中文字符
+	        // 判断ascii码，如果是
 	        for (let i = 0; i < text.length; i++) {
 	            text.charCodeAt(i) < 128 ? eCharLen++ : cCharLen++;
 	        }
@@ -3615,6 +4705,14 @@
 	}
 
 	const EPSILON = 1e-8;
+	// Adapted from https://github.com/apache/echarts/blob/master/src/util/graphic.ts by striezel
+	// License: https://github.com/apache/echarts/blob/master/LICENSE
+	/**
+	 * Return `true` if the given line (line `a`) and the given polygon
+	 * are intersect.
+	 * Note that we do not count colinear as intersect here because no
+	 * requirement for that. We could do that if required in future.
+	 */
 	function lineIntersectPolygon(a1x, a1y, a2x, a2y, points) {
 	    for (let i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
 	        const p = points[i];
@@ -3625,6 +4723,8 @@
 	    }
 	    return false;
 	}
+	// Adapted from https://github.com/ecomfe/zrender/blob/master/src/contain/polygon.ts by pissang
+	// License: https://github.com/ecomfe/zrender/blob/master/LICENSE
 	function polygonContainPoint(points, x, y) {
 	    let w = 0;
 	    let p = points[0];
@@ -3636,30 +4736,44 @@
 	        w += isPointInLine(p.x, p.y, p2.x, p2.y, x, y);
 	        p = p2;
 	    }
+	    // Close polygon
 	    const p0 = points[0];
 	    if (!isAroundEqual(p.x, p0.x) || !isAroundEqual(p.y, p0.y)) {
 	        w += isPointInLine(p.x, p.y, p0.x, p0.y, x, y);
 	    }
 	    return w !== 0;
 	}
+	// Adapted from https://github.com/ecomfe/zrender/blob/master/src/contain/windingLine.ts by pissang
+	// License: https://github.com/ecomfe/zrender/blob/master/LICENSE
 	function isPointInLine(x0, y0, x1, y1, x, y) {
 	    if ((y > y0 && y > y1) || (y < y0 && y < y1)) {
 	        return 0;
 	    }
+	    // Ignore horizontal line
 	    if (y1 === y0) {
 	        return 0;
 	    }
 	    const t = (y - y0) / (y1 - y0);
 	    let dir = y1 < y0 ? 1 : -1;
+	    // Avoid winding error when intersection point is the connect point of two line of polygon
 	    if (t === 1 || t === 0) {
 	        dir = y1 < y0 ? 0.5 : -0.5;
 	    }
 	    const x_ = t * (x1 - x0) + x0;
+	    // If (x, y) on the line, considered as "contain".
 	    return x_ === x ? Infinity : x_ > x ? dir : 0;
 	}
+	// Adapted from https://github.com/ecomfe/zrender/blob/master/src/contain/polygon.ts by pissang
+	// License: https://github.com/ecomfe/zrender/blob/master/LICENSE
 	function isAroundEqual(a, b) {
 	    return Math.abs(a - b) < EPSILON;
 	}
+	/**
+	 * polygon图元之间是否相交
+	 * @param pointsA 图元A的points
+	 * @param pointsB 图元B的points
+	 * @returns 是否相交
+	 */
 	function polygonIntersectPolygon(pointsA, pointsB) {
 	    for (let i = 0; i < pointsB.length; i++) {
 	        if (polygonContainPoint(pointsA, pointsB[i].x, pointsB[i].y)) {
@@ -3716,9 +4830,11 @@
 	    let width = 0;
 	    for (const character of string) {
 	        const codePoint = character.codePointAt(0);
+	        // Ignore control characters
 	        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) {
 	            continue;
 	        }
+	        // Ignore combining characters
 	        if (codePoint >= 0x300 && codePoint <= 0x36f) {
 	            continue;
 	        }
@@ -3745,6 +4861,7 @@
 	};
 	const ansiRegex = ({ onlyFirst = false } = {}) => {
 	    const pattern = [
+	        // eslint-disable-next-line max-len
 	        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
 	        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
 	    ].join('|');
@@ -4001,9 +5118,12 @@
 	    return 'N';
 	};
 	const emojiRegex = () => {
+	    // https://mths.be/emoji
+	    // eslint-disable-next-line max-len
 	    return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26F9(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC3\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC08\uDC26](?:\u200D\u2B1B)?|[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE88\uDE90-\uDEBD\uDEBF-\uDEC2\uDECE-\uDEDB\uDEE0-\uDEE8]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF-\uDDB3\uDDBC\uDDBD]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
 	};
 
+	// FIXME: from VRender
 	function getContextFont(text, defaultAttr = {}, fontSizeScale) {
 	    if (!fontSizeScale) {
 	        fontSizeScale = 1;
@@ -4020,16 +5140,25 @@
 
 	class TextMeasure {
 	    constructor(option, textSpec) {
+	        /** 数字大小缓存 */
 	        this._numberCharSize = null;
+	        /** 全角字符大小缓存 */
 	        this._fullCharSize = null;
+	        /** 字母大小缓存 */
 	        this._letterCharSize = null;
+	        /** 特殊字符缓存 */
 	        this._specialCharSizeMap = {};
+	        /** 内置测量 canvas */
 	        this._canvas = null;
 	        this._context = null;
 	        this._contextSaved = false;
+	        /** 是否不支持 canvas */
 	        this._notSupportCanvas = false;
+	        /** 是否不支持 vrender */
 	        this._notSupportVRender = false;
+	        /** 文字 spec */
 	        this._userSpec = {};
+	        /** 特殊字符集 */
 	        this.specialCharSet = '-/: .,@%\'"~';
 	        this._option = option;
 	        this._userSpec = textSpec !== null && textSpec !== void 0 ? textSpec : {};
@@ -4041,6 +5170,7 @@
 	            ? this.fullMeasure.bind(this)
 	            : this.measureWithNaiveCanvas.bind(this);
 	    }
+	    /** 初始化测量相关上下文 */
 	    initContext() {
 	        if (this._notSupportCanvas) {
 	            return false;
@@ -4054,6 +5184,7 @@
 	                typeof window.document !== 'undefined' &&
 	                globalThis &&
 	                isValid(globalThis.document)) {
+	                // 默认创建方法
 	                this._canvas = globalThis.document.createElement('canvas');
 	            }
 	        }
@@ -4094,6 +5225,7 @@
 	            lineHeight
 	        };
 	    }
+	    /** 计算文本宽高 */
 	    measure(text, method) {
 	        switch (method) {
 	            case 'vrender':
@@ -4108,12 +5240,13 @@
 	                return this.quickMeasure(text);
 	        }
 	    }
+	    /** 精确计算文本宽高 */
 	    fullMeasure(text) {
 	        if (isNil(text)) {
 	            return { width: 0, height: 0 };
 	        }
 	        if (isNil(this._option.getTextBounds) || !this._notSupportVRender) {
-	            return this.measureWithNaiveCanvas(text);
+	            return this.measureWithNaiveCanvas(text); // 降级
 	        }
 	        const { fontFamily, fontSize, fontWeight, textAlign, textBaseline, ellipsis, limit, lineHeight } = this.textSpec;
 	        let size;
@@ -4133,17 +5266,18 @@
 	        }
 	        catch (e) {
 	            this._notSupportVRender = true;
-	            size = this.measureWithNaiveCanvas(text);
+	            size = this.measureWithNaiveCanvas(text); // 降级
 	        }
 	        return size;
 	    }
+	    /** 通过原生 canvas 精确计算文本宽度，高度为估算 */
 	    measureWithNaiveCanvas(text) {
 	        return this._measureReduce(text, this._measureWithNaiveCanvas.bind(this));
 	    }
 	    _measureWithNaiveCanvas(text) {
 	        var _a;
 	        if (!this.initContext()) {
-	            return this._quickMeasureWithoutCanvas(text);
+	            return this._quickMeasureWithoutCanvas(text); // 降级
 	        }
 	        const metrics = this._context.measureText(text);
 	        const { fontSize, lineHeight } = this.textSpec;
@@ -4154,6 +5288,7 @@
 	            fontBoundingBoxDescent: metrics.fontBoundingBoxDescent
 	        };
 	    }
+	    /** 快速估算文本宽高 */
 	    quickMeasure(text) {
 	        return this._measureReduce(text, this._quickMeasure.bind(this));
 	    }
@@ -4164,13 +5299,17 @@
 	        };
 	        for (let i = 0; i < text.length; i++) {
 	            const char = text[i];
+	            // 先判断是否特殊字符
 	            let size = this._measureSpecialChar(char);
+	            // 再判断是否数字
 	            if (isNil(size) && TextMeasure.NUMBERS_CHAR_SET.includes(char)) {
 	                size = this._measureNumberChar();
 	            }
+	            // 再判断全角字符
 	            if (isNil(size) && ['F', 'W'].includes(eastAsianCharacterInfo(char))) {
 	                size = this._measureFullSizeChar();
 	            }
+	            // 最后按半角字符处理
 	            if (isNil(size)) {
 	                size = this._measureLetterChar();
 	            }
@@ -4181,6 +5320,7 @@
 	        }
 	        return totalSize;
 	    }
+	    /** 不使用 canvas 来快速估算文本宽高 */
 	    quickMeasureWithoutCanvas(text) {
 	        return this._measureReduce(text, this._quickMeasureWithoutCanvas.bind(this));
 	    }
@@ -4193,6 +5333,7 @@
 	        const { fontSize, lineHeight } = this.textSpec;
 	        for (let i = 0; i < text.length; i++) {
 	            const char = text[i];
+	            // 判断全角字符
 	            const size = ['F', 'W'].includes(eastAsianCharacterInfo(char)) ? 1 : 0.53;
 	            totalSize.width += size * fontSize;
 	        }
@@ -4216,11 +5357,12 @@
 	            }
 	            return {
 	                width: textArr.reduce((maxWidth, cur) => Math.max(maxWidth, processor(cur).width), 0),
-	                height: textArr.length * (((_a = lineHeight) !== null && _a !== void 0 ? _a : fontSize) + 1) + 1
+	                height: textArr.length * (((_a = lineHeight) !== null && _a !== void 0 ? _a : fontSize) + 1) + 1 // 经验值
 	            };
 	        }
 	        return processor(text.toString());
 	    }
+	    /** 测量一个数字 */
 	    _measureNumberChar() {
 	        if (isNil(this._numberCharSize)) {
 	            const numberBounds = this._standardMethod(TextMeasure.NUMBERS_CHAR_SET);
@@ -4233,12 +5375,14 @@
 	        }
 	        return this._numberCharSize;
 	    }
+	    /** 测量一个全角字符 */
 	    _measureFullSizeChar() {
 	        if (isNil(this._fullCharSize)) {
 	            this._fullCharSize = this._standardMethod(TextMeasure.FULL_SIZE_CHAR);
 	        }
 	        return this._fullCharSize;
 	    }
+	    /** 测量一个英文字符 */
 	    _measureLetterChar() {
 	        if (isNil(this._letterCharSize)) {
 	            const alphabetBounds = this._standardMethod(TextMeasure.ALPHABET_CHAR_SET);
@@ -4251,6 +5395,7 @@
 	        }
 	        return this._letterCharSize;
 	    }
+	    /** 测量一个特殊字符 */
 	    _measureSpecialChar(char) {
 	        if (isValid(this._specialCharSizeMap[char])) {
 	            return this._specialCharSizeMap[char];
@@ -4274,8 +5419,11 @@
 	        }
 	    }
 	}
+	/** 英文字母集 */
 	TextMeasure.ALPHABET_CHAR_SET = 'abcdefghijklmnopqrstuvwxyz';
+	/** 数字集 */
 	TextMeasure.NUMBERS_CHAR_SET = '0123456789';
+	/** 全角字符 */
 	TextMeasure.FULL_SIZE_CHAR = '字';
 
 	const calculateAnchorOfBounds = (bounds, anchorType) => {
@@ -4331,26 +5479,28 @@
 	        { x: Math.cos(a.angle), y: Math.sin(a.angle) },
 	        { x: -Math.sin(a.angle), y: Math.cos(a.angle) },
 	        { x: Math.cos(b.angle), y: Math.sin(a.angle) },
-	        { x: -Math.sin(b.angle), y: Math.cos(a.angle) }
+	        { x: -Math.sin(b.angle), y: Math.cos(a.angle) } // Rect B's second axis
 	    ];
+	    // calculate the projection range of a rectangle on a given axis
 	    function getProjectionRange(obb, axisX, axisY) {
 	        const corners = obb.getRotatedCorners();
 	        const projections = corners.map(p => p.x * axisX + p.y * axisY);
 	        return { min: Math.min(...projections), max: Math.max(...projections) };
 	    }
+	    // Calculate distances for all axes
 	    let maxDistance = 0;
 	    for (const axis of axes) {
 	        const rangeA = getProjectionRange(a, axis.x, axis.y);
 	        const rangeB = getProjectionRange(b, axis.x, axis.y);
 	        let distance;
 	        if (rangeA.max < rangeB.min) {
-	            distance = rangeB.min - rangeA.max;
+	            distance = rangeB.min - rangeA.max; // B is to the right of A
 	        }
 	        else if (rangeB.max < rangeA.min) {
-	            distance = rangeA.min - rangeB.max;
+	            distance = rangeA.min - rangeB.max; // A is to the right of B
 	        }
 	        else {
-	            distance = 0;
+	            distance = 0; // Overlapping
 	        }
 	        maxDistance = Math.max(maxDistance, distance);
 	    }
@@ -4359,6 +5509,7 @@
 
 	function transformBoundsWithMatrix(out, bounds, matrix) {
 	    const { x1, y1, x2, y2 } = bounds;
+	    // 如果没有旋转和缩放，那就直接translate
 	    if (matrix.onlyTranslate()) {
 	        if (out !== bounds) {
 	            out.setValue(bounds.x1, bounds.y1, bounds.x2, bounds.y2);
@@ -4373,6 +5524,16 @@
 	    out.add(matrix.a * x1 + matrix.c * y2 + matrix.e, matrix.b * x1 + matrix.d * y2 + matrix.f);
 	    return bounds;
 	}
+	/**
+	 * 依据graphic的属性对bounds进行变换
+	 * @param bounds
+	 * @param x
+	 * @param y
+	 * @param scaleX
+	 * @param scaleY
+	 * @param angle
+	 * @param rotateCenter
+	 */
 	function transformBounds(bounds, x, y, scaleX, scaleY, angle, rotateCenter) {
 	    if (abs(scaleX) <= epsilon || abs(scaleY) <= epsilon) {
 	        return;
@@ -4390,6 +5551,37 @@
 	    }
 	    bounds.translate(x, y);
 	}
+	/**
+	Copyright (c) 2015-2021, University of Washington Interactive Data Lab
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	1. Redistributions of source code must retain the above copyright notice, this
+	   list of conditions and the following disclaimer.
+
+	2. Redistributions in binary form must reproduce the above copyright notice,
+	   this list of conditions and the following disclaimer in the documentation
+	   and/or other materials provided with the distribution.
+
+	3. Neither the name of the copyright holder nor the names of its contributors
+	  may be used to endorse or promote products derived from this software
+	  without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 */
+	// 基于Vega的Bounds重构
+	// https://github.com/vega/vega/blob/825bfaba6ccfe3306183df22b8c955a07bb30714/packages/vega-scenegraph/src/Bounds.js
 	class Bounds {
 	    constructor(bounds) {
 	        if (bounds) {
@@ -4496,6 +5688,11 @@
 	        const p = this.scalePoints(sx, sy, x, y);
 	        return this.clear().add(p[0], p[1]).add(p[2], p[3]);
 	    }
+	    /**
+	     * 并集
+	     * @param b
+	     * @returns
+	     */
 	    union(b) {
 	        if (b.x1 < this.x1) {
 	            this.x1 = b.x1;
@@ -4511,6 +5708,11 @@
 	        }
 	        return this;
 	    }
+	    /**
+	     * 交集
+	     * @param b
+	     * @returns
+	     */
 	    intersect(b) {
 	        if (b.x1 > this.x1) {
 	            this.x1 = b.x1;
@@ -4526,15 +5728,36 @@
 	        }
 	        return this;
 	    }
+	    /**
+	     * 是否包含b
+	     * @param b
+	     * @returns
+	     */
 	    encloses(b) {
 	        return b && this.x1 <= b.x1 && this.x2 >= b.x2 && this.y1 <= b.y1 && this.y2 >= b.y2;
 	    }
+	    /**
+	     * 是否共边
+	     * @param b
+	     * @returns
+	     */
 	    alignsWith(b) {
 	        return b && (this.x1 === b.x1 || this.x2 === b.x2 || this.y1 === b.y1 || this.y2 === b.y2);
 	    }
+	    /**
+	     * 是否相交
+	     * @param b
+	     * @returns
+	     */
 	    intersects(b) {
 	        return b && !(this.x2 < b.x1 || this.x1 > b.x2 || this.y2 < b.y1 || this.y1 > b.y2);
 	    }
+	    /**
+	     * 是否包含
+	     * @param x
+	     * @param y
+	     * @returns
+	     */
 	    contains(x = 0, y = 0) {
 	        return !(x < this.x1 || x > this.x2 || y < this.y1 || y > this.y2);
 	    }
@@ -4640,6 +5863,7 @@
 	        this.f = f;
 	    }
 	    equalToMatrix(m2) {
+	        // ef -> ad -> bc
 	        return !(this.e !== m2.e ||
 	            this.f !== m2.f ||
 	            this.a !== m2.a ||
@@ -4648,6 +5872,7 @@
 	            this.c !== m2.c);
 	    }
 	    equalTo(a, b, c, d, e, f) {
+	        // ef -> ad -> bc
 	        return !(this.e !== e || this.f !== f || this.a !== a || this.d !== d || this.b !== b || this.c !== c);
 	    }
 	    setValue(a, b, c, d, e, f) {
@@ -4668,6 +5893,9 @@
 	        this.f = 0;
 	        return this;
 	    }
+	    /**
+	     * 获取当前矩阵的逆矩阵
+	     */
 	    getInverse() {
 	        const a = this.a;
 	        const b = this.b;
@@ -4699,6 +5927,17 @@
 	        return this;
 	    }
 	    rotateByCenter(rad, cx, cy) {
+	        /** rotate matrix
+	         * | cos -sin (1-cos)*cx+sin*cy |
+	         * | sin cos  (1-cos)*cy-sin*cx |
+	         * | 0   0    1                 |
+	         * after multiply
+	         *   m13 = (1-cos)*cx+sin*cy;
+	         *   m23 = (1-cos)*cy-sin*cx;
+	         * | cos*a-sin*b cos*c-sin*d cos*e-sin*f+m13 |
+	         * | sin*a+cos*b sin*c+cos*d sin*e+cos*f+m23 |
+	         * | 0           0           1               |
+	         */
 	        const cos = Math.cos(rad);
 	        const sin = Math.sin(rad);
 	        const rotateM13 = (1 - cos) * cx + sin * cy;
@@ -4741,6 +5980,15 @@
 	        return this;
 	    }
 	    transpose() {
+	        /** transpose matrix
+	         * | 0 1 0 |
+	         * | 1 0 0 |
+	         * | 0 0 1 |
+	         * after multiply
+	         * | b d f |
+	         * | a c e |
+	         * | 0 0 1 |
+	         */
 	        const { a, b, c, d, e, f } = this;
 	        this.a = b;
 	        this.b = a;
@@ -4750,6 +5998,10 @@
 	        this.f = e;
 	        return this;
 	    }
+	    /**
+	     * 矩阵相乘
+	     * @param matrix
+	     */
 	    multiply(a2, b2, c2, d2, e2, f2) {
 	        const a1 = this.a;
 	        const b1 = this.b;
@@ -4771,6 +6023,11 @@
 	        this.f = dy;
 	        return this;
 	    }
+	    /**
+	     * 插值计算
+	     * @param m2
+	     * @param t
+	     */
 	    interpolate(m2, t) {
 	        const m = new Matrix();
 	        m.a = this.a + (m2.a - this.a) * t;
@@ -4781,6 +6038,11 @@
 	        m.f = this.f + (m2.f - this.f) * t;
 	        return m;
 	    }
+	    /**
+	     * 将point转到当前矩阵的坐标空间中
+	     * @param source
+	     * @param target
+	     */
 	    transformPoint(source, target) {
 	        const { a, b, c, d, e, f } = this;
 	        const dt = a * d - b * c;
@@ -4794,6 +6056,7 @@
 	        target.x = x * nextA + y * nextC + nextE;
 	        target.y = x * nextB + y * nextD + nextF;
 	    }
+	    // 只有translate
 	    onlyTranslate(scale = 1) {
 	        return this.a === scale && this.b === 0 && this.c === 0 && this.d === scale;
 	    }
@@ -4817,6 +6080,7 @@
 	            skewX: 0,
 	            skewY: 0
 	        };
+	        // Apply the QR-like decomposition.
 	        if (a !== 0 || b !== 0) {
 	            const r = Math.sqrt(a * a + b * b);
 	            result.rotateDeg = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);
@@ -4838,6 +6102,17 @@
 	        return result;
 	    }
 	}
+	/**
+	 * 对matrix进行通常的变换（基于rotateCenter进行旋转的同时进行translate和scale）
+	 * @param out
+	 * @param origin
+	 * @param x
+	 * @param y
+	 * @param scaleX
+	 * @param scaleY
+	 * @param angle
+	 * @param rotateCenter
+	 */
 	function normalTransform(out, origin, x, y, scaleX, scaleY, angle, rotateCenter) {
 	    const oa = origin.a;
 	    const ob = origin.b;
@@ -4871,18 +6146,20 @@
 	    out.f = of + ob * rotateCenterX + od * rotateCenterY - b1 * offsetX - d1 * offsetY;
 	}
 
+	// LRU清除
 	class LRU {
 	    constructor() {
 	        this.CLEAN_THRESHOLD = 1e3;
-	        this.L_TIME = 1000;
-	        this.R_COUNT = 1;
-	        this.R_TIMESTAMP_MAX_SIZE = 20;
+	        this.L_TIME = 1000; // 1000ms以内
+	        this.R_COUNT = 1; // 使用次数为0
+	        this.R_TIMESTAMP_MAX_SIZE = 20; // timestamp最大长度
 	    }
 	    clearCache(cache, params) {
 	        const { CLEAN_THRESHOLD = this.CLEAN_THRESHOLD, L_TIME = this.L_TIME, R_COUNT = this.R_COUNT } = params;
 	        if (cache.size < CLEAN_THRESHOLD) {
 	            return 0;
 	        }
+	        // 开始清理，清理最近1000ms内使用次数为0的缓存
 	        let clearNum = 0;
 	        const clear = (key) => {
 	            clearNum++;
@@ -4892,7 +6169,7 @@
 	        cache.forEach((item, key) => {
 	            if (item.timestamp.length < R_COUNT) {
 	                return clear(key);
-	            }
+	            } // 最近使用次数小于R_COUNT，清除
 	            let useCount = 0;
 	            while (now - item.timestamp[item.timestamp.length - 1 - useCount] < L_TIME) {
 	                useCount++;
@@ -4902,7 +6179,8 @@
 	            }
 	            if (useCount < R_COUNT) {
 	                return clear(key);
-	            }
+	            } // 最近L_TIME以内使用次数小于R_COUNT，清除
+	            // 清除L_TIME以外的key，避免数组过长
 	            while (now - item.timestamp[0] > L_TIME) {
 	                item.timestamp.shift();
 	            }
@@ -4913,6 +6191,7 @@
 	    addLimitedTimestamp(cacheItem, t, params) {
 	        const { R_TIMESTAMP_MAX_SIZE = this.R_TIMESTAMP_MAX_SIZE } = params;
 	        if (cacheItem.timestamp.length > R_TIMESTAMP_MAX_SIZE) {
+	            // cacheItem.timestamp[cacheItem.timestamp.length-1] =
 	            cacheItem.timestamp.shift();
 	        }
 	        cacheItem.timestamp.push(t);
@@ -4984,6 +6263,7 @@
 	    r /= 255;
 	    g /= 255;
 	    b /= 255;
+	    // Find greatest and smallest channel values
 	    const cMin = Math.min(r, g, b);
 	    const cMax = Math.max(r, g, b);
 	    const delta = cMax - cMin;
@@ -4993,12 +6273,15 @@
 	    if (delta === 0) {
 	        h = 0;
 	    }
+	    // Red is max
 	    else if (cMax === r) {
 	        h = ((g - b) / delta) % 6;
 	    }
+	    // Green is max
 	    else if (cMax === g) {
 	        h = (b - r) / delta + 2;
 	    }
+	    // Blue is max
 	    else {
 	        h = (r - g) / delta + 4;
 	    }
@@ -5007,7 +6290,9 @@
 	        h += 360;
 	    }
 	    l = (cMax + cMin) / 2;
+	    // Calculate saturation
 	    s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+	    // Multiply l and s by 100
 	    s = +(s * 100).toFixed(1);
 	    l = +(l * 100).toFixed(1);
 	    return {
@@ -5017,6 +6302,34 @@
 	    };
 	}
 
+	/*
+	Copyright (c) 2013, Jason Davies.
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	  * Redistributions of source code must retain the above copyright notice, this
+	    list of conditions and the following disclaimer.
+
+	  * Redistributions in binary form must reproduce the above copyright notice,
+	    this list of conditions and the following disclaimer in the documentation
+	    and/or other materials provided with the distribution.
+
+	  * The name Jason Davies may not be used to endorse or promote products
+	    derived from this software without specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+	DISCLAIMED. IN NO EVENT SHALL JASON DAVIES BE LIABLE FOR ANY DIRECT, INDIRECT,
+	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+	OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+	ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	*/
 	const REG_HEX = /^#([0-9a-f]{3,8})$/;
 	const DEFAULT_COLORS_OPACITY = {
 	    transparent: 0xffffff00
@@ -5182,6 +6495,7 @@
 	    else if (isArray(value)) {
 	        return new RGB(value[0], value[1], value[2]);
 	    }
+	    // default return
 	    return new RGB(255, 255, 255);
 	}
 	function rgba(value) {
@@ -5191,6 +6505,7 @@
 	    else if (isArray(value)) {
 	        return new RGB(value[0], value[1], value[2], value[3]);
 	    }
+	    // default return
 	    return new RGB(255, 255, 255, 1);
 	}
 	function SRGBToLinear(c) {
@@ -5204,12 +6519,15 @@
 	    if (forceHex || isHex) {
 	        const hex = parseInt(isHex[1], 16);
 	        const hexLength = isHex[1].length;
+	        // #fff
 	        if (hexLength === 3) {
 	            return new RGB(((hex >> 8) & 0xf) + (((hex >> 8) & 0xf) << 4), ((hex >> 4) & 0xf) + (((hex >> 4) & 0xf) << 4), (hex & 0xf) + ((hex & 0xf) << 4), 1);
 	        }
+	        // #ffffff
 	        if (hexLength === 6) {
 	            return rgb(hex);
 	        }
+	        // #ffffffaa
 	        else if (hexLength === 8) {
 	            return new RGB((hex >> 24) & 0xff, (hex >> 16) & 0xff, (hex >> 8) & 0xff, (hex & 0xff) / 0xff);
 	        }
@@ -5250,21 +6568,26 @@
 	        }
 	    }
 	    static parseColorString(value) {
+	        // case0: transparent
 	        if (isValid(DEFAULT_COLORS_OPACITY[value])) {
 	            return rgba(DEFAULT_COLORS_OPACITY[value]);
 	        }
+	        // case1: 简写 ['blue','red']
 	        if (isValid(DEFAULT_COLORS[value])) {
 	            return rgb(DEFAULT_COLORS[value]);
 	        }
 	        const formatValue = `${value}`.trim().toLowerCase();
+	        // case2: 16进制
 	        const hexRes = setHex(formatValue);
 	        if (hexRes !== undefined) {
 	            return hexRes;
 	        }
+	        // case3 : rgb
 	        if (/^(rgb|RGB|rgba|RGBA)/.test(formatValue)) {
 	            const aColor = formatValue.replace(/(?:\(|\)|rgba|RGBA|rgb|RGB)*/g, '').split(',');
 	            return new RGB(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10), parseFloat(aColor[3]));
 	        }
+	        // case4: hsl
 	        if (/^(hsl|HSL|hsla|HSLA)/.test(formatValue)) {
 	            const aColor = formatValue.replace(/(?:\(|\)|hsla|HSLA|hsl|HSL)*/g, '').split(',');
 	            const rgb = hslToRgb(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10));
@@ -5274,10 +6597,12 @@
 	    }
 	    constructor(value) {
 	        const color = Color.parseColorString(value);
+	        // case0: transparent
 	        if (color) {
 	            this.color = color;
 	        }
 	        else {
+	            // default: 白色
 	            console.warn(`Warn: 传入${value}无法解析为Color`);
 	            this.color = new RGB(255, 255, 255);
 	        }
@@ -5321,6 +6646,7 @@
 	        this.color.b = Math.max(0, Math.min(255, Math.floor(b * color.color.b)));
 	        return this;
 	    }
+	    // todo: 这里亮度计算都没考虑alpha通道
 	    getHSVBrightness() {
 	        return Math.max(this.color.r, this.color.g, this.color.b) / 255;
 	    }
@@ -5348,11 +6674,14 @@
 	        return res !== null && res !== void 0 ? res : this;
 	    }
 	    setColorName(name) {
+	        // color keywords
 	        const hex = DEFAULT_COLORS[name.toLowerCase()];
 	        if (typeof hex !== 'undefined') {
+	            // red
 	            this.setHex(hex);
 	        }
 	        else {
+	            // unknown color
 	            console.warn('THREE.Color: Unknown color ' + name);
 	        }
 	        return this;
@@ -5376,6 +6705,9 @@
 	    getLuminance3() {
 	        return (0.299 * this.color.r + 0.587 * this.color.g + 0.114 * this.color.b) / 255;
 	    }
+	    /**
+	     * https://www.w3.org/TR/WCAG21/#use-of-color
+	     */
 	    getLuminanceWCAG() {
 	        const RsRGB = this.color.r / 255;
 	        const GsRGB = this.color.g / 255;
@@ -5461,6 +6793,7 @@
 	            this.opacity = 1;
 	        }
 	    }
+	    // 转为16进制
 	    formatHex() {
 	        return `#${hex(this.r) + hex(this.g) + hex(this.b) + (this.opacity === 1 ? '' : hex(this.opacity * 255))}`;
 	    }
@@ -5473,11 +6806,17 @@
 	        const { h, s, l } = rgbToHsl(this.r, this.g, this.b);
 	        return `${opacity === 1 ? 'hsl(' : 'hsla('}${h},${s}%,${l}%${opacity === 1 ? ')' : `,${opacity})`}`;
 	    }
+	    // 转为16进制
 	    toString() {
 	        return this.formatHex();
 	    }
 	}
 
+	/**
+	 * 将 hex 格式颜色转换为 rgb 格式
+	 * @param str hex 格式的颜色值
+	 * @returns rgb 格式
+	 */
 	function hexToRgb(str) {
 	    let r = '';
 	    let g = '';
@@ -5539,6 +6878,11 @@
 		rgbToHsl: rgbToHsl
 	});
 
+	/**
+	 * 将 padding 转换为通用的格式（[上，右，下，左]）
+	 * @param padding
+	 * @return [ top, right, bottom, left ]
+	 */
 	function normalizePadding(padding) {
 	    if (isValidNumber(padding)) {
 	        return [padding, padding, padding, padding];
@@ -5610,6 +6954,12 @@
 	function millisecondsSetterName(isUTC) {
 	    return isUTC ? 'setUTCMilliseconds' : 'setMilliseconds';
 	}
+	/**
+	 * 根据时间推断格式化字符串
+	 * @param value
+	 * @param isUTC
+	 * @returns
+	 */
 	function getFormatFromValue(value, isUTC) {
 	    const date = toDate(value);
 	    const M = date[monthGetterName(isUTC)]() + 1;
@@ -5657,15 +7007,20 @@
 	        const m = date[minutesGetterName(isUTC)]();
 	        const s = date[secondsGetterName(isUTC)]();
 	        const S = date[millisecondsGetterName(isUTC)]();
+	        // 月份，周等需要管理管理locale的时间格式化暂时不支持
 	        return ((template || '')
 	            .replace(/YYYY/g, pad(y + '', 4, '0', 'left'))
 	            .replace(/yyyy/g, y + '')
 	            .replace(/yy/g, (y % 100) + '')
 	            .replace(/Q/g, q + '')
+	            // .replace(/{MMMM}/g, month[M - 1])
+	            // .replace(/{MMM}/g, monthAbbr[M - 1])
 	            .replace(/MM/g, pad(M, 2, '0', 'left'))
 	            .replace(/M/g, M + '')
 	            .replace(/dd/g, pad(d, 2, '0', 'left'))
 	            .replace(/d/g, d + '')
+	            // .replace(/{eeee}/g, dayOfWeek[e])
+	            // .replace(/{ee}/g, dayOfWeekAbbr[e])
 	            .replace(/e/g, e + '')
 	            .replace(/HH/g, pad(H, 2, '0', 'left'))
 	            .replace(/H/g, H + '')
@@ -5967,9 +7322,14 @@
 	        };
 	    }
 	    const style = getComputedStyle(el);
+	    // clientWidth/clientHeight: 默认整数，会向上取整，导致canvas > container
+	    // getBoundingClientRect：默认小数，但是在container上有css类似 transform: scale(0.5)时，获取结果不对
+	    // getComputedStyle：默认小数，获取最终结果，但是会包含padding；
 	    if (/^(\d*\.?\d+)(px)$/.exec(style.width)) {
+	        // 当dom元素的 display: 'none' 的时候，获取到的宽高会变成原始的样式配置，而不是计算后的像素值
 	        const computedWidth = parseFloat(style.width) - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight) || el.clientWidth - 1;
 	        const computedHeight = parseFloat(style.height) - parseFloat(style.paddingTop) - parseFloat(style.paddingBottom) || el.clientHeight - 1;
+	        // 理论上不用向下取整，目前没加。
 	        return {
 	            width: computedWidth <= 0 ? defaultWidth : computedWidth,
 	            height: computedHeight <= 0 ? defaultHeight : computedHeight
@@ -5977,10 +7337,20 @@
 	    }
 	    return { width: defaultWidth, height: defaultHeight };
 	}
+	/**
+	 * 获取元素的绝对位置坐标（相对于页面左上角）
+	 * @param element
+	 * @returns
+	 */
 	function getElementAbsolutePosition(element) {
 	    const { x, y } = element.getBoundingClientRect();
 	    return { x, y };
 	}
+	/**
+	 * 获取元素的相对位置坐标（相对于其他dom元素）
+	 * @param element
+	 * @returns
+	 */
 	function getElementRelativePosition(element, base) {
 	    const posElement = getElementAbsolutePosition(element);
 	    const posBase = getElementAbsolutePosition(base);
@@ -6012,12 +7382,23 @@
 	const getScaleY = (element) => {
 	    return element.getBoundingClientRect().height / element.offsetHeight;
 	};
+	/**
+	 * 获取目标元素的缩放因数
+	 * @param element 目标 dom 元素
+	 * @returns
+	 */
 	const getScale = (element) => {
 	    if (element.offsetWidth > 0) {
 	        return getScaleX(element);
 	    }
 	    return getScaleY(element);
 	};
+	/**
+	 * 判断是否是元素的父元素
+	 * @param element 从其父元素开始查找的 DOM 元素
+	 * @param target 要查找的目标父元素
+	 * @returns boolean, true 代表查找到，false 表示未找到
+	 */
 	function hasParentElement(element, target) {
 	    let parent = element.parentNode;
 	    while (parent !== null) {
@@ -6028,6 +7409,11 @@
 	    }
 	    return false;
 	}
+	/**
+	 * 将style字符串转换成对象形式
+	 * @param style字符串 例如："color:red;line-height:20px;"
+	 * @returns style对象，如 { color: 'red', 'line-height': '20px' }
+	 */
 	const styleStringToObject = (styleStr = '') => {
 	    const res = {};
 	    styleStr.split(';').forEach(item => {
@@ -6044,9 +7430,19 @@
 	    });
 	    return res;
 	};
+	/**
+	 * 将小驼峰转换成中划线连接的字符串
+	 * @param str 如：'lineHeight'  => 'line-height'
+	 * @returns
+	 */
 	const lowerCamelCaseToMiddle = (str) => {
 	    return str.replace(/([A-Z])/g, '-$1').toLowerCase();
 	};
+	/**
+	 * 将中划线连接的字符串转换成驼峰字符串
+	 * @param str 如：'line-height'  => 'lineHeight'
+	 * @returns
+	 */
 	function toCamelCase(str) {
 	    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 	}
@@ -6055,6 +7451,7 @@
 	        return obj instanceof Element;
 	    }
 	    catch (_a) {
+	        // 跨端 plan B
 	        const htmlElementKeys = [
 	            'children',
 	            'innerHTML',
@@ -6122,6 +7519,29 @@
 	  return distance / factor;
 	}
 
+	/**
+	 * The MIT License (MIT)
+	 *
+	 * Copyright (c) 2019 Morgan Herlocker
+	 *
+	 * Permission is hereby granted, free of charge, to any person obtaining a copy of
+	 * this software and associated documentation files (the "Software"), to deal in
+	 * the Software without restriction, including without limitation the rights to
+	 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+	 * the Software, and to permit persons to whom the Software is furnished to do so,
+	 * subject to the following conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+	 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+	 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+	 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+	 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+	 *
+	 */
+	// https://github.com/Turfjs/turf
 	function getGeom(geojson) {
 	    if (geojson.type === 'Feature') {
 	        return geojson.geometry;
@@ -6137,6 +7557,7 @@
 	    }
 	    const geom = getGeom(polygon);
 	    const type = geom.type;
+	    //  BBox [west, south, east, north]
 	    const bbox = polygon.bbox;
 	    let polys = geom.coordinates;
 	    if (bbox && pointInRect(point, { x1: bbox[0], x2: bbox[1], y1: bbox[1], y2: bbox[3] }, true) === true) {
@@ -6157,11 +7578,13 @@
 	    }
 	    return result;
 	}
+	// https://github.com/Turfjs/turf
 	function destination(point, distance, bearing, options = {}) {
 	    const longitude1 = degreeToRadian(point[0]);
 	    const latitude1 = degreeToRadian(point[1]);
 	    const bearingRad = degreeToRadian(bearing);
 	    const radians = lengthToRadians(distance, options.units);
+	    // Main
 	    const latitude2 = Math.asin(Math.sin(latitude1) * Math.cos(radians) + Math.cos(latitude1) * Math.sin(radians) * Math.cos(bearingRad));
 	    const longitude2 = longitude1 +
 	        Math.atan2(Math.sin(bearingRad) * Math.sin(radians) * Math.cos(latitude1), Math.cos(radians) - Math.sin(latitude1) * Math.sin(latitude2));
@@ -6170,17 +7593,41 @@
 	    return { x: lng, y: lat };
 	}
 
+	/* Adapted from venn.js by Ben Frederickson
+	 * https://github.com/benfred/venn.js
+	 * Licensed under the MIT
+
+	 * url: https://github.com/benfred/venn.js/blob/master/src/circleintersection.js
+	 * License: https://github.com/benfred/venn.js/blob/master/LICENSE
+	 * @license
+	 */
 	const SMALL = 1e-10;
 
+	/* Adapted from venn.js by Ben Frederickson
+	 * https://github.com/benfred/venn.js
+	 * Licensed under the MIT
+
+	 * url: https://github.com/benfred/venn.js/blob/master/src/circleintersection.js
+	 * License: https://github.com/benfred/venn.js/blob/master/LICENSE
+	 * @license
+	 */
+	/** Returns the intersection area of a bunch of circles (where each circle
+	 is an object having an x,y and radius property) */
 	function intersectionArea(circles, stats) {
+	    // get all the intersection points of the circles
 	    const intersectionPoints = getIntersectionPoints(circles);
+	    // filter out points that aren't included in all the circles
 	    const innerPoints = intersectionPoints.filter(function (p) {
 	        return containedInCircles(p, circles);
 	    });
 	    let arcArea = 0;
 	    let polygonArea = 0;
 	    const arcs = [];
+	    // if we have intersection points that are within all the circles,
+	    // then figure out the area contained by them
 	    if (innerPoints.length > 1) {
+	        // sort the points by angle from the center of the polygon, which lets
+	        // us just iterate over points to get the edges
 	        const center = getCenter(innerPoints);
 	        for (let i = 0; i < innerPoints.length; ++i) {
 	            const p = innerPoints[i];
@@ -6189,14 +7636,20 @@
 	        innerPoints.sort(function (a, b) {
 	            return b.angle - a.angle;
 	        });
+	        // iterate over all points, get arc between the points
+	        // and update the areas
 	        let p2 = innerPoints[innerPoints.length - 1];
 	        for (let i = 0; i < innerPoints.length; ++i) {
 	            const p1 = innerPoints[i];
+	            // polygon area updates easily ...
 	            polygonArea += (p2.x + p1.x) * (p1.y - p2.y);
+	            // updating the arc area is a little more involved
 	            const midPoint = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
 	            let arc = null;
 	            for (let j = 0; j < p1.parentIndex.length; ++j) {
 	                if (p2.parentIndex.indexOf(p1.parentIndex[j]) > -1) {
+	                    // figure out the angle halfway between the two points
+	                    // on the current circle
 	                    const circle = circles[p1.parentIndex[j]];
 	                    const a1 = Math.atan2(p1.x - circle.x, p1.y - circle.y);
 	                    const a2 = Math.atan2(p2.x - circle.x, p2.y - circle.y);
@@ -6204,14 +7657,19 @@
 	                    if (angleDiff < 0) {
 	                        angleDiff += 2 * Math.PI;
 	                    }
+	                    // and use that angle to figure out the width of the
+	                    // arc
 	                    const a = a2 - angleDiff / 2;
 	                    let width = PointService.distancePP(midPoint, {
 	                        x: circle.x + circle.radius * Math.sin(a),
 	                        y: circle.y + circle.radius * Math.cos(a)
 	                    });
+	                    // clamp the width to the largest is can actually be
+	                    // (sometimes slightly overflows because of FP errors)
 	                    if (width > circle.radius * 2) {
 	                        width = circle.radius * 2;
 	                    }
+	                    // pick the circle whose arc has the smallest width
 	                    if (arc === null || arc.width > width) {
 	                        arc = { circle: circle, width: width, p1: p1, p2: p2 };
 	                    }
@@ -6225,12 +7683,16 @@
 	        }
 	    }
 	    else {
+	        // no intersection points, is either disjoint - or is completely
+	        // overlapped. figure out which by examining the smallest circle
 	        let smallest = circles[0];
 	        for (let i = 1; i < circles.length; ++i) {
 	            if (circles[i].radius < smallest.radius) {
 	                smallest = circles[i];
 	            }
 	        }
+	        // make sure the smallest circle is completely contained in all
+	        // the other circles
 	        let disjoint = false;
 	        for (let i = 0; i < circles.length; ++i) {
 	            if (PointService.distancePP(circles[i], smallest) > Math.abs(smallest.radius - circles[i].radius)) {
@@ -6262,6 +7724,7 @@
 	    }
 	    return arcArea + polygonArea;
 	}
+	/** returns whether a point is contained by all of a list of circles */
 	function containedInCircles(point, circles) {
 	    for (let i = 0; i < circles.length; ++i) {
 	        if (PointService.distancePP(point, circles[i]) > circles[i].radius + SMALL) {
@@ -6270,6 +7733,7 @@
 	    }
 	    return true;
 	}
+	/** Gets all intersection points between a bunch of circles */
 	function getIntersectionPoints(circles) {
 	    const ret = [];
 	    for (let i = 0; i < circles.length; ++i) {
@@ -6284,13 +7748,19 @@
 	    }
 	    return ret;
 	}
+	/** Circular segment area calculation. See http://mathworld.wolfram.com/CircularSegment.html */
 	function circleArea(r, width) {
 	    return r * r * Math.acos(1 - width / r) - (r - width) * Math.sqrt(width * (2 * r - width));
 	}
+	/** Returns the overlap area of two circles of radius r1 and r2 - that
+	have their centers separated by distance d. Simpler faster
+	circle intersection for only two circles */
 	function circleOverlap(r1, r2, d) {
+	    // no overlap
 	    if (d >= r1 + r2) {
 	        return 0;
 	    }
+	    // completely overlapped
 	    if (d <= Math.abs(r1 - r2)) {
 	        return Math.PI * Math.min(r1, r2) * Math.min(r1, r2);
 	    }
@@ -6298,10 +7768,15 @@
 	    const w2 = r2 - (d * d - r1 * r1 + r2 * r2) / (2 * d);
 	    return circleArea(r1, w1) + circleArea(r2, w2);
 	}
+	/** Given two circles (containing a x/y/radius attributes),
+	returns the intersecting points if possible.
+	note: doesn't handle cases where there are infinitely many
+	intersection points (circles are equivalent):, or only one intersection point*/
 	function circleCircleIntersection(p1, p2) {
 	    const d = PointService.distancePP(p1, p2);
 	    const r1 = p1.radius;
 	    const r2 = p2.radius;
+	    // if to far away, or self contained - can't be done
 	    if (d >= r1 + r2 || d <= Math.abs(r1 - r2)) {
 	        return [];
 	    }
@@ -6316,6 +7791,7 @@
 	        { x: x0 - rx, y: y0 + ry }
 	    ];
 	}
+	/** Returns the center of a bunch of points */
 	function getCenter(points) {
 	    const center = { x: 0, y: 0 };
 	    for (let i = 0; i < points.length; ++i) {
@@ -6327,6 +7803,14 @@
 	    return center;
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-time-format
+	 * Licensed under the ISC
+
+	 * url: https://github.com/d3/d3-time-format/blob/d6feb945baa4b7a45898a9ca926ebca044e20657/src/locale.js
+	 * License: https://github.com/d3/d3-time-format/blob/main/LICENSE
+	 * @license
+	 */
 	class TimeUtil {
 	    static getInstance() {
 	        if (!TimeUtil.instance) {
@@ -6339,8 +7823,9 @@
 	        this.locale_periods = ['AM', 'PM'];
 	        this.locale_weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
 	        this.locale_shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-	        this.numberRe = /^\s*\d+/;
+	        this.numberRe = /^\s*\d+/; // note: ignores next directive
 	        this.pads = { '-': '', _: ' ', '0': '0' };
+	        //   const percentRe = /^%/;
 	        this.requoteRe = /[\\^$*+?|[\]().{}]/g;
 	        this.locale_months = [
 	            'January',
@@ -6617,18 +8102,22 @@
 	            if (i !== string.length) {
 	                return null;
 	            }
+	            // If a UNIX timestamp is specified, return it.
 	            if ('Q' in d) {
 	                return new Date(d.Q);
 	            }
 	            if ('s' in d) {
 	                return new Date(d.s * 1000 + ('L' in d ? d.L : 0));
 	            }
+	            // If this is utcParse, never use the local timezone.
 	            if (Z && !('Z' in d)) {
 	                d.Z = 0;
 	            }
+	            // The am-pm flag is 0 for AM, and 1 for PM.
 	            if ('p' in d) {
 	                d.H = (d.H % 12) + d.p * 12;
 	            }
+	            // If the month was not specified, inherit from the quarter.
 	            if (d.m === undefined) {
 	                d.m = 'q' in d ? d.q : 0;
 	            }
@@ -6637,6 +8126,7 @@
 	                d.M += d.Z % 100;
 	                return that.utcDate(d);
 	            }
+	            // Otherwise, all fields are in local time.
 	            return that.localDate(d);
 	        };
 	    }
@@ -6678,6 +8168,13 @@
 	    }
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	function formatDecimal(x) {
 	    return Math.abs((x = Math.round(x))) >= 1e21 ? x.toLocaleString('en').replace(/,/g, '') : x.toString(10);
 	}
@@ -6685,12 +8182,19 @@
 	    const _x = p ? x.toExponential(p - 1) : x.toExponential();
 	    const i = _x.indexOf('e');
 	    if (i < 0) {
-	        return null;
+	        return null; // NaN, ±Infinity
 	    }
 	    const coefficient = _x.slice(0, i);
 	    return [coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, +_x.slice(i + 1)];
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	function formatGroup(grouping, thousands) {
 	    return function (value, width) {
 	        let i = value.length;
@@ -6712,6 +8216,13 @@
 	    };
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	let prefixExponent;
 	function formatPrefixAuto(x, p) {
 	    const d = formatDecimalParts(x, p);
@@ -6728,9 +8239,16 @@
 	            ? coefficient + new Array(i - n + 1).join('0')
 	            : i > 0
 	                ? coefficient.slice(0, i) + '.' + coefficient.slice(i)
-	                : '0.' + new Array(1 - i).join('0') + formatDecimalParts(x, Math.max(0, p + i - 1))[0];
+	                : '0.' + new Array(1 - i).join('0') + formatDecimalParts(x, Math.max(0, p + i - 1))[0]; // less than 1y!
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	function formatRounded(x, p) {
 	    const d = formatDecimalParts(x, p);
 	    if (!d) {
@@ -6745,6 +8263,13 @@
 	            : coefficient + new Array(exponent - coefficient.length + 2).join('0');
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	function formatTrim(s) {
 	    const n = s.length;
 	    let i0 = -1;
@@ -6820,6 +8345,13 @@
 	    });
 	}
 
+	/* Adapted from d3-time-format by Mike Bostock
+	 * https://github.com/d3/d3-format
+	 * Licensed under the ISC
+
+	 * License: https://github.com/d3/d3-format/blob/main/LICENSE
+	 * @license
+	 */
 	const prefixes = ['y', 'z', 'a', 'f', 'p', 'n', 'µ', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
 	class NumberUtil {
 	    constructor() {
@@ -6868,19 +8400,33 @@
 	        let precision = specifierIns.precision;
 	        let trim = specifierIns.trim;
 	        let type = specifierIns.type;
+	        // The "n" type is an alias for ",g".
 	        if (type === 'n') {
 	            (comma = true), (type = 'g');
 	        }
+	        // The "" type, and any invalid type, is an alias for ".12~g".
+	        // @ts-ignore
 	        else if (!formatTypes[type]) {
 	            precision === undefined && (precision = 12), (trim = true), (type = 'g');
 	        }
+	        // If zero fill is specified, padding goes after sign and before digits.
+	        // @ts-ignore
 	        if (zero || (fill === '0' && align === '=')) {
 	            (zero = true), (fill = '0'), (align = '=');
 	        }
+	        // Compute the prefix and suffix.
+	        // For SI-prefix, the suffix is lazily computed.
 	        const prefix = symbol === '$' ? this.currencyPrefix : symbol === '#' && /[boxX]/.test(type) ? '0' + type.toLowerCase() : '';
 	        const suffix = symbol === '$' ? this.currencySuffix : /[%p]/.test(type) ? this.percent : '';
+	        // What format function should we use?
+	        // Is this an integer type?
+	        // Can this type generate exponential notation?
 	        const formatType = formatTypes[type];
 	        const maybeSuffix = /[defgprstz%]/.test(type);
+	        // Set the default precision if not specified,
+	        // or clamp the specified precision to the supported range.
+	        // For significant precision, it must be in [1, 21].
+	        // For fixed precision, it must be in [0, 20].
 	        precision =
 	            precision === undefined
 	                ? 6
@@ -6901,20 +8447,27 @@
 	            }
 	            else {
 	                _value = +_value;
+	                // Determine the sign. -0 is not less than 0, but 1 / -0 is!
 	                let valueNegative = _value < 0 || 1 / _value < 0;
+	                // Perform the initial formatting.
 	                _value = isNaN(_value) ? nan : formatType(Math.abs(_value), precision);
+	                // Trim insignificant zeros.
 	                if (trim) {
 	                    _value = formatTrim(_value);
 	                }
+	                // If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign.
 	                if (valueNegative && +_value === 0 && sign !== '+') {
 	                    valueNegative = false;
 	                }
+	                // Compute the prefix and suffix.
 	                valuePrefix =
 	                    (valueNegative ? (sign === '(' ? sign : minus) : sign === '-' || sign === '(' ? '' : sign) + valuePrefix;
 	                valueSuffix =
 	                    (type === 's' ? prefixes[8 + prefixExponent / 3] : '') +
 	                        valueSuffix +
 	                        (valueNegative && sign === '(' ? ')' : '');
+	                // Break the formatted value into the integer “value” part that can be
+	                // grouped, and fractional or exponential “suffix” part that is not.
 	                if (maybeSuffix) {
 	                    (i = -1), (n = _value.length);
 	                    while (++i < n) {
@@ -6926,15 +8479,19 @@
 	                    }
 	                }
 	            }
+	            // If the fill character is not "0", grouping is applied before padding.
 	            if (comma && !zero) {
 	                _value = group(_value, Infinity);
 	            }
+	            // Compute the padding.
 	            let length = valuePrefix.length + _value.length + valueSuffix.length;
 	            let padding = length < width ? new Array(width - length + 1).join(fill) : '';
+	            // If the fill character is "0", grouping is applied after padding.
 	            if (comma && zero) {
 	                _value = group(padding + _value, padding.length ? width - valueSuffix.length : Infinity);
 	                padding = '';
 	            }
+	            // Reconstruct the final output based on the desired alignment.
 	            switch (align) {
 	                case '<':
 	                    _value = valuePrefix + _value + valueSuffix + padding;
@@ -6988,6 +8545,7 @@
 	    X: (x) => Math.round(x).toString(16).toUpperCase(),
 	    x: (x) => Math.round(x).toString(16),
 	    t: (x, p) => {
+	        // 判断是否为整数
 	        if (Number.isInteger(x)) {
 	            return x.toFixed(2);
 	        }
@@ -7005,6 +8563,16 @@
 	    };
 	}
 
+	/* Adapted from fmin by Ben Frederickson
+	 * https://github.com/benfred/fmin
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/benfred/fmin/blob/master/src/blas1.js
+	 * License: https://github.com/benfred/fmin/blob/master/LICENSE
+	 * @license
+	 */
+	// need some basic operations on vectors, rather than adding a dependency,
+	// just define here
 	function zeros(x) {
 	    const r = new Array(x);
 	    for (let i = 0; i < x; ++i) {
@@ -7036,6 +8604,15 @@
 	    }
 	}
 
+	/* Adapted from fmin by Ben Frederickson
+	 * https://github.com/benfred/fmin
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/benfred/fmin/blob/master/src/nelderMead.js
+	 * License: https://github.com/benfred/fmin/blob/master/LICENSE
+	 * @license
+	 */
+	/** minimizes a function using the downhill simplex method */
 	function nelderMead(f, x0, parameters) {
 	    parameters = parameters || {};
 	    const maxIterations = parameters.maxIterations || x0.length * 200;
@@ -7048,6 +8625,7 @@
 	    const psi = parameters.psi !== undefined ? parameters.psi : -0.5;
 	    const sigma = parameters.sigma !== undefined ? parameters.sigma : 0.5;
 	    let maxDiff;
+	    // initialize simplex.
 	    const N = x0.length;
 	    const simplex = new Array(N + 1);
 	    simplex[0] = x0;
@@ -7076,6 +8654,8 @@
 	    for (let iteration = 0; iteration < maxIterations; ++iteration) {
 	        simplex.sort(sortOrder);
 	        if (parameters.history) {
+	            // copy the simplex (since later iterations will mutate) and
+	            // sort it to have a consistent order between iterations
 	            const sortedSimplex = simplex.map(function (x) {
 	                const state = x.slice();
 	                state.fx = x.fx;
@@ -7094,6 +8674,7 @@
 	        if (Math.abs(simplex[0].fx - simplex[N].fx) < minErrorDelta && maxDiff < minTolerance) {
 	            break;
 	        }
+	        // compute the centroid of all but the worst point in the simplex
 	        for (let i = 0; i < N; ++i) {
 	            centroid[i] = 0;
 	            for (let j = 0; j < N; ++j) {
@@ -7101,9 +8682,12 @@
 	            }
 	            centroid[i] /= N;
 	        }
+	        // reflect the worst point past the centroid  and compute loss at reflected
+	        // point
 	        const worst = simplex[N];
 	        weightedSum(reflected, 1 + rho, centroid, -rho, worst);
 	        reflected.fx = f(reflected);
+	        // if the reflected point is the best seen, then possibly expand
 	        if (reflected.fx < simplex[0].fx) {
 	            weightedSum(expanded, 1 + chi, centroid, -chi, worst);
 	            expanded.fx = f(expanded);
@@ -7114,9 +8698,12 @@
 	                updateSimplex(reflected);
 	            }
 	        }
+	        // if the reflected point is worse than the second worst, we need to
+	        // contract
 	        else if (reflected.fx >= simplex[N - 1].fx) {
 	            let shouldReduce = false;
 	            if (reflected.fx > worst.fx) {
+	                // do an inside contraction
 	                weightedSum(contracted, 1 + psi, centroid, -psi, worst);
 	                contracted.fx = f(contracted);
 	                if (contracted.fx < worst.fx) {
@@ -7127,6 +8714,7 @@
 	                }
 	            }
 	            else {
+	                // do an outside contraction
 	                weightedSum(contracted, 1 - psi * rho, centroid, psi * rho, worst);
 	                contracted.fx = f(contracted);
 	                if (contracted.fx < reflected.fx) {
@@ -7137,9 +8725,11 @@
 	                }
 	            }
 	            if (shouldReduce) {
+	                // if we don't contract here, we're done
 	                if (sigma >= 1) {
 	                    break;
 	                }
+	                // do a reduction
 	                for (let i = 1; i < simplex.length; ++i) {
 	                    weightedSum(simplex[i], 1 - sigma, simplex[0], sigma, simplex[i]);
 	                    simplex[i].fx = f(simplex[i]);
@@ -7154,6 +8744,21 @@
 	    return { fx: simplex[0].fx, x: simplex[0] };
 	}
 
+	/* Adapted from fmin by Ben Frederickson
+	 * https://github.com/benfred/fmin
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/benfred/fmin/blob/master/src/linesearch.js
+	 * License: https://github.com/benfred/fmin/blob/master/LICENSE
+	 * @license
+	 */
+	/// searches along line 'pk' for a point that satifies the wolfe conditions
+	/// See 'Numerical Optimization' by Nocedal and Wright p59-60
+	/// f : objective function
+	/// pk : search direction
+	/// current: object containing current gradient/loss
+	/// next: output: contains next gradient/loss
+	/// returns a: step size taken
 	function wolfeLineSearch(f, pk, current, next, a, c1, c2) {
 	    const phi0 = current.fx;
 	    const phiPrime0 = dotProduct(current.fxprime, pk);
@@ -7206,7 +8811,17 @@
 	    return a;
 	}
 
+	/* Adapted from fmin by Ben Frederickson
+	 * https://github.com/benfred/fmin
+	 * Licensed under the BSD-3-Clause
+
+	 * url: https://github.com/benfred/fmin/blob/master/src/conjugateGradient.js
+	 * License: https://github.com/benfred/fmin/blob/master/LICENSE
+	 * @license
+	 */
 	function conjugateGradient(f, initial, params) {
+	    // allocate all memory up front here, keep out of the loop for perfomance
+	    // reasons
 	    let current = { x: initial.slice(), fx: 0, fxprime: initial.slice() };
 	    let next = { x: initial.slice(), fx: 0, fxprime: initial.slice() };
 	    const yk = initial.slice();
@@ -7219,13 +8834,17 @@
 	    scale(pk, current.fxprime, -1);
 	    for (let i = 0; i < maxIterations; ++i) {
 	        a = wolfeLineSearch(f, pk, current, next, a);
+	        // todo: history in wrong spot?
 	        if (params.history) {
 	            params.history.push({ x: current.x.slice(), fx: current.fx, fxprime: current.fxprime.slice(), alpha: a });
 	        }
 	        if (!a) {
+	            // faiiled to find point that satifies wolfe conditions.
+	            // reset direction for next iteration
 	            scale(pk, current.fxprime, -1);
 	        }
 	        else {
+	            // update direction using Polak–Ribiere CG method
 	            weightedSum(yk, 1, next.fxprime, -1, current.fxprime);
 	            const delta_k = dotProduct(current.fxprime, current.fxprime);
 	            const beta_k = Math.max(0, dotProduct(yk, next.fxprime) / delta_k);
@@ -7288,6 +8907,7 @@
 	exports.binaryFuzzySearch = binaryFuzzySearch;
 	exports.binaryFuzzySearchInNumberRange = binaryFuzzySearchInNumberRange;
 	exports.bisect = bisect;
+	exports.bootstrapEstimate = bootstrapEstimate;
 	exports.calculateAnchorOfArc = calculateAnchorOfArc;
 	exports.calculateAnchorOfBounds = calculateAnchorOfBounds;
 	exports.calculateMaxRadius = calculateMaxRadius;
@@ -7308,6 +8928,7 @@
 	exports.conjugateGradient = conjugateGradient;
 	exports.constant = constant;
 	exports.containedInCircles = containedInCircles;
+	exports.correlation = correlation;
 	exports.cos = cos;
 	exports.crossProduct = crossProduct;
 	exports.crossProductPoint = crossProductPoint;
@@ -7426,6 +9047,7 @@
 	exports.lowerFirst = lowerFirst;
 	exports.max = max;
 	exports.maxInArray = maxInArray;
+	exports.mean = mean;
 	exports.median = median;
 	exports.memoize = memoize;
 	exports.merge = merge;
@@ -7452,6 +9074,7 @@
 	exports.monthSetterName = monthSetterName;
 	exports.nelderMead = nelderMead;
 	exports.norm2 = norm2;
+	exports.normalQuantile = normalQuantile;
 	exports.normalTransform = normalTransform;
 	exports.normalizeAngle = normalizeAngle;
 	exports.normalizePadding = normalizePadding;
@@ -7482,6 +9105,7 @@
 	exports.randomLCG = randomLCG;
 	exports.range = range;
 	exports.rectInsideAnotherRect = rectInsideAnotherRect;
+	exports.regressionBootstrap = regressionBootstrap;
 	exports.regressionLinear = regressionLinear;
 	exports.regressionLogistic = regressionLogistic;
 	exports.regressionLowess = regressionLowess;