a-js-tools 1.0.13-beta.5 → 2.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) <2024> <earthnut.dev>
+Copyright (c) <2024> <Mr.MudBean>
     
 Permission to use, copy, modify, and/or distribute this software for any  
 purpose with or without fee is hereby granted, provided that the above  
@@ -16,7 +16,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 # MIT 许可证
 
-版权所有 (c) [2024] [花生亻]
+版权所有 (c) [2024] [泥豆君]
 
 特此免费授予任何获得本软件及相关文档文件（以下简称“软件”）副本的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、再许可和/或出售该软件副本的权利，并允许向其提供该软件的人这样做，但须遵守以下条件：
 

package/README.md

@@ -1,6 +1,6 @@
 # 一点点 🤏 js 函数
 
-[![version](<https://img.shields.io/npm/v/a-js-tools.svg?logo=npm&logoColor=rgb(0,0,0)&label=版本号&labelColor=rgb(73,73,228)&color=rgb(0,0,0)>)](https://www.npmjs.com/package/a-js-tools) [![issues 提交](<https://img.shields.io/badge/issues-提交-rgb(255,0,63)?logo=github>)](https://github.com/earthnutDev/a-js-tools/issues)
+[![version](<https://img.shields.io/npm/v/a-js-tools.svg?logo=npm&logoColor=rgb(0,0,0)&label=版本号&labelColor=rgb(73,73,228)&color=rgb(0,0,0)>)](https://www.npmjs.com/package/a-js-tools) [![issues 提交](<https://img.shields.io/badge/issues-提交-rgb(255,0,63)?logo=github>)](https://github.com/MrMudBean/a-js-tools/issues)
 一个纯函数的工具
 
 ## 安装

package/cjs/array/difference.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *  求给出的两个数组的差值（A - B）
+ *
+ * @param a  - 第一个数组
+ * @param b - 第二个数组
+ * @throws {TypeError} 当两个参数有一个不是
+ * @description 当两个参数有一个不是数组时将抛出
+ * @returns 返回第一个参数相对第二个参数的差值
+ * @example
+ *
+ * ```ts
+ * import { difference} from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ *
+ * log(difference([], [1, 2, 3])); // []
+ *
+ * log([1, 2, 3], []); //[1, 2, 3]
+ *
+ * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+ *
+ * // 将抛出 TypeError
+ * log(difference([1, 2, 3], 'a'));
+ * log(difference([1, 2, 3], 1));
+ * log(difference([1, 2, 3], undefined));
+ * log(difference([1, 2, 3], null));
+ * log(difference([1, 2, 3],  true));
+ * ```
+ *
+ */
+function difference(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {
+        throw new TypeError('参数需为数组');
+    }
+    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.isEmptyArray(b)) {
+        return a;
+    }
+    /**  获取两个数组中长度较小的  */
+    // 参数有顺序要求
+    // const [shorter, longer] = a.length > b.length ? [b, a] : [a, b];
+    // const shorterSet = new Set(shorter);
+    const bSet = new Set(b);
+    return a.filter(i => !bSet.has(i));
+}
+
+exports.difference = difference;

package/cjs/array/index.js

@@ -0,0 +1,154 @@
+'use strict';
+
+var intersection = require('./intersection.js');
+var union = require('./union.js');
+var difference = require('./difference.js');
+var symmetricDifference = require('./symmetricDifference.js');
+
+/**
+ *
+ * 数组的一些方法
+ *
+ * - union 两个数组的并集（排除共有项）
+ * - intersection 两个数组的交集（共有项）
+ * - difference 两个数组的差集 （A - B）
+ * - symmetricDifference  对称差集 （ A △ B）
+ *
+ */
+const enArr = {
+    /**
+     *
+     * 数组的并集
+     *
+     *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+     * @param arrays  - 多个数组
+     * @returns 联合后的数组
+     *
+     *
+     * @example
+     *
+     * ```ts
+     * import { union } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     * // []
+     * log(union());
+     *
+     * // [1, 2, 3]
+     * log(union([1, 2, 3]));
+     *
+     * //  TypeError
+     * log(union([1, 2, 3], 'i'));
+     * log(union([1, 2, 3], undefined));
+     * log(union([1, 2, 3], null));
+     * log(union([1, 2, 3], 4));
+     * log(union([1, 2, 3], {}));
+     * log(union([1, 2, 3], false));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+     * ```
+     *
+     */
+    union: union.union,
+    /**
+     *
+     * 两个数组的交集
+     *
+     * @param a 数组 1️⃣
+     * @param b 数组 2️⃣
+     * @returns 返回两个数组的交集
+     * @example
+     *
+     * ```ts
+     * import { intersection } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     *
+     * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
+     * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
+     *
+     * ```
+     *
+     */
+    intersection: intersection.intersection,
+    /**
+     *  求给出的两个数组的差值（A - B）
+     *
+     * @param a  - 第一个数组
+     * @param b - 第二个数组
+     * @throws {TypeError} 当两个参数有一个不是
+     * @description 当两个参数有一个不是数组时将抛出
+     * @returns 返回第一个参数相对第二个参数的差值
+     * @example
+     *
+     * ```ts
+     * import { difference} from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     *
+     * log(difference([], [1, 2, 3])); // []
+     *
+     * log([1, 2, 3], []); //[1, 2, 3]
+     *
+     * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+     *
+     * // 将抛出 TypeError
+     * log(difference([1, 2, 3], 'a'));
+     * log(difference([1, 2, 3], 1));
+     * log(difference([1, 2, 3], undefined));
+     * log(difference([1, 2, 3], null));
+     * log(difference([1, 2, 3],  true));
+     * ```
+     *
+     */
+    difference: difference.difference,
+    /**
+     *
+     * 对称差集 （ A △ B）
+     *
+     * @param a  - 数组 a
+     * @param b  - 数组 b
+     * @returns - 返回一个全新的数组
+     *
+     * @example
+     *
+     * ```ts
+     * import { symmetricDifference } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
+     *
+     *
+     * /// TypeError
+     * log(symmetricDifference(1, []));
+     * log(symmetricDifference(undefined, []));
+     * log(symmetricDifference(null, []));
+     * log(symmetricDifference('a', []));
+     * log(symmetricDifference(true, []));
+     *
+     * ```
+     *
+     */
+    symmetricDifference: symmetricDifference.symmetricDifference,
+};
+
+exports.intersection = intersection.intersection;
+exports.union = union.union;
+exports.difference = difference.difference;
+exports.symmetricDifference = symmetricDifference.symmetricDifference;
+exports.enArr = enArr;

package/cjs/array/intersection.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *
+ * 两个数组的交集
+ *
+ * @param a 数组 1️⃣
+ * @param b 数组 2️⃣
+ * @returns 返回两个数组的交集
+ * @example
+ *
+ * ```ts
+ * import { intersection } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ *
+ * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
+ * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
+ *
+ * ```
+ *
+ */
+function intersection(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {
+        throw new TypeError('参数必须是数组类型数据');
+    }
+    // 任意数组为空，则返回空数组
+    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.isEmptyArray(b)) {
+        return [];
+    }
+    /**
+     * 在实际运算中， new Set() 的 开销为 O(n) ,filter 的开销也为 O(n)
+     *
+     * 但是以较短的数组创建 Set ，可以节省内存开销
+     */
+    const [shorter, longer] = a.length <= b.length ? [a, b] : [b, a];
+    // 提前创建工具 Set
+    const shortSet = new Set(shorter);
+    return longer.filter(item => shortSet.has(item));
+}
+
+exports.intersection = intersection;

package/cjs/array/symmetricDifference.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+var difference = require('./difference.js');
+
+/**
+ *
+ * 对称差集 （ A △ B）
+ *
+ * @param a  - 数组 a
+ * @param b  - 数组 b
+ * @returns - 返回一个全新的数组
+ *
+ * @example
+ *
+ * ```ts
+ * import { symmetricDifference } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
+ *
+ *
+ * /// TypeError
+ * log(symmetricDifference(1, []));
+ * log(symmetricDifference(undefined, []));
+ * log(symmetricDifference(null, []));
+ * log(symmetricDifference('a', []));
+ * log(symmetricDifference(true, []));
+ *
+ * ```
+ *
+ */
+function symmetricDifference(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {
+        throw new TypeError('参数必须是数组');
+    }
+    if (aTypeOfJs.isEmptyArray(a)) {
+        return [...b];
+    }
+    if (aTypeOfJs.isEmptyArray(b)) {
+        return [...a];
+    }
+    return [...difference.difference(a, b), ...difference.difference(b, a)];
+}
+
+exports.symmetricDifference = symmetricDifference;

package/cjs/array/union.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *
+ * 数组的并集
+ *
+ *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+ * @param arrays  - 多个数组
+ * @returns 联合后的数组
+ *
+ *
+ * @example
+ *
+ * ```ts
+ * import { union } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ * // []
+ * log(union());
+ *
+ * // [1, 2, 3]
+ * log(union([1, 2, 3]));
+ *
+ * //  TypeError
+ * log(union([1, 2, 3], 'i'));
+ * log(union([1, 2, 3], undefined));
+ * log(union([1, 2, 3], null));
+ * log(union([1, 2, 3], 4));
+ * log(union([1, 2, 3], {}));
+ * log(union([1, 2, 3], false));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+ * ```
+ *
+ */
+function union(...arrays) {
+    if (aTypeOfJs.isEmptyArray(arrays)) {
+        return [];
+    }
+    if (arrays.some(i => !aTypeOfJs.isArray(i))) {
+        throw new TypeError('参数必须都是数组形式的元素');
+    }
+    if (arrays.length === 1) {
+        return [...arrays[0]];
+    }
+    const resultSet = new Set();
+    for (const array of arrays) {
+        for (const item of array) {
+            resultSet.add(item);
+        }
+    }
+    return Array.from(resultSet);
+}
+
+exports.union = union;

package/cjs/className.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * 驼峰命名与连字符命名法的互换
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/class-name
+ * @license MIT
+ */
+/**
+ *
+ * 连字符连接转化为小/大驼峰命名法
+ *
+ * @param str    待转化文本
+ * @param dividingType   连字符，缺省值为 "-"
+ * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
+ * @returns 驼峰命名法字符串（e.g. “helloWorld”）
+ *
+ */
+function toLowerCamelCase(
+/**  待转化文本  */
+str, 
+/**  连字符，缺省值为 "-"  */
+dividingType = '-', 
+/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
+initial = false) {
+    let result = str;
+    /**
+     * 匹配规则
+     *
+     * - 匹配到分隔符，将分隔符后面的字符转化为大写
+     */
+    const template = /[\\]|[\^]|[?]|[-]|[.]|[(]|[)]|[|]|[[]\[\]]|[{]|[}]|[+]|[*]|[$]/;
+    /**  转化首字符   */
+    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;
+}
+
+exports.toLowerCamelCase = toLowerCamelCase;
+exports.toSplitCase = toSplitCase;

package/cjs/getRandomNumber.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ * 过去随机数
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/get-random-number
+ * @license MIT
+ */
+/**
+ *
+ * 获取一个随机的整数类型
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
+ *
+ * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
+ *
+ * @param   max 较大值 ，不允许为`NaN`
+ * @param   min 较小值，不允许为 `NaN`
+ * @returns  任意的整数
+ */
+function getRandomInt(max = 1, min = 0) {
+    //  判断是否为 NaN 或 不是数字
+    if (!isFinite(max) ||
+        !isFinite(min) ||
+        aTypeOfJs.isNaN(max) ||
+        aTypeOfJs.isNaN(min) ||
+        !aTypeOfJs.isNumber(max) ||
+        !aTypeOfJs.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) ||
+        aTypeOfJs.isNaN(max) ||
+        aTypeOfJs.isNaN(min) ||
+        !aTypeOfJs.isNumber(max) ||
+        !aTypeOfJs.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;
+}
+
+exports.getRandomFloat = getRandomFloat;
+exports.getRandomInt = getRandomInt;

package/cjs/getRandomString.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+var createConstructor = require('./object/createConstructor.js');
+var getRandomNumber = require('./getRandomNumber.js');
+
+/**
+ * 获取随机字符串
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/get-random-string
+ * @license MIT
+ */
+/**
+ *
+ *  获取简单的随机字符串
+ *
+ *  @param   options - 字符串长度
+ *  @returns  - 随机字符串
+ *
+ *
+ */
+function getRandomString(options) {
+    //   验证输入参数
+    if (
+    // 参数类型错误
+    (!aTypeOfJs.isPlainObject(options) && !aTypeOfJs.isNumber(options)) ||
+        // 参数为 NaN
+        (aTypeOfJs.isNumber(options) && aTypeOfJs.isNaN(options)) ||
+        // 参数为数字时为无穷大
+        (aTypeOfJs.isNumber(options) && !isFinite(options)) ||
+        // 参数为数字时为非整数
+        (aTypeOfJs.isNumber(options) && !Number.isInteger(options)) ||
+        // 参数为数字时为负数
+        (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options < 1) ||
+        // 参数为数值然而却小于 1
+        (aTypeOfJs.isNumber(options) && options < 1) ||
+        // 参数为对象但是 length 属性非数值
+        (aTypeOfJs.isPlainObject(options) &&
+            (!aTypeOfJs.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 (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options > 0)
+        createConstructor.ObjectAssign(initOptions, { length: options });
+    if (aTypeOfJs.isPlainObject(options)) {
+        createConstructor.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[getRandomNumber.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 && !aTypeOfJs.isUndefined(str2[i])) {
+                str1[i] += str2[i];
+            }
+            else if (i < str2Length) {
+                str1[i] = str2[i];
+            }
+        }
+    }
+    /// 结果字符串不包含字符
+    if (!/[a-zA-Z]/.test(result))
+        return String.fromCharCode(getRandomNumber.getRandomInt(97, 122)).concat(result.slice(1));
+    while (!/^[a-zA-Z]$/.test(result[0]))
+        result = result.slice(1) + result[0];
+    return result;
+}
+
+exports.getRandomString = getRandomString;

package/cjs/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var className = require('./className.js');
+var createConstructor = require('./object/createConstructor.js');
+var getRandomNumber = require('./getRandomNumber.js');
+var getRandomString = require('./getRandomString.js');
+var performance = require('./performance.js');
+var escapeRegExp = require('./regexp/escapeRegExp.js');
+var autoEscapedRegExp = require('./regexp/autoEscapedRegExp.js');
+var isNode = require('./isNode.js');
+var index = require('./array/index.js');
+var sleep = require('./sleep.js');
+var intersection = require('./array/intersection.js');
+var union = require('./array/union.js');
+var difference = require('./array/difference.js');
+var symmetricDifference = require('./array/symmetricDifference.js');
+
+
+
+exports.toLowerCamelCase = className.toLowerCamelCase;
+exports.toSplitCase = className.toSplitCase;
+exports.ObjectAssign = createConstructor.ObjectAssign;
+exports.createConstructor = createConstructor.createConstructor;
+exports.getRandomFloat = getRandomNumber.getRandomFloat;
+exports.getRandomInt = getRandomNumber.getRandomInt;
+exports.getRandomString = getRandomString.getRandomString;
+exports.debounce = performance.debounce;
+exports.throttle = performance.throttle;
+exports.escapeRegExp = escapeRegExp.escapeRegExp;
+exports.autoEscapedRegExp = autoEscapedRegExp.autoEscapedRegExp;
+exports.isBrowser = isNode.isBrowser;
+exports.isNode = isNode.isNode;
+exports.enArr = index.enArr;
+exports.sleep = sleep.sleep;
+exports.intersection = intersection.intersection;
+exports.union = union.union;
+exports.difference = difference.difference;
+exports.symmetricDifference = symmetricDifference.symmetricDifference;