@mudbean/utils 2.0.5

package/es/className.js

@@ -0,0 +1,52 @@
+/**
+ * 驼峰命名与连字符命名法的互换
+ */
+/**
+ * # 连字符连接转化为小/大驼峰命名法
+ *
+ * @param str    待转化文本
+ * @param dividingType   连字符，缺省值为 "-"
+ * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
+ * @returns 驼峰命名法字符串（e.g. “helloWorld”）
+ */
+function toLowerCamelCase(
+/**  待转化文本  */
+str, 
+/**  连字符，缺省值为 "-"  */
+dividingType = '-', 
+/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
+initial = false) {
+    let result = str;
+    /**
+     * 匹配规则
+     *
+     * - 匹配到分隔符，将分隔符后面的字符转化为大写
+     */
+    const template = /[\\]|[\^]|[?]|[-]|[.]|[(]|[)]|[|]|[[]\[\]]|[{]|[}]|[+]|[*]|[$]/;
+    /**
+     *  转化首字符
+     * @param _str
+     * @param _dividingType
+     */
+    const toTransform = (_str, _dividingType) => _str.replace(new RegExp(`${template.test(_dividingType) ? `\\${_dividingType}` : _dividingType}([a-zA-Z])`, 'g'), (match, p1) => p1.toUpperCase());
+    // 多分隔符转化
+    dividingType
+        .split('')
+        .forEach((item) => (result = toTransform(result, item)));
+    return initial
+        ? result.replace(/^./, (match) => match.toUpperCase())
+        : result;
+}
+/**
+ * # 驼峰命名法转化为连字符连接
+ *
+ * @param str          待转化文本
+ * @param dividingType       分割符
+ * @returns 分割符转化的文本 (e.g. 'hello-world')
+ */
+function toSplitCase(str, dividingType = '-') {
+    const result = str.replace(/[A-Z]/g, (match) => dividingType.concat(match.toLowerCase()));
+    return result.startsWith(dividingType) ? result.substring(1) : result;
+}
+
+export { toLowerCamelCase, toSplitCase };

package/es/createBezier.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @file createBezier.ts
+ * @description 生成贝尔赛曲线
+ * @author Mr.MudBean <Mr.MudBean@outlook.com>
+ * @copyright 2026 ©️ Mr.MudBean
+ * @since 2026-03-26 11:24
+ * @version 2.0.2
+ * @lastModified 2026-06-11 19:07
+ *
+ * ## [贝尔赛曲线](https://developer.mozilla.org/zh-CN/docs/Web/CSS/Reference/Values/easing-function#%E4%B8%89%E6%AC%A1%E8%B4%9D%E5%A1%9E%E5%B0%94%E7%BC%93%E5%8A%A8%E5%87%BD%E6%95%B0)
+ *
+ * 一种通过控制点生成光滑曲线的数学参数曲线，是平滑插值曲线。
+ *
+ * 广泛应用于计算机图像学、字体设计、动画游戏开发、工业设计和医学图像处理。
+ *
+ * 常见的贝尔赛曲线类型有二次和三次，其中三次贝尔赛曲线使用最多。曲线具有端点插值、凸包性。
+ *
+ */
+/**
+ * # 在 JS 中模拟 CSS cubic-bezier(p1x, p1y, p2x, p2y)
+ *
+ * @param p1x - 第一个控制点 X
+ * @param p1y - 第一个控制点 Y
+ * @param p2x - 第二个控制点 X
+ * @param p2y - 第二个控制点 Y
+ * @returns 一个接收时间 t (0-1) 返回进度值 (0-1 或超出) 的函数
+ * @example
+ * ```ts
+ * // --- 使用示例 ---
+ *
+ * // 1. 定义一个类似 CSS 'ease-in-out' 的曲线: cubic-bezier(0.42, 0, 0.58, 1)
+ * const myEaseInOut = createBezier(0.42, 0, 0.58, 1);
+ *
+ * // 2. 定义一个带回弹效果的曲线: cubic-bezier(0.68, -0.55, 0.27, 1.55)
+ * const myElastic = createBezier(0.68, -0.55, 0.27, 1.55);
+ *
+ * // 3. 在 JS 动画循环中使用
+ * let startTime = null;
+ * const duration = 1000; // 1秒
+ * const element = document.getElementById('box');
+ *
+ * function animate(timestamp) {
+ *   if (!startTime) startTime = timestamp;
+ *   const elapsed = timestamp - startTime;
+ *
+ *   // 计算归一化时间 (0 到 1)
+ *   let rawTime = Math.min(elapsed / duration, 1);
+ *
+ *   // 【关键点】将线性时间 rawTime 传入贝塞尔函数，得到非线性进度
+ *   const progress = myElastic(rawTime);
+ *
+ *   // 应用进度 (例如移动距离)
+ *   const distance = 300 * progress;
+ *   element.style.transform = `translateX(${distance}px)`;
+ *
+ *   if (elapsed < duration) {
+ *     requestAnimationFrame(animate);
+ *   }
+ * }
+ *
+ * requestAnimationFrame(animate);
+ * ```
+ */
+export declare function createBezier(p1x: number, p1y: number, p2x: number, p2y: number): (t: number) => number;

package/es/createBezier.js

@@ -0,0 +1,133 @@
+/**
+ * @file createBezier.ts
+ * @description 生成贝尔赛曲线
+ * @author Mr.MudBean <Mr.MudBean@outlook.com>
+ * @copyright 2026 ©️ Mr.MudBean
+ * @since 2026-03-26 11:24
+ * @version 2.0.2
+ * @lastModified 2026-06-11 19:07
+ *
+ * ## [贝尔赛曲线](https://developer.mozilla.org/zh-CN/docs/Web/CSS/Reference/Values/easing-function#%E4%B8%89%E6%AC%A1%E8%B4%9D%E5%A1%9E%E5%B0%94%E7%BC%93%E5%8A%A8%E5%87%BD%E6%95%B0)
+ *
+ * 一种通过控制点生成光滑曲线的数学参数曲线，是平滑插值曲线。
+ *
+ * 广泛应用于计算机图像学、字体设计、动画游戏开发、工业设计和医学图像处理。
+ *
+ * 常见的贝尔赛曲线类型有二次和三次，其中三次贝尔赛曲线使用最多。曲线具有端点插值、凸包性。
+ *
+ */
+/**
+ * # 在 JS 中模拟 CSS cubic-bezier(p1x, p1y, p2x, p2y)
+ *
+ * @param p1x - 第一个控制点 X
+ * @param p1y - 第一个控制点 Y
+ * @param p2x - 第二个控制点 X
+ * @param p2y - 第二个控制点 Y
+ * @returns 一个接收时间 t (0-1) 返回进度值 (0-1 或超出) 的函数
+ * @example
+ * ```ts
+ * // --- 使用示例 ---
+ *
+ * // 1. 定义一个类似 CSS 'ease-in-out' 的曲线: cubic-bezier(0.42, 0, 0.58, 1)
+ * const myEaseInOut = createBezier(0.42, 0, 0.58, 1);
+ *
+ * // 2. 定义一个带回弹效果的曲线: cubic-bezier(0.68, -0.55, 0.27, 1.55)
+ * const myElastic = createBezier(0.68, -0.55, 0.27, 1.55);
+ *
+ * // 3. 在 JS 动画循环中使用
+ * let startTime = null;
+ * const duration = 1000; // 1秒
+ * const element = document.getElementById('box');
+ *
+ * function animate(timestamp) {
+ *   if (!startTime) startTime = timestamp;
+ *   const elapsed = timestamp - startTime;
+ *
+ *   // 计算归一化时间 (0 到 1)
+ *   let rawTime = Math.min(elapsed / duration, 1);
+ *
+ *   // 【关键点】将线性时间 rawTime 传入贝塞尔函数，得到非线性进度
+ *   const progress = myElastic(rawTime);
+ *
+ *   // 应用进度 (例如移动距离)
+ *   const distance = 300 * progress;
+ *   element.style.transform = `translateX(${distance}px)`;
+ *
+ *   if (elapsed < duration) {
+ *     requestAnimationFrame(animate);
+ *   }
+ * }
+ *
+ * requestAnimationFrame(animate);
+ * ```
+ */
+function createBezier(p1x, p1y, p2x, p2y) {
+    // 三次贝塞尔曲线公式: B(t) = (1-t)^3 * P0 + 3(1-t)^2*t * P1 + 3(1-t)*t^2 * P2 + t^3 * P3
+    // 这里 P0=(0,0), P3=(1,1)
+    const cx = 3 * p1x;
+    const bx = 3 * (p2x - p1x) - cx;
+    const ax = 1 - cx - bx;
+    const cy = 3 * p1y;
+    const by = 3 * (p2y - p1y) - cy;
+    const ay = 1 - cy - by;
+    // 计算给定 t 的 x 值
+    /**
+     * @param t
+     */
+    function sampleCurveX(t) {
+        return ((ax * t + bx) * t + cx) * t;
+    }
+    /**
+     * ### 计算给定 t 的 y 值
+     * @param t 时间进度
+     */
+    function sampleCurveY(t) {
+        return ((ay * t + by) * t + cy) * t;
+    }
+    /**
+     * ### 核心难点：已知 x (时间)，求 t。因为 x(t) 是单调的，可以用牛顿迭代法求解
+     * @param x 时间进度
+     */
+    function getTForX(x) {
+        let t0, t1, t2, x2, d2;
+        // 初始猜测
+        t2 = x;
+        // 牛顿迭代法 (通常 8 次足够精确)
+        for (let i = 0; i < 8; i++) {
+            x2 = sampleCurveX(t2) - x;
+            if (Math.abs(x2) < 1e-6)
+                return t2;
+            d2 = (3 * ax * t2 + 2 * bx) * t2 + cx;
+            if (Math.abs(d2) < 1e-6)
+                break;
+            t2 = t2 - x2 / d2;
+        }
+        // 如果牛顿法失败，退化为二分法
+        t0 = 0;
+        t1 = 1;
+        t2 = x;
+        while (t0 < t1) {
+            x2 = sampleCurveX(t2);
+            if (Math.abs(x2 - x) < 1e-6)
+                return t2;
+            if (x > x2)
+                t0 = t2;
+            else
+                t1 = t2;
+            t2 = (t1 - t0) * 0.5 + t0;
+        }
+        return t2;
+    }
+    // 返回最终的计算函数
+    return function (t) {
+        // 边界处理：CSS 允许 t < 0 或 t > 1 (产生回弹效果)
+        if (t <= 0)
+            return sampleCurveY(0);
+        if (t >= 1)
+            return sampleCurveY(1);
+        const realT = getTForX(t);
+        return sampleCurveY(realT);
+    };
+}
+
+export { createBezier };

package/es/getRandomNumber.d.ts

@@ -0,0 +1,24 @@
+/**
+ * # 获取一个随机的整数类型
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
+ *
+ * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
+ *
+ * @param   max 较大值 ，不允许为`NaN`
+ * @param   min 较小值，不允许为 `NaN`
+ * @returns  任意的整数
+ */
+export declare function getRandomInt(max?: number, min?: number): number;
+/**
+ * # 获取任意的浮点数
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字
+ *
+ * 如果只传入一个参数，则如果提供的值为负数，则获取小于（或大于）该数字的浮点数
+ *
+ * @param   max 较大数，缺省值为 1
+ * @param min 较小值，缺省值为 0
+ * @returns  任意的浮点数
+ */
+export declare function getRandomFloat(max?: number, min?: number): number;

package/es/getRandomNumber.js

@@ -0,0 +1,67 @@
+import { isNaN, isNumber } from '@mudbean/is';
+
+/**
+ * 获取随机数
+ */
+/**
+ * # 获取一个随机的整数类型
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
+ *
+ * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
+ *
+ * @param   max 较大值 ，不允许为`NaN`
+ * @param   min 较小值，不允许为 `NaN`
+ * @returns  任意的整数
+ */
+function getRandomInt(max = 1, min = 0) {
+    //  判断是否为 NaN 或 不是数字
+    if (!isFinite(max) ||
+        !isFinite(min) ||
+        isNaN(max) ||
+        isNaN(min) ||
+        !isNumber(max) ||
+        !isNumber(min)) {
+        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
+    }
+    /**  获取最小值  */
+    let _min = Math.ceil(Number(min)), 
+    /**  获取最大值  */
+    _max = Math.floor(Number(max));
+    //  两值相等时，直接返回最大值
+    if (_max === _min)
+        return _max;
+    //  两值交换
+    if (_min > _max)
+        [_max, _min] = [_min, _max];
+    return Math.round(Math.random() * (_max - _min) + _min);
+}
+/**
+ * # 获取任意的浮点数
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字
+ *
+ * 如果只传入一个参数，则如果提供的值为负数，则获取小于（或大于）该数字的浮点数
+ *
+ * @param   max 较大数，缺省值为 1
+ * @param min 较小值，缺省值为 0
+ * @returns  任意的浮点数
+ */
+function getRandomFloat(max = 1, min = 0) {
+    //  判断是否为 NaN 或 不是数字
+    if (!isFinite(max) ||
+        !isFinite(min) ||
+        isNaN(max) ||
+        isNaN(min) ||
+        !isNumber(max) ||
+        !isNumber(min)) {
+        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
+    }
+    if (max == min)
+        max++;
+    if (min > max)
+        [max, min] = [min, max];
+    return Math.random() * (max - min) + min;
+}
+
+export { getRandomFloat, getRandomInt };

package/es/getRandomString.d.ts

@@ -0,0 +1,73 @@
+/**
+ * # 随机字符串生成器
+ */
+export type RandomStringOptions = {
+    /**
+     * 字符串长度
+     *
+     * @default 32
+     */
+    length?: number;
+    /**
+     *  字符集
+     * @default '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+     */
+    chars?: string;
+    /**
+     *  是否包含数字
+     *
+     * @default false
+     */
+    includeNumbers?: boolean;
+    /**
+     *  是否包含大写字母
+     *
+     * @default false
+     */
+    includeUppercaseLetters?: boolean;
+    /**
+     * 是否包含特殊字符
+     *
+     * @default false
+     */
+    includeSpecial?: boolean;
+    /**
+     * 字符类型
+     *
+     * 缺省值为 'string'，可选为 'uuid'
+     *
+     * @default 'string''
+     */
+    type?: 'string' | 'uuid';
+};
+/**
+ * # 获取简单的随机字符串
+ *
+ * ```ts
+ * type RandomStringOptions = {
+ *     length?: number; // 字符串长度
+ *     chars?: string;  // 包含英文字符
+ *     includeNumbers?: boolean; // 包含数字
+ *     includeUppercaseLetters?: boolean; // 包含大写字符
+ *     includeSpecial?: boolean; // 包含特殊字符
+ *     type?: 'string' | 'uuid'; // 生成类型
+ * }
+ * ```
+ *
+ * @param  options - 字符串生成参数
+ * @returns  - 随机字符串
+ * @example
+ * ```ts
+ * import { getRandomString } from '@mudbean/utils';
+ *
+ * // 获取简单的随机字符串
+ * // 'abcdefg'
+ * getRandomString(7);
+ *
+ * // 获取随机的字符串
+ * getRandomString({
+ *    length: 7,
+ * })
+ * ```
+ */
+export declare function getRandomString(options?: RandomStringOptions | number): string;

package/es/getRandomString.js

@@ -0,0 +1,141 @@
+import { isPlainObject, isNumber, isNaN, isUndefined } from '@mudbean/is';
+import { ObjectAssign } from './object/createConstructor.js';
+import { getRandomInt } from './getRandomNumber.js';
+
+/**
+ * 获取随机字符串
+ */
+/**
+ * # 获取简单的随机字符串
+ *
+ * ```ts
+ * type RandomStringOptions = {
+ *     length?: number; // 字符串长度
+ *     chars?: string;  // 包含英文字符
+ *     includeNumbers?: boolean; // 包含数字
+ *     includeUppercaseLetters?: boolean; // 包含大写字符
+ *     includeSpecial?: boolean; // 包含特殊字符
+ *     type?: 'string' | 'uuid'; // 生成类型
+ * }
+ * ```
+ *
+ * @param  options - 字符串生成参数
+ * @returns  - 随机字符串
+ * @example
+ * ```ts
+ * import { getRandomString } from '@mudbean/utils';
+ *
+ * // 获取简单的随机字符串
+ * // 'abcdefg'
+ * getRandomString(7);
+ *
+ * // 获取随机的字符串
+ * getRandomString({
+ *    length: 7,
+ * })
+ * ```
+ */
+function getRandomString(options) {
+    //   验证输入参数
+    if (
+    // 参数类型错误
+    (!isPlainObject(options) && !isNumber(options)) ||
+        // 参数为 NaN
+        (isNumber(options) && isNaN(options)) ||
+        // 参数为数字时为无穷大
+        (isNumber(options) && !isFinite(options)) ||
+        // 参数为数字时为非整数
+        (isNumber(options) && !Number.isInteger(options)) ||
+        // 参数为数字时为负数
+        (isNumber(options) && Number.isInteger(options) && options < 1) ||
+        // 参数为数值然而却小于 1
+        (isNumber(options) && options < 1) ||
+        // 参数为对象但是 length 属性非数值
+        (isPlainObject(options) &&
+            (!isNumber(options.length) ||
+                options.length < 1 ||
+                !Number.isInteger(options.length))))
+        throw new TypeError('参数类型错误 ❌ (getRandomString)');
+    const initOptions = {
+        length: 32,
+        chars: 'abcdefghijklmnopqrstuvwxyz',
+        chars2: '0123456789',
+        chars3: '!@#$%^&*()_+~`|}{[]:;?><,./-=',
+        type: 'string',
+        includeUppercaseLetters: false,
+        includeNumbers: false,
+        includeSpecial: false,
+    };
+    /// 生成 UUID
+    if (initOptions.type === 'uuid')
+        return crypto.randomUUID();
+    // 验证输入参数
+    if (isNumber(options) && Number.isInteger(options) && options > 0)
+        ObjectAssign(initOptions, { length: options });
+    if (isPlainObject(options)) {
+        ObjectAssign(initOptions, options);
+        initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
+    }
+    /**  生成随机字符串  */
+    const templateCharsArr = initOptions.chars.split('');
+    // 添加大写字母
+    if (initOptions.includeUppercaseLetters)
+        interleaveString(templateCharsArr, initOptions.chars.toUpperCase());
+    // 添加数字
+    if (initOptions.includeNumbers)
+        interleaveString(templateCharsArr, initOptions.chars2);
+    // 添加特殊字符
+    if (initOptions.includeSpecial)
+        interleaveString(templateCharsArr, initOptions.chars3);
+    /** 结果字符串 */
+    let result = '';
+    /** 混淆后的字符串 */
+    const str = templateCharsArr.join('');
+    /** 混淆后字符长度 */
+    const strLen = str.length;
+    if (globalThis && globalThis.crypto && globalThis.crypto.getRandomValues) {
+        // 使用密码学安全的随机数生成器
+        const bytes = globalThis.crypto.getRandomValues(new Uint8Array(initOptions.length));
+        /**  获取最后的 chars 数据  */
+        // 循环遍历
+        bytes.forEach(byte => (result += str[byte % strLen]));
+    }
+    else {
+        for (let i = 0; i < initOptions.length; i++)
+            result += str[getRandomInt(strLen - 1)];
+    }
+    /**
+     * # 字符串交叉函数
+     *
+     * 非线形串交叉，对相交叉
+     *
+     * @param  str1 - 字符串1
+     * @param  str2 - 字符串2
+     * @returns - 交叉后的字符串
+     * @example
+     *
+     * ```ts
+     * interleaveString('abc', '123') // 'a1b2c3'
+     * ```
+     */
+    function interleaveString(str1, str2) {
+        const str1Length = str1.length, str2Length = str2.length;
+        const maxLength = Math.max(str1Length, str2Length);
+        for (let i = 0; i < maxLength; i++) {
+            if (i < str1Length && !isUndefined(str2[i])) {
+                str1[i] += str2[i];
+            }
+            else if (i < str2Length) {
+                str1[i] = str2[i];
+            }
+        }
+    }
+    /// 结果字符串不包含字符
+    if (!/[a-zA-Z]/.test(result))
+        return String.fromCharCode(getRandomInt(97, 122)).concat(result.slice(1));
+    while (!/^[a-zA-Z]$/.test(result[0]))
+        result = result.slice(1) + result[0];
+    return result;
+}
+
+export { getRandomString };

package/es/index.d.ts

@@ -0,0 +1,12 @@
+export { toLowerCamelCase, toSplitCase } from './className';
+export type { CreateConstructor } from './object/createConstructor';
+export { createConstructor, ObjectAssign } from './object/createConstructor';
+export { getRandomFloat, getRandomInt } from './getRandomNumber';
+export { getRandomString } from './getRandomString';
+export { throttle, debounce } from './performance';
+export type { DebounceAndThrottleReturnType, debounce_throttle_options, } from './performance';
+export { escapeRegExp, autoEscapedRegExp } from './regexp';
+export { isBrowser, isNode } from './isNode';
+export { intersection, enArr, union, difference, symmetricDifference, } from './array';
+export { sleep } from './sleep';
+export { createBezier } from './createBezier';

package/es/index.js

@@ -0,0 +1,15 @@
+export { toLowerCamelCase, toSplitCase } from './className.js';
+export { ObjectAssign, createConstructor } from './object/createConstructor.js';
+export { getRandomFloat, getRandomInt } from './getRandomNumber.js';
+export { getRandomString } from './getRandomString.js';
+export { debounce, throttle } from './performance.js';
+export { escapeRegExp } from './regexp/escapeRegExp.js';
+export { autoEscapedRegExp } from './regexp/autoEscapedRegExp.js';
+export { isBrowser, isNode } from './isNode.js';
+export { enArr } from './array/index.js';
+export { sleep } from './sleep.js';
+export { createBezier } from './createBezier.js';
+export { difference } from './array/difference.js';
+export { intersection } from './array/intersection.js';
+export { symmetricDifference } from './array/symmetricDifference.js';
+export { union } from './array/union.js';

package/es/isNode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * # 判断当前环境是否为 node 环境
+ */
+export declare function isNode(): boolean;
+/**
+ * # 是否为浏览器环境
+ */
+export declare function isBrowser(): boolean;

package/es/isNode.js

@@ -0,0 +1,20 @@
+import { isUndefined } from '@mudbean/is';
+
+/**
+ * # 判断当前环境是否为 node 环境
+ */
+function isNode() {
+    return !isUndefined((globalThis &&
+        globalThis.process &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node) ||
+        undefined);
+}
+/**
+ * # 是否为浏览器环境
+ */
+function isBrowser() {
+    return !isNode();
+}
+
+export { isBrowser, isNode };

package/es/object/createConstructor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 构建构建的构建函数
+ */
+export interface CreateConstructor<T, Args extends unknown[] = unknown[]> {
+    new (...args: Args): T;
+}
+/**
+ * # 构建一个 Constructor 构造函数
+ *
+ * 接收一个构造函数，然后返回 TS 能识别的构造函数自身
+ *
+ * 函数本身并没有执行任何逻辑，仅是简单的返回了实参自身
+ *
+ * 而经过该函数的包装，构造函数成了能够被 TS 识别为可用 new 实例的构造函数
+ *
+ * @param constructor - 传入一个构造函数
+ * @returns 返回传入的构造函数
+ * @example
+ * ```ts
+ * import { createConstructor } from "@mudbean/utils";
+ *
+ * type Tom = {
+ *   a: number
+ * }
+ *
+ * function _Tom (this: TomType): Tom {
+ *    this.a = 1;
+ *
+ *    return this;
+ * }
+ *
+ * // 逻辑上没有错，但是会造成 ts 显示
+ * // 其目标缺少构造签名的 "new" 表达式隐式具有 "any" 类型。ts(7009)
+ * const a = new _Tom();
+ *
+ * const tomConstructor = createConstructor(_tom);
+ *
+ * const b = new tomConstructor(); // 这时就不会显示错误
+ * ```
+ */
+export declare function createConstructor<T, Args extends unknown[] = unknown[]>(constructor: (...argumentList: Args) => T): CreateConstructor<T, Args>;
+/**
+ * # 对象的 assign 用法
+ * @param target
+ * @param bar
+ */
+export declare function ObjectAssign(target: Record<string, unknown>, bar: Record<string, unknown>): Record<string, unknown>;