foreslash 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change Log
 
+## Version 0.3.3 - 2025-11-05
+
+Unstable version
+
+- Feat 🥥 Functions added: `lerp` `scientificNotation` `castArray` `romanNumerals` `randomDistribution` and so forth
+- Fix 🥕 Document: Added version tags to `memo` and description to several methods
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `lerp` `scientificNotation` `castArray` `randomDistribution` 等
+- 修复 🥕 文档: 补充 `memo` 的版本标签和部分方法的说明
+- 其他修复与优化
+
 ## Version 0.3.2 - 2025-09-23
 
 Unstable version

package/lib/index.cmn.cjs

@@ -45,6 +45,10 @@ function cartesianProduct(...arrList) {
     return res;
 }
 
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
 function chunk(array, size = 2) {
     const res = [];
     if (size < 1 || isNaN(size))
@@ -609,6 +613,201 @@ function format(num, options) {
         return sign + integer;
 }
 
+function lerp(val1, val2, t) {
+    if (isNumber(val1)) {
+        if (!isNumber(val2))
+            throw new Error('Invalid val2 parameter: val2 should be a number');
+        return _lerp(val1, val2, t);
+    }
+    else if (isArray(val1)) {
+        if (!isArray(val2))
+            throw new Error('Invalid val2 parameter: val2 should be an Array');
+        if (val1.length !== val2.length) {
+            throw new Error(`Invalid val2 parameter: the length of val2 (${val2.length}) should be consistent with val1 (${val1.length})`);
+        }
+        if (val1.length === 0)
+            return [];
+        if (isNumber(val1[0])) {
+            if (!isNumber(val2[0]))
+                throw new Error('Invalid val2 parameter: val2 should be an Array<number>');
+            return val1.map((v1, index) => _lerp(v1, val2[index], t));
+        }
+        else if (isArray(val1[0])) {
+            const res = [];
+            for (let i = 0; i < val1.length; i++) {
+                const arr1 = val1[i];
+                const arr2 = val2[i];
+                if (arr1.length !== arr2.length) {
+                    throw new Error(`Invalid val2 parameter: The length of array at index ${i} in val2 (${arr2.length}) must match the length of the corresponding array in val1 (${arr1.length})`);
+                }
+                res.push(arr1.map((v1, index) => _lerp(v1, arr2[index], t)));
+            }
+            return res;
+        }
+    }
+    throw new Error('Invalid val1 parameter: val1 should be a number or Array');
+}
+function _lerp(val1, val2, t) {
+    return val1 + (val2 - val1) * t;
+}
+
+function romanNumerals(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const thousand = (options || {}).thousand || 'normal';
+    const forceSplitThousand = thousand === 'strict';
+    const integer = str.split('.')[0].replace('-', '');
+    if (integer === '0') {
+        const zero = (options || {}).zero || '0';
+        if (type === 'json')
+            return `["${zero}"]`;
+        else
+            return zero;
+    }
+    if (integer === '1') {
+        const one = (options || {}).one || 'I';
+        if (type === 'json')
+            return `["${one}"]`;
+        else
+            return one;
+    }
+    const chunks = chunk(Array.from(integer).reverse(), 3);
+    const romanChunks = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const val = Number(chunks[i].reverse().join(''));
+        if (i === chunks.length - 2 && !forceSplitThousand && Number(chunks[i + 1]) < 4) {
+            romanChunks.push(number2roman(val + Number(chunks[i + 1]) * 1000));
+            break;
+        }
+        else {
+            romanChunks.push(number2roman(val));
+        }
+    }
+    switch (type) {
+        case 'js':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\\\\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'html':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '&#x0305;'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'json':
+            return `[${romanChunks.map((str) => `"${str}"`).join(', ')}]`;
+        case 'unicode':
+        default:
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+    }
+}
+function number2roman(num) {
+    const symbols = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I'],
+    ];
+    let roman = '';
+    for (const [val, str] of symbols) {
+        while (num >= val) {
+            num -= val;
+            roman += str;
+        }
+        if (num == 0)
+            break;
+    }
+    return roman;
+}
+
+function scientificNotation(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const _precision = (options || {}).precision;
+    const precision = isNumber(_precision) ? clamp(_precision !== null && _precision !== void 0 ? _precision : 2, 0, Infinity) : null;
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    let exp = 0;
+    let n = '';
+    if (integer === '0') {
+        exp = /^(0+)/.test(fractional) ? -(fractional.match(/^(0+)/)[0].length + 1) : -1;
+        [integer, fractional] = [fractional.slice(-exp - 1, -exp), fractional.slice(-exp)];
+    }
+    else {
+        exp = integer.length - 1;
+        [integer, fractional] = [integer.slice(0, 1), integer.slice(1) + fractional];
+    }
+    if (isNumber(precision)) {
+        if (fractional.length > precision) {
+            const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+            [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+        }
+        else if (fractional.length < precision) {
+            fractional += '0'.repeat(precision - fractional.length);
+        }
+    }
+    else {
+        fractional = fractional.replace(/0+$/, '');
+    }
+    if ((precision === null && fractional) || (isNumber(precision) && precision > 0)) {
+        n = sign + integer + '.' + fractional;
+    }
+    else
+        n = sign + integer;
+    switch (type) {
+        case 'exp':
+            return `${n}e${exp < 0 ? '' : '+'}${exp}`;
+        case 'js':
+            return `${n}*10**${exp}`;
+        case 'code':
+            return `${n}*10^${exp}`;
+        case 'html':
+            return `${n}&#x00d7;10<sup>${exp}</sup>`;
+        case 'json':
+            return `{"number":"${n}","exp":${exp}}`;
+        case 'unicode':
+        default:
+            return `${n}×10${transferNumberToUniCode(String(exp))}`;
+    }
+}
+function transferNumberToUniCode(n) {
+    const strMap = Object.assign(Object.assign({}, Array.from('⁰¹²³⁴⁵⁶⁷⁸⁹')), { '-': '⁻', '+': '⁺' });
+    return Array.from(n)
+        .map((s) => (strMap[s] ? strMap[s] : s))
+        .join('');
+}
+
 function parallel(args, fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!args.length)
@@ -1240,6 +1439,54 @@ function randomChoice(arr, weights) {
     return arr[index];
 }
 
+function randomDistribution(p, options) {
+    const threshold = (options === null || options === void 0 ? void 0 : options.threshold) ? Math.max(options.threshold, Number.MIN_VALUE * 2) : 5e-6;
+    const C = getInitP(p, threshold);
+    let current = C;
+    return function getRandomDistribution() {
+        const res = Math.random() < current;
+        if (res)
+            current = C;
+        else
+            current += C;
+        return res;
+    };
+}
+function getInitP(targetP, threshold = 5e-6) {
+    if (targetP <= 0)
+        return 0;
+    if (targetP >= 1)
+        return 1;
+    let [down, up] = [0, 1];
+    let mid = 1;
+    let tempP = 1;
+    let tempPLast = 1;
+    let step = 64;
+    while (step-- > 0) {
+        mid = (down + up) / 2;
+        tempP = getRealPFromInitP(mid);
+        if (Math.abs(tempPLast - tempP) < threshold)
+            break;
+        if (tempP > targetP)
+            up = mid;
+        else
+            down = mid;
+    }
+    return mid;
+}
+function getRealPFromInitP(initP) {
+    let sum = 0;
+    let prod = 0;
+    let cur = 0;
+    let max = Math.ceil(1 / initP);
+    for (let n = 1; n <= max; n++) {
+        cur = Math.min(1, n * initP) * (1 - prod);
+        prod += cur;
+        sum += n * cur;
+    }
+    return 1 / sum;
+}
+
 const radix32 = '0123456789abcdefghijklmnopqrstuv';
 const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
 const base32Crockford = '0123456789abcdefghjkmnpqrstvwxyz';
@@ -1866,22 +2113,22 @@ function _deepClone(obj, map, options) {
     if (isFormData(obj))
         return _cloneFormData(obj, map, _deepClone, options);
     let res;
-    if (obj instanceof Date) {
+    if (isDate(obj)) {
         res = new Date(obj.valueOf());
         map.set(obj, res);
     }
-    else if (obj instanceof RegExp) {
+    else if (isRegExp(obj)) {
         res = new RegExp(obj.source, obj.flags);
         map.set(obj, res);
     }
-    else if (obj instanceof ArrayBuffer) {
+    else if (isArrayBuffer(obj)) {
         res = _cloneArrayBuffer(obj, map);
     }
     else if (isTypedArray(obj)) {
         res = new obj.constructor(_cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.length);
         map.set(obj, res);
     }
-    else if (obj instanceof DataView) {
+    else if (isDataView(obj)) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
@@ -2289,6 +2536,7 @@ exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
 exports.casePascal = casePascal;
 exports.caseSnake = caseSnake;
+exports.castArray = castArray;
 exports.chunk = chunk;
 exports.clamp = clamp;
 exports.compose = compose;
@@ -2304,6 +2552,7 @@ exports.format = format;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
 exports.getAcceptableMIMEByExt = getAcceptableMIMEByExt;
 exports.getGlobalThis = getGlobalThis;
+exports.getInitP = getInitP;
 exports.getTag = getTag;
 exports.indent = indent;
 exports.isArray = isArray;
@@ -2360,6 +2609,7 @@ exports.isWrapperObject = isWrapperObject;
 exports.isWrapperString = isWrapperString;
 exports.isWrapperSymbol = isWrapperSymbol;
 exports.kebabCase = kebabCase;
+exports.lerp = lerp;
 exports.memo = memo;
 exports.noop = noop;
 exports.not = not;
@@ -2370,6 +2620,7 @@ exports.passWith = passWith;
 exports.pipe = pipe;
 exports.randomBase32String = randomBase32String;
 exports.randomChoice = randomChoice;
+exports.randomDistribution = randomDistribution;
 exports.randomHexString = randomHexString;
 exports.randomInt = randomInt;
 exports.randomIntFloor = randomIntFloor;
@@ -2377,11 +2628,13 @@ exports.randomString = randomString;
 exports.range = range;
 exports.remove = remove;
 exports.retry = retry;
+exports.romanNumerals = romanNumerals;
 exports.round = round;
 exports.roundBank = roundBank;
 exports.roundBase = roundBase;
 exports.roundCeil = roundCeil;
 exports.roundFloor = roundFloor;
+exports.scientificNotation = scientificNotation;
 exports.shuffle = shuffle;
 exports.sleep = sleep;
 exports.snakeCase = snakeCase;

package/lib/index.d.ts

@@ -24,6 +24,56 @@ declare function cartesianProduct<T1, T2, T3, T4, T5, T6, T7>(arr1: ArrayLike<T1
 declare function cartesianProduct<T1, T2, T3, T4, T5, T6, T7, T8>(arr1: ArrayLike<T1>, arr2: ArrayLike<T2>, arr3: ArrayLike<T3>, arr4: ArrayLike<T4>, arr5: ArrayLike<T5>, arr6: ArrayLike<T6>, arr7: ArrayLike<T7>, arr8: ArrayLike<T8>): [T1, T2, T3, T4, T5, T6, T7, T8][];
 declare function cartesianProduct(...arrList: ArrayLike<any>[]): any[][];
 
+/**
+ * 将值转换为一个数组
+ * @param value 需要处理的值
+ * @returns 一个数组, 如果输入值是数组, 则输出的数组是其**浅拷贝**; 如果输入不是数组，则将输入包进一个新数组里
+ * @example
+ * ```js
+ * // 如果输入不是数组，则将输入包进一个新数组里
+ * castArray(1) // [1]
+ * castArray('1') // ['1']
+ * castArray(null) // [null]
+ *
+ * // 如果输入值是数组, 则输出的数组是其浅拷贝
+ * castArray([1, 2, 3, 4, 5]) // [1, 2, 3, 4, 5]
+ * ```
+ * @version 0.3.3
+ */
+declare function castArray<T>(value: T): CastArray<T>;
+/**
+ * 将任意输入处理为数组:
+ * 1. `never` 类型判断, 确保 `castArray<never>` 返回 `never[]` 而不是 `unknown[]`
+ * 2. `unknown` 类型判断, `unknown` 是顶级类型, 需要特殊处理
+ * 3. `readonly any[]` 类型判断, 输出的类型需要去除 `readonly`
+ * 4. 非数组类型判断, 处理联合类型
+ *
+ * 数组类型判据:
+ * - 如果 `Exclude<T, readonly any[]> extends never` 意味着 `T` 的类型与 `any[]` 兼容, 此时应该走逻辑 3
+ *
+ * @example
+ * ```ts
+ * type T = CastArray<string> // string[]
+ * type T = CastArray<string[]> // string[]
+ * type T = CastArray<readonly string[]> // string[]
+ * // 特殊类型
+ * type T = CastArray<any> // any[]
+ * type T = CastArray<unknown> // unknown[]
+ * type T = CastArray<never> // never[]
+ * // 联合类型
+ * type T = CastArray<string | number> // (string | number)[]
+ * type T = CastArray<string[] | number> // string[] | number[]
+ * type T = CastArray<string | number | never> // (string | number)[]
+ * type T = CastArray<string | number[] | never[]> // never[] | number[] | string[]
+ * type T = CastArray<string | number | never[]> // never[] | (string | number)[]
+ * ```
+ */
+type CastArray<T> = [
+    T
+] extends [never] ? never[] : [
+    unknown
+] extends [T] ? unknown[] : (T extends readonly (infer U)[] ? U[] : never) | (Exclude<T, readonly any[]> extends never ? never : Exclude<T, readonly any[]>[]);
+
 type Not<T> = T extends false | 0 | '' | null | undefined ? true : false;
 
 type Stringify<T extends string | number | boolean | bigint | null | undefined> = `${T}`;
@@ -253,24 +303,6 @@ declare function retry<T>(asyncFunction: RetryFunction<T>, option?: RetryOption)
 declare function sleep(time?: number): Promise<unknown>;
 
 type TryitResult<Res, Err> = [undefined, Res] | [Err, undefined];
-/**
- * 将一个函数处理为 `error-first` 的函数
- * @param fn 需要处理的函数, 可以是异步函数
- * @returns 处理过的函数, 调用后返回一个 `error-first` 的元组 `[error, result]`;\
- * 如果原函数是异步函数, 则返回值会是 `Promise<[error, result]>`;\
- * 如果运行正常则 `result` 是原函数的返回值, `error` 为 `undefined`;\
- * 如果出现异常则 `result` 为 `undefined`, `error` 是原函数抛出的错误
- * @example
- * ```js
- * // Async Function
- * const normalAsyncFn = () => { return Promise.resolve(1) }
- * const errorAsyncFn = () => { return Promise.reject('1') }
- * tryit(normalAsyncFn)() // Promise<[undefined, 1]>
- * tryit(errorAsyncFn)() // Promise<[Error('1'), undefined]>
- * ```
- * @version 0.2.0
- */
-declare function tryit<Args extends any[], Res, Err extends Error>(fn: (...args: Args) => Promise<Res>): (...args: Args) => Promise<TryitResult<Res, Err>>;
 /**
  * 将一个函数处理为 `error-first` 的函数
  * @param fn 需要处理的函数, 可以是异步函数
@@ -285,9 +317,15 @@ declare function tryit<Args extends any[], Res, Err extends Error>(fn: (...args:
  * const errorFn = () => { throw new Error('1') }
  * tryit(normalFn)() // [undefined, 1]
  * tryit(errorFn)() // [Error('1'), undefined]
+ * // Async Function
+ * const normalAsyncFn = () => { return Promise.resolve(1) }
+ * const errorAsyncFn = () => { return Promise.reject(new Error('1')) }
+ * tryit(normalAsyncFn)() // Promise<[undefined, 1]>
+ * tryit(errorAsyncFn)() // Promise<[Error('1'), undefined]>
  * ```
  * @version 0.2.0
  */
+declare function tryit<Args extends any[], Res, Err extends Error>(fn: (...args: Args) => Promise<Res>): (...args: Args) => Promise<TryitResult<Res, Err>>;
 declare function tryit<Args extends any[], Res, Err extends Error>(fn: (...args: Args) => Res): (...args: Args) => TryitResult<Res, Err>;
 
 interface PromiseLikeConstructor {
@@ -963,14 +1001,15 @@ declare function clamp(num: number, min: number, max: number, options?: {
 declare function decimalNotation(num: string | number): string;
 
 /**
- * 将一个数字转换为指定的格式(如千分位逗号分隔)
+ * 将一个数字转换为指定的格式(如千分位逗号分隔)\
+ * 如果想要将数字转换为科学计数法, 请使用 `scientificNotation`
  * @param num 需要格式化的数字
  * @param options 格式化配置\
- * - `separator` 分割符, 默认为 `','`
- * - `separate` 按位分割, 默认为 `3`
- * - `decimal` 小数点, 默认为 `'.'`
- * - `precision` 小数精度, 默认为 `2`
- * - `round` 数值修约规则
+ * `separator` 分割符, 默认为 `','`\
+ * `separate` 按位分割, 默认为 `3`\
+ * `decimal` 小数点, 默认为 `'.'`\
+ * `precision` 小数精度, 默认为 `2`\
+ * `round` 数值修约规则
  *   - `'round'` 四舍五入
  *   - `'banker'` 四舍六入五成双
  *   - `'floor'` 向下取整
@@ -1001,6 +1040,84 @@ declare function isOdd(num: number): boolean;
  */
 declare function isEven(num: number): boolean;
 
+/**
+ * 用线性插值法求取一个中间值
+ * @param val1 第一个值, 当 权重=0 时返回的将是这个值, 可以是数组或二维数组
+ * @param val2 第二个值, 当 权重=0 时返回的将是这个值, 可以是数组或二维数组
+ * @param t 权重
+ * @example
+ * ```js
+ * // 传入数值
+ * lerp(1, 2, 0) // 1
+ * lerp(1, 2, 0.5) // 1.5
+ * lerp(1, 2, 1) // 2
+ * lerp(1, 2, 3) // 4
+ *
+ * // 传入数组(数组长度必须一致否则会报错)
+ * lerp([1, 2], [2, 4], 0.5) // [1.5, 3]
+ *
+ * // 传入二维数组(数组长度必须一致否则会报错)
+ * lerp(
+ *   [
+ *     [1, 2],
+ *     [3, 4],
+ *   ],
+ *   [
+ *     [11, 12],
+ *     [13, 14],
+ *   ],
+ *   0.5
+ * )
+ * // [
+ * //   [6, 7],
+ * //   [8, 9],
+ * // ]
+ * ```
+ * @version 0.3.3
+ */
+declare function lerp(val1: number, val2: number, t: number): number;
+declare function lerp(val1: [number], val2: [number], t: number): [number];
+declare function lerp(val1: [number, number], val2: [number, number], t: number): [number, number];
+declare function lerp(val1: [number, number, number], val2: [number, number, number], t: number): [number, number, number];
+declare function lerp(val1: [number, number, number, number], val2: [number, number, number, number], t: number): [number, number, number, number];
+declare function lerp(val1: [number, number, number, number, number], val2: [number, number, number, number, number], t: number): [number, number, number, number, number];
+declare function lerp(val1: [number, number, number, number, number, number], val2: [number, number, number, number, number, number], t: number): [number, number, number, number, number, number];
+declare function lerp(val1: [number, number, number, number, number, number, number], val2: [number, number, number, number, number, number, number], t: number): [number, number, number, number, number, number, number];
+declare function lerp(val1: [number, number, number, number, number, number, number, number], val2: [number, number, number, number, number, number, number, number], t: number): [number, number, number, number, number, number, number, number];
+declare function lerp(val1: number[], val2: number[], t: number): number[];
+declare function lerp(val1: number[][], val2: number[][], t: number): number[][];
+
+/**
+ * 将一个数字转换为罗马数字, 罗马数字没有 `0`、小数和负数
+ * @param num 需要转换的数字
+ * @param options 格式化配置\
+ * `type` 类型, 默认为 `unicode`, 以数字 `4090` 为例
+ *   - `'unicode'` 使用 Unicode 表示 `'I̅V̅XC'`
+ *   - `'js'` 适合用于 JavaScript 代码字符串 `'I\\u0305V\\u0305XC'`
+ *   - `'html'` 适合用于 HTML 展示的字符串 `'I&#x0305;V&#x0305;XC'`
+ *   - `'json'` 一个 JSON 字符串, 具体数值是下标^1000 `["XC", "IV"]`
+ *
+ * `thousand` 千分位类型, 默认为 `normal`
+ *   - `'normal'` 习惯用法, 超过 3999 的部分才使用上划线区分
+ *   - `'strict'` 严格区分千分位
+ *
+ * `zero` 用什么字符串表示 `0` (罗马数字里没有 `0`), 不填默认为 `'0'`\
+ * `one` 用什么字符串表示 `1` (你可以设置一个彩蛋, 比如输出 `Yo`), 不填默认为 `'I'`, 这项**只会影响数字 1**
+ * @returns 返回一个罗马数字表示的数字
+ * @example
+ * ```js
+ * romanNumerals(2025) // MMXXV
+ * romanNumerals(2025, { thousand: 'strict' }) // I̅I̅XXV
+ * ```
+ * @version 0.3.3
+ */
+declare function romanNumerals(num: string | number, options?: {
+    type?: 'unicode' | 'js' | 'html' | 'json';
+    thousand?: 'normal' | 'strict';
+    zero?: string;
+    one?: string;
+}): string;
+
 /**
  * 数值修约, 可以使用 4 种修约方法, 默认使用四舍五入
  * - 四舍五入: 修约位置的后一位如果是 5 则进位, 否则不进位
@@ -1106,6 +1223,51 @@ declare function roundFloor(integer: string, fractional: string, precision: numb
  */
 declare function roundCeil(integer: string, fractional: string, precision: number, isNegative: boolean): [integer: string, fractional: string];
 
+/**
+ * 将一个数字转换为科学计数法
+ * @param num 需要转换的数字
+ * @param options 格式化配置\
+ * `type` 类型, 默认为 `unicode`
+ *   - `'unicode'` 指数部分使用 Unicode 表示 `1.23×10⁴⁵⁶`
+ *   - `'exp'` 用指数表示法, 用 `e` 替换 `×10` 部分 `1.23e+456`
+ *   - `'js'` 适合用于 JavaScript 的算式 `1.23*10**456`
+ *   - `'code'` 适合用于其他计算机语言的算式 `1.23*10^456`
+ *   - `'html'` 适合用于 HTML 展示的字符串 `1.23&#x00d7;10<sup>456</sup>`
+ *   - `'json'` 一个 JSON 字符串, 可以自由处理 `{"number":1.23,"exp":456}`
+ *
+ * `precision` 小数精度, 默认不作数值修约\
+ * `round` 数值修约规则
+ *   - `'round'` 四舍五入
+ *   - `'banker'` 四舍六入五成双
+ *   - `'floor'` 向下取整
+ *   - `'ceil'` 向上取整
+ * @returns 返回一个科学计数法表示的数字
+ * @example
+ * ```js
+ * scientificNotation(1e12) // 1×10¹²
+ * scientificNotation(-2.33e-8) // -2.33×10⁻⁸
+ * // 可以指定输出类型
+ * scientificNotation(1.234e-6, { type: 'exp' }) // 1.234e-6
+ * scientificNotation(1.234e6, { type: 'exp' }) // 1.234e+6
+ * scientificNotation(6.534e-6, { type: 'code' }) // 6.534*10^-6
+ * scientificNotation(6.534e6, { type: 'code' }) // 6.534*10^6
+ * scientificNotation(-4.321e-8, { type: 'html' }) // -4.321&#x00d7;10<sup>-8</sup>
+ * scientificNotation(-4.321e8, { type: 'html' }) // -4.321&#x00d7;10<sup>8</sup>
+ * scientificNotation(-9.87e-9, { type: 'json' }) // {"number":"-9.87","exp":-9}
+ * scientificNotation(-9.87e9, { type: 'json' }) // {"number":"-9.87","exp":9}
+ * // 可以指定小数点后的位数及数值修约规则
+ * scientificNotation(1.235e6, { type: 'exp', precision: 2 }) // 1.24e+6
+ * scientificNotation(6.545e-6, { type: 'code', precision: 2, round: 'banker' }) // 6.54*10^-6
+ * scientificNotation(-9.87e9, { type: 'json', precision: 1, round: 'floor' }) // {"number":"-9.9","exp":9}
+ * ```
+ * @version 0.3.3
+ */
+declare function scientificNotation(num: string | number, options?: {
+    type?: 'unicode' | 'exp' | 'js' | 'code' | 'html' | 'json';
+    precision?: number;
+    round?: 'round' | 'banker' | 'floor' | 'ceil';
+}): string;
+
 /**
  * 根据文件名称判断是否匹配支持的文件类型，需要注意 `.C` 与 `.c` 的区别
  * - `text/x-c++src` 对应 `.C`
@@ -1200,6 +1362,35 @@ declare function getAcceptableMIMEByExt(ext: string): string[];
  */
 declare function randomChoice<T>(arr: ArrayLike<T>, weights?: ArrayLike<number>): T;
 
+/**
+ * 一个广泛使用的[伪随机数生成算法(PRD)](https://github.com/Moushudyx/pseudo-random-distribution)\
+ * 返回一个方法, 输出为布尔型, 可以生成一个比正常随机序列分布更加均匀的伪随机数列\
+ * 可以极大地避免罕见牌型出现, 缺点是初始概率很低(即第一次命中的概率远远小于输入的 `p`)\
+ * 建议在投入使用之前, 先调用 `ceil(1 / p)` 次作为初始化\
+ * 此外需要注意的是, 这个算法的最终的精度并不是完全等于输入的 `p` 值
+ * @param p 整体概率值, 即概率的数学期望
+ * @param options 相关配置
+ * - `threshold` 精度, 数值越小, 精度越高, 序列越接近目标 `p` 值, 默认为 `5e-6`
+ * @returns 一个方法, 按给定的概率值返回 `true` 和 `false`
+ * @example
+ * ```js
+ * const p0_5 = pipe(randomDistribution(0.5), Number)
+ * p0_5() // 0, 1, 0, 0, 1, 1 ...
+ * ```
+ * @version 0.3.3
+ */
+declare function randomDistribution(p: number, options?: {
+    threshold: number;
+}): () => boolean;
+/**
+ * 内部方法, 用于实现 `randomDistribution` 中的 PRD 算法部分, 根据目标概率, 给出一个初始概率
+ * @param targetP 目标概率
+ * @param threshold 精度, 数值越小, 精度越高
+ * @returns PRD 算法需要的初始概率
+ * @version 0.3.3
+ */
+declare function getInitP(targetP: number, threshold?: number): number;
+
 /**
  * 生成指定范围内的随机整数
  * @param min 随机数的下界，包含于此范围内
@@ -2029,6 +2220,7 @@ declare function isEmpty(value: unknown): boolean;
  *   return fib(n - 1) + fib(n - 2)
  * })
  * ```
+ * @version 0.2.1
  */
 declare function memo<TArgs extends any[], TRes>(fn: (...args: TArgs) => TRes, options?: {
     getKey?: (...args: TArgs) => string | number;
@@ -2216,5 +2408,5 @@ declare function throttle<T extends any[]>(fn: (...args: T) => any, delay: numbe
     reset: () => void;
 };
 
-export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isEven, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isOdd, isPlaceholder, isPlainObject, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, round, roundBank, roundBase, roundCeil, roundFloor, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };
-export type { BaseMargeType, Chunked, CloneOptions, CustomCloner, IsNegative, IsPositive, IsZero, MergeOption, MergeStrategy, MergeStrategyFunction, MergeType, MergeTypeStrategy, Not, RangeOptions, SourceMergeType, Stringify, TargetMergeType, TypedArray };
+export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, castArray, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getInitP, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isEven, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isOdd, isPlaceholder, isPlainObject, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, lerp, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomDistribution, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, romanNumerals, round, roundBank, roundBase, roundCeil, roundFloor, scientificNotation, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };
+export type { BaseMargeType, CastArray, Chunked, CloneOptions, CustomCloner, IsNegative, IsPositive, IsZero, MergeOption, MergeStrategy, MergeStrategyFunction, MergeType, MergeTypeStrategy, Not, RangeOptions, SourceMergeType, Stringify, TargetMergeType, TypedArray };

package/lib/index.mjs

@@ -43,6 +43,10 @@ function cartesianProduct(...arrList) {
     return res;
 }
 
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
 function chunk(array, size = 2) {
     const res = [];
     if (size < 1 || isNaN(size))
@@ -607,6 +611,201 @@ function format(num, options) {
         return sign + integer;
 }
 
+function lerp(val1, val2, t) {
+    if (isNumber(val1)) {
+        if (!isNumber(val2))
+            throw new Error('Invalid val2 parameter: val2 should be a number');
+        return _lerp(val1, val2, t);
+    }
+    else if (isArray(val1)) {
+        if (!isArray(val2))
+            throw new Error('Invalid val2 parameter: val2 should be an Array');
+        if (val1.length !== val2.length) {
+            throw new Error(`Invalid val2 parameter: the length of val2 (${val2.length}) should be consistent with val1 (${val1.length})`);
+        }
+        if (val1.length === 0)
+            return [];
+        if (isNumber(val1[0])) {
+            if (!isNumber(val2[0]))
+                throw new Error('Invalid val2 parameter: val2 should be an Array<number>');
+            return val1.map((v1, index) => _lerp(v1, val2[index], t));
+        }
+        else if (isArray(val1[0])) {
+            const res = [];
+            for (let i = 0; i < val1.length; i++) {
+                const arr1 = val1[i];
+                const arr2 = val2[i];
+                if (arr1.length !== arr2.length) {
+                    throw new Error(`Invalid val2 parameter: The length of array at index ${i} in val2 (${arr2.length}) must match the length of the corresponding array in val1 (${arr1.length})`);
+                }
+                res.push(arr1.map((v1, index) => _lerp(v1, arr2[index], t)));
+            }
+            return res;
+        }
+    }
+    throw new Error('Invalid val1 parameter: val1 should be a number or Array');
+}
+function _lerp(val1, val2, t) {
+    return val1 + (val2 - val1) * t;
+}
+
+function romanNumerals(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const thousand = (options || {}).thousand || 'normal';
+    const forceSplitThousand = thousand === 'strict';
+    const integer = str.split('.')[0].replace('-', '');
+    if (integer === '0') {
+        const zero = (options || {}).zero || '0';
+        if (type === 'json')
+            return `["${zero}"]`;
+        else
+            return zero;
+    }
+    if (integer === '1') {
+        const one = (options || {}).one || 'I';
+        if (type === 'json')
+            return `["${one}"]`;
+        else
+            return one;
+    }
+    const chunks = chunk(Array.from(integer).reverse(), 3);
+    const romanChunks = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const val = Number(chunks[i].reverse().join(''));
+        if (i === chunks.length - 2 && !forceSplitThousand && Number(chunks[i + 1]) < 4) {
+            romanChunks.push(number2roman(val + Number(chunks[i + 1]) * 1000));
+            break;
+        }
+        else {
+            romanChunks.push(number2roman(val));
+        }
+    }
+    switch (type) {
+        case 'js':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\\\\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'html':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '&#x0305;'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'json':
+            return `[${romanChunks.map((str) => `"${str}"`).join(', ')}]`;
+        case 'unicode':
+        default:
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+    }
+}
+function number2roman(num) {
+    const symbols = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I'],
+    ];
+    let roman = '';
+    for (const [val, str] of symbols) {
+        while (num >= val) {
+            num -= val;
+            roman += str;
+        }
+        if (num == 0)
+            break;
+    }
+    return roman;
+}
+
+function scientificNotation(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const _precision = (options || {}).precision;
+    const precision = isNumber(_precision) ? clamp(_precision !== null && _precision !== void 0 ? _precision : 2, 0, Infinity) : null;
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    let exp = 0;
+    let n = '';
+    if (integer === '0') {
+        exp = /^(0+)/.test(fractional) ? -(fractional.match(/^(0+)/)[0].length + 1) : -1;
+        [integer, fractional] = [fractional.slice(-exp - 1, -exp), fractional.slice(-exp)];
+    }
+    else {
+        exp = integer.length - 1;
+        [integer, fractional] = [integer.slice(0, 1), integer.slice(1) + fractional];
+    }
+    if (isNumber(precision)) {
+        if (fractional.length > precision) {
+            const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+            [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+        }
+        else if (fractional.length < precision) {
+            fractional += '0'.repeat(precision - fractional.length);
+        }
+    }
+    else {
+        fractional = fractional.replace(/0+$/, '');
+    }
+    if ((precision === null && fractional) || (isNumber(precision) && precision > 0)) {
+        n = sign + integer + '.' + fractional;
+    }
+    else
+        n = sign + integer;
+    switch (type) {
+        case 'exp':
+            return `${n}e${exp < 0 ? '' : '+'}${exp}`;
+        case 'js':
+            return `${n}*10**${exp}`;
+        case 'code':
+            return `${n}*10^${exp}`;
+        case 'html':
+            return `${n}&#x00d7;10<sup>${exp}</sup>`;
+        case 'json':
+            return `{"number":"${n}","exp":${exp}}`;
+        case 'unicode':
+        default:
+            return `${n}×10${transferNumberToUniCode(String(exp))}`;
+    }
+}
+function transferNumberToUniCode(n) {
+    const strMap = Object.assign(Object.assign({}, Array.from('⁰¹²³⁴⁵⁶⁷⁸⁹')), { '-': '⁻', '+': '⁺' });
+    return Array.from(n)
+        .map((s) => (strMap[s] ? strMap[s] : s))
+        .join('');
+}
+
 function parallel(args, fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!args.length)
@@ -1238,6 +1437,54 @@ function randomChoice(arr, weights) {
     return arr[index];
 }
 
+function randomDistribution(p, options) {
+    const threshold = (options === null || options === void 0 ? void 0 : options.threshold) ? Math.max(options.threshold, Number.MIN_VALUE * 2) : 5e-6;
+    const C = getInitP(p, threshold);
+    let current = C;
+    return function getRandomDistribution() {
+        const res = Math.random() < current;
+        if (res)
+            current = C;
+        else
+            current += C;
+        return res;
+    };
+}
+function getInitP(targetP, threshold = 5e-6) {
+    if (targetP <= 0)
+        return 0;
+    if (targetP >= 1)
+        return 1;
+    let [down, up] = [0, 1];
+    let mid = 1;
+    let tempP = 1;
+    let tempPLast = 1;
+    let step = 64;
+    while (step-- > 0) {
+        mid = (down + up) / 2;
+        tempP = getRealPFromInitP(mid);
+        if (Math.abs(tempPLast - tempP) < threshold)
+            break;
+        if (tempP > targetP)
+            up = mid;
+        else
+            down = mid;
+    }
+    return mid;
+}
+function getRealPFromInitP(initP) {
+    let sum = 0;
+    let prod = 0;
+    let cur = 0;
+    let max = Math.ceil(1 / initP);
+    for (let n = 1; n <= max; n++) {
+        cur = Math.min(1, n * initP) * (1 - prod);
+        prod += cur;
+        sum += n * cur;
+    }
+    return 1 / sum;
+}
+
 const radix32 = '0123456789abcdefghijklmnopqrstuv';
 const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
 const base32Crockford = '0123456789abcdefghjkmnpqrstvwxyz';
@@ -1864,22 +2111,22 @@ function _deepClone(obj, map, options) {
     if (isFormData(obj))
         return _cloneFormData(obj, map, _deepClone, options);
     let res;
-    if (obj instanceof Date) {
+    if (isDate(obj)) {
         res = new Date(obj.valueOf());
         map.set(obj, res);
     }
-    else if (obj instanceof RegExp) {
+    else if (isRegExp(obj)) {
         res = new RegExp(obj.source, obj.flags);
         map.set(obj, res);
     }
-    else if (obj instanceof ArrayBuffer) {
+    else if (isArrayBuffer(obj)) {
         res = _cloneArrayBuffer(obj, map);
     }
     else if (isTypedArray(obj)) {
         res = new obj.constructor(_cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.length);
         map.set(obj, res);
     }
-    else if (obj instanceof DataView) {
+    else if (isDataView(obj)) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
@@ -2275,4 +2522,4 @@ function throttle(fn, delay, options) {
     return _throttle(fn, delay, Object.assign({ trailing: false, leading: true }, options));
 }
 
-export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isEven, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isOdd, isPlaceholder, isPlainObject, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, round, roundBank, roundBase, roundCeil, roundFloor, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };
+export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, castArray, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getInitP, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isEven, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isOdd, isPlaceholder, isPlainObject, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, lerp, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomDistribution, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, romanNumerals, round, roundBank, roundBase, roundCeil, roundFloor, scientificNotation, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };

package/lib/index.umd.js

@@ -49,6 +49,10 @@ See the Mulan PSL v2 for more details.
       return res;
   }
 
+  function castArray(value) {
+      return Array.isArray(value) ? value.slice() : [value];
+  }
+
   function chunk(array, size = 2) {
       const res = [];
       if (size < 1 || isNaN(size))
@@ -613,6 +617,201 @@ See the Mulan PSL v2 for more details.
           return sign + integer;
   }
 
+  function lerp(val1, val2, t) {
+      if (isNumber(val1)) {
+          if (!isNumber(val2))
+              throw new Error('Invalid val2 parameter: val2 should be a number');
+          return _lerp(val1, val2, t);
+      }
+      else if (isArray(val1)) {
+          if (!isArray(val2))
+              throw new Error('Invalid val2 parameter: val2 should be an Array');
+          if (val1.length !== val2.length) {
+              throw new Error(`Invalid val2 parameter: the length of val2 (${val2.length}) should be consistent with val1 (${val1.length})`);
+          }
+          if (val1.length === 0)
+              return [];
+          if (isNumber(val1[0])) {
+              if (!isNumber(val2[0]))
+                  throw new Error('Invalid val2 parameter: val2 should be an Array<number>');
+              return val1.map((v1, index) => _lerp(v1, val2[index], t));
+          }
+          else if (isArray(val1[0])) {
+              const res = [];
+              for (let i = 0; i < val1.length; i++) {
+                  const arr1 = val1[i];
+                  const arr2 = val2[i];
+                  if (arr1.length !== arr2.length) {
+                      throw new Error(`Invalid val2 parameter: The length of array at index ${i} in val2 (${arr2.length}) must match the length of the corresponding array in val1 (${arr1.length})`);
+                  }
+                  res.push(arr1.map((v1, index) => _lerp(v1, arr2[index], t)));
+              }
+              return res;
+          }
+      }
+      throw new Error('Invalid val1 parameter: val1 should be a number or Array');
+  }
+  function _lerp(val1, val2, t) {
+      return val1 + (val2 - val1) * t;
+  }
+
+  function romanNumerals(num, options) {
+      const str = decimalNotation(num);
+      if (/NaN|Inf/.test(str))
+          return str;
+      const type = (options || {}).type || 'unicode';
+      const thousand = (options || {}).thousand || 'normal';
+      const forceSplitThousand = thousand === 'strict';
+      const integer = str.split('.')[0].replace('-', '');
+      if (integer === '0') {
+          const zero = (options || {}).zero || '0';
+          if (type === 'json')
+              return `["${zero}"]`;
+          else
+              return zero;
+      }
+      if (integer === '1') {
+          const one = (options || {}).one || 'I';
+          if (type === 'json')
+              return `["${one}"]`;
+          else
+              return one;
+      }
+      const chunks = chunk(Array.from(integer).reverse(), 3);
+      const romanChunks = [];
+      for (let i = 0; i < chunks.length; i++) {
+          const val = Number(chunks[i].reverse().join(''));
+          if (i === chunks.length - 2 && !forceSplitThousand && Number(chunks[i + 1]) < 4) {
+              romanChunks.push(number2roman(val + Number(chunks[i + 1]) * 1000));
+              break;
+          }
+          else {
+              romanChunks.push(number2roman(val));
+          }
+      }
+      switch (type) {
+          case 'js':
+              return romanChunks
+                  .map((str, index) => str
+                  .split('')
+                  .map((s) => s + '\\\\u0305'.repeat(index))
+                  .join(''))
+                  .reverse()
+                  .join('');
+          case 'html':
+              return romanChunks
+                  .map((str, index) => str
+                  .split('')
+                  .map((s) => s + '&#x0305;'.repeat(index))
+                  .join(''))
+                  .reverse()
+                  .join('');
+          case 'json':
+              return `[${romanChunks.map((str) => `"${str}"`).join(', ')}]`;
+          case 'unicode':
+          default:
+              return romanChunks
+                  .map((str, index) => str
+                  .split('')
+                  .map((s) => s + '\u0305'.repeat(index))
+                  .join(''))
+                  .reverse()
+                  .join('');
+      }
+  }
+  function number2roman(num) {
+      const symbols = [
+          [1000, 'M'],
+          [900, 'CM'],
+          [500, 'D'],
+          [400, 'CD'],
+          [100, 'C'],
+          [90, 'XC'],
+          [50, 'L'],
+          [40, 'XL'],
+          [10, 'X'],
+          [9, 'IX'],
+          [5, 'V'],
+          [4, 'IV'],
+          [1, 'I'],
+      ];
+      let roman = '';
+      for (const [val, str] of symbols) {
+          while (num >= val) {
+              num -= val;
+              roman += str;
+          }
+          if (num == 0)
+              break;
+      }
+      return roman;
+  }
+
+  function scientificNotation(num, options) {
+      const str = decimalNotation(num);
+      if (/NaN|Inf/.test(str))
+          return str;
+      const type = (options || {}).type || 'unicode';
+      const _precision = (options || {}).precision;
+      const precision = isNumber(_precision) ? clamp(_precision !== null && _precision !== void 0 ? _precision : 2, 0, Infinity) : null;
+      const round = (options || {}).round || 'round';
+      let [integer, fractional] = str.split('.');
+      let sign = '';
+      if (/^-/.test(integer)) {
+          integer = integer.substring(1);
+          sign = '-';
+      }
+      fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+      let exp = 0;
+      let n = '';
+      if (integer === '0') {
+          exp = /^(0+)/.test(fractional) ? -(fractional.match(/^(0+)/)[0].length + 1) : -1;
+          [integer, fractional] = [fractional.slice(-exp - 1, -exp), fractional.slice(-exp)];
+      }
+      else {
+          exp = integer.length - 1;
+          [integer, fractional] = [integer.slice(0, 1), integer.slice(1) + fractional];
+      }
+      if (isNumber(precision)) {
+          if (fractional.length > precision) {
+              const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+              [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+          }
+          else if (fractional.length < precision) {
+              fractional += '0'.repeat(precision - fractional.length);
+          }
+      }
+      else {
+          fractional = fractional.replace(/0+$/, '');
+      }
+      if ((precision === null && fractional) || (isNumber(precision) && precision > 0)) {
+          n = sign + integer + '.' + fractional;
+      }
+      else
+          n = sign + integer;
+      switch (type) {
+          case 'exp':
+              return `${n}e${exp < 0 ? '' : '+'}${exp}`;
+          case 'js':
+              return `${n}*10**${exp}`;
+          case 'code':
+              return `${n}*10^${exp}`;
+          case 'html':
+              return `${n}&#x00d7;10<sup>${exp}</sup>`;
+          case 'json':
+              return `{"number":"${n}","exp":${exp}}`;
+          case 'unicode':
+          default:
+              return `${n}×10${transferNumberToUniCode(String(exp))}`;
+      }
+  }
+  function transferNumberToUniCode(n) {
+      const strMap = Object.assign(Object.assign({}, Array.from('⁰¹²³⁴⁵⁶⁷⁸⁹')), { '-': '⁻', '+': '⁺' });
+      return Array.from(n)
+          .map((s) => (strMap[s] ? strMap[s] : s))
+          .join('');
+  }
+
   function parallel(args, fn, options) {
       return __awaiter(this, void 0, void 0, function* () {
           if (!args.length)
@@ -1244,6 +1443,54 @@ See the Mulan PSL v2 for more details.
       return arr[index];
   }
 
+  function randomDistribution(p, options) {
+      const threshold = (options === null || options === void 0 ? void 0 : options.threshold) ? Math.max(options.threshold, Number.MIN_VALUE * 2) : 5e-6;
+      const C = getInitP(p, threshold);
+      let current = C;
+      return function getRandomDistribution() {
+          const res = Math.random() < current;
+          if (res)
+              current = C;
+          else
+              current += C;
+          return res;
+      };
+  }
+  function getInitP(targetP, threshold = 5e-6) {
+      if (targetP <= 0)
+          return 0;
+      if (targetP >= 1)
+          return 1;
+      let [down, up] = [0, 1];
+      let mid = 1;
+      let tempP = 1;
+      let tempPLast = 1;
+      let step = 64;
+      while (step-- > 0) {
+          mid = (down + up) / 2;
+          tempP = getRealPFromInitP(mid);
+          if (Math.abs(tempPLast - tempP) < threshold)
+              break;
+          if (tempP > targetP)
+              up = mid;
+          else
+              down = mid;
+      }
+      return mid;
+  }
+  function getRealPFromInitP(initP) {
+      let sum = 0;
+      let prod = 0;
+      let cur = 0;
+      let max = Math.ceil(1 / initP);
+      for (let n = 1; n <= max; n++) {
+          cur = Math.min(1, n * initP) * (1 - prod);
+          prod += cur;
+          sum += n * cur;
+      }
+      return 1 / sum;
+  }
+
   const radix32 = '0123456789abcdefghijklmnopqrstuv';
   const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
   const base32Crockford = '0123456789abcdefghjkmnpqrstvwxyz';
@@ -1870,22 +2117,22 @@ See the Mulan PSL v2 for more details.
       if (isFormData(obj))
           return _cloneFormData(obj, map, _deepClone, options);
       let res;
-      if (obj instanceof Date) {
+      if (isDate(obj)) {
           res = new Date(obj.valueOf());
           map.set(obj, res);
       }
-      else if (obj instanceof RegExp) {
+      else if (isRegExp(obj)) {
           res = new RegExp(obj.source, obj.flags);
           map.set(obj, res);
       }
-      else if (obj instanceof ArrayBuffer) {
+      else if (isArrayBuffer(obj)) {
           res = _cloneArrayBuffer(obj, map);
       }
       else if (isTypedArray(obj)) {
           res = new obj.constructor(_cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.length);
           map.set(obj, res);
       }
-      else if (obj instanceof DataView) {
+      else if (isDataView(obj)) {
           res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
           map.set(obj, res);
       }
@@ -2293,6 +2540,7 @@ See the Mulan PSL v2 for more details.
   exports.caseKebab = caseKebab;
   exports.casePascal = casePascal;
   exports.caseSnake = caseSnake;
+  exports.castArray = castArray;
   exports.chunk = chunk;
   exports.clamp = clamp;
   exports.compose = compose;
@@ -2308,6 +2556,7 @@ See the Mulan PSL v2 for more details.
   exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
   exports.getAcceptableMIMEByExt = getAcceptableMIMEByExt;
   exports.getGlobalThis = getGlobalThis;
+  exports.getInitP = getInitP;
   exports.getTag = getTag;
   exports.indent = indent;
   exports.isArray = isArray;
@@ -2364,6 +2613,7 @@ See the Mulan PSL v2 for more details.
   exports.isWrapperString = isWrapperString;
   exports.isWrapperSymbol = isWrapperSymbol;
   exports.kebabCase = kebabCase;
+  exports.lerp = lerp;
   exports.memo = memo;
   exports.noop = noop;
   exports.not = not;
@@ -2374,6 +2624,7 @@ See the Mulan PSL v2 for more details.
   exports.pipe = pipe;
   exports.randomBase32String = randomBase32String;
   exports.randomChoice = randomChoice;
+  exports.randomDistribution = randomDistribution;
   exports.randomHexString = randomHexString;
   exports.randomInt = randomInt;
   exports.randomIntFloor = randomIntFloor;
@@ -2381,11 +2632,13 @@ See the Mulan PSL v2 for more details.
   exports.range = range;
   exports.remove = remove;
   exports.retry = retry;
+  exports.romanNumerals = romanNumerals;
   exports.round = round;
   exports.roundBank = roundBank;
   exports.roundBase = roundBase;
   exports.roundCeil = roundCeil;
   exports.roundFloor = roundFloor;
+  exports.scientificNotation = scientificNotation;
   exports.shuffle = shuffle;
   exports.sleep = sleep;
   exports.snakeCase = snakeCase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foreslash",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Foreslash is a Javascript utilities lib which contains plenty of practical functions.",
   "author": "moushu",
   "license": "Mulan PSL v2",