foreslash 0.3.2 → 0.3.4

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;
@@ -2053,6 +2245,34 @@ declare const noop: (...args: any[]) => void;
  */
 declare function not(value: unknown): boolean;
 
+type KeyOf<T extends object> = object extends T ? keyof any : keyof T;
+type ValueOf<T extends object> = object extends T ? unknown : T[keyof T];
+type PickPredicate<T extends object> = (value: ValueOf<T>, key: KeyOf<T>, obj: T) => any;
+type OmitPredicate<T extends object> = (value: ValueOf<T>, key: KeyOf<T>, obj: T) => any;
+
+/**
+ * 给定一个对象和对象中键的列表, 返回一个**排除**给定键的新对象(是传入对象的浅拷贝)\
+ * 如果你希望深拷贝一个对象, 请使用 `deepClone` 或 `fastClone`
+ * @param obj 需要处理的对象
+ * @param keys 需要**排除**的键, 可以是一个数组、字符串或谓词函数
+ * @returns 传入对象的浅拷贝, 与传入对象不同的是新对象**排除了**指定的键
+ * @example
+ * ```ts
+ * omit({ a: 1, b: 2, c: '' }, ['a', 'c']) // { b: 2 }
+ * omit({ a: 1, b: 2, c: '' }, 'b') // { a: 1, c: '' }
+ * // 谓词函数
+ * omit({ a: 1, b: 2, c: '' }, (value, key) => value === 2 || key === 'c') // { a: 1 }
+ * // 需要注意的是传入谓词函数时可能会有类型不匹配的问题
+ * // Typescript 无法得知最终过滤的结果, 而是认为过滤结果与原类型一致
+ * const obj = omit({ a: 1, b: 2 }, (value, key) => value === 2) // { a: 1 }
+ * type typeofObj = typeof obj // { a: number; b: number } <- Typescript 没有推导出正确结果
+ * ```
+ * @version 0.3.4
+ */
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+declare function omit<T extends object, K extends keyof T>(obj: T, keys: OmitPredicate<T>): T;
+declare function omit<T extends object, K extends keyof T>(obj: T, key: K): Omit<T, K>;
+
 /**
  * 不做任何操作，返回第一个参数，一般用于函数式编程
  * @param value 任意值
@@ -2081,6 +2301,29 @@ declare function pass(): undefined;
  */
 declare function passWith<T>(fn: (arg: T) => any): typeof pass;
 
+/**
+ * 给定一个对象和对象中键的列表, 返回一个**只包含**给定键的新对象(是传入对象的浅拷贝)\
+ * 如果你希望深拷贝一个对象, 请使用 `deepClone` 或 `fastClone`
+ * @param obj 需要处理的对象
+ * @param keys 需要**取出**的键, 可以是一个数组、字符串或谓词函数
+ * @returns 传入对象的浅拷贝, 与传入对象不同的是新对象仅包含指定的键
+ * @example
+ * ```ts
+ * pick({ a: 1, b: 2, c: '' }, ['a', 'c']) // { a: 1, c: '' }
+ * pick({ a: 1, b: 2, c: '' }, 'b') // { b: 2 }
+ * // 谓词函数
+ * pick({ a: 1, b: 2, c: '' }, (value, key) => value === 2 || key === 'c') // { b: 2, c: '' }
+ * // 需要注意的是传入谓词函数时可能会有类型不匹配的问题
+ * // Typescript 无法得知最终过滤的结果, 而是认为过滤结果与原类型一致
+ * const obj = pick({ a: 1, b: 2 }, (value, key) => value === 2) // { b: 2 }
+ * type typeofObj = typeof obj // { a: number; b: number } <- Typescript 没有推导出正确结果
+ * ```
+ * @version 0.3.4
+ */
+declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function pick<T extends object, K extends keyof T>(obj: T, keys: PickPredicate<T>): T;
+declare function pick<T extends object, K extends keyof T>(obj: T, key: K): Pick<T, K>;
+
 // pipe
 type PipeFuncList1<PipeArgs extends any[], PipeResult> = [(...args: PipeArgs) => PipeResult]
 type PipeFuncList2<PipeArgs extends any[], PipeResult, Mid1 = any> = [
@@ -2216,5 +2459,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, omit, parallel, pascalCase, pass, passWith, pick, 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 };