gzjs-utils 1.0.25 → 1.0.26

package/package.json

@@ -1,13 +1,29 @@
 {
   "name": "gzjs-utils",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "smart js utils",
-  "main": "lib/index.js",
+  "main": "lib/index.cjs",
+  "module": "lib/index.mjs",
+  "browser": "lib/index.umd.js",
   "typings": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.cjs",
+      "browser": "./lib/index.umd.js",
+      "types": "./types/index.d.ts"
+    }
+  },
   "scripts": {
-    "dev": "npx nodemon",
-    "build": "cross-env NODE_ENV=production webpack",
-    "test": ""
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "test": "tsx test/test-crypto.ts && tsx test/test-file-hash.ts && tsx test/test-clone.ts && tsx test/test-promise.ts && tsx test/test-throttle.ts",
+    "test:crypto": "tsx test/test-crypto.ts",
+    "test:file": "tsx test/test-file-hash.ts",
+    "test:clone": "tsx test/test-clone.ts",
+    "test:promise": "tsx test/test-promise.ts",
+    "test:throttle": "tsx test/test-throttle.ts"
   },
   "repository": {
     "type": "git",
@@ -19,9 +35,24 @@
     "AES",
     "Base64",
     "MD5",
-    "Hexs",
+    "SHA",
+    "SHA1",
+    "SHA224",
+    "SHA256",
+    "SHA384",
+    "SHA512",
+    "Hmac",
     "Bytes"
   ],
   "author": "xiyuan-lgz",
-  "license": "ISC"
+  "license": "ISC",
+  "files": [
+    "lib",
+    "types",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "crypto-js": "^4.2.0",
+    "eval5": "^1.4.8"
+  }
 }

package/types/index.d.ts

@@ -1,2 +1,12 @@
-import _JsUtils_ from "./utils";
-export default _JsUtils_;
+import { default as JsUtils } from './utils';
+import { default as AES } from './utils/AES';
+import { default as Base64 } from './utils/Base64';
+import { default as MD5 } from './utils/MD5';
+import { default as Hmac } from './utils/Hmac';
+import { default as SHA } from './utils/SHA';
+import { default as Bytes } from './utils/Bytes';
+import { default as TreeUtils } from './utils/TreeUtils';
+import { default as Regexps } from './utils/Regexps';
+import { default as DateUtils } from './utils/DateUtils';
+export default JsUtils;
+export { AES, JsUtils, Base64, Bytes, MD5, Hmac, SHA, TreeUtils, Regexps, DateUtils };

package/types/utils/AES.d.ts

@@ -26,76 +26,43 @@ declare const provders: {
          * @param opts
          */
         encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding">): Uint8Array;
-        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding">): Uint8Array<ArrayBufferLike>;
         encode(key: string, plaintext: string, opts?: Pick<Options, "padding">): string;
         decode(key: string, ciphertext: string, opts?: Pick<Options, "padding">): string;
     };
     CBC: {
         encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
-        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
         encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
         decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
     };
     CFB: {
         encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): Uint8Array;
-        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): Uint8Array<ArrayBufferLike>;
         encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): string;
         decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): string;
     };
     OFB: {
         encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
-        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
         encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
         decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
     };
     CTR: {
         encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
-        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
         encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
         decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
     };
 };
 export type Mode = keyof typeof provders | string;
-/**
- * AES 加解密函数， 默认使用 ECB模式,
- *
- * A pure JavaScript implementation of the AES block cipher algorithm and all common modes of operation (CBC, CFB, CTR, ECB and OFB).
- * Features --------
- *
- * <ul>
- *  <li>Pure JavaScript (with no dependencies)</li>
- *  <li>Supports all key sizes (128-bit, 192-bit and 256-bit)</li>
- *  <li>Supports all common modes of operation (CBC, CFB, CTR, ECB and OFB)</li>
- *  <li>Works in either node.js or web browsers</li>
- * </ul>
- *
- * <h1>API</h1>
- * <strong>Node.js</strong>
- * <span>To install <code>gzjs-utils</code> in your node.js project:</span>
- * <pre>npm install gzjs-utils</pre>
- *
- * 通用用法 为 <code>浏览器引入js 后 会注册全局变量JsUtils</code>
- * <pre>
- *     const JsUtils = require('gzjs-utils');
- *
- *
- *     const iv = "<IV>"                // iv must 16 bytes
- *     const key = "<aesKey>";          // keys must be 128 bits (16 bytes), 192 bits (24 bytes) or 256 bits (32 bytes)
- *     const mode = '<mode>'            // ECB,CBC, CFB,OFB,CTR
- *     const padding =  "PKCS#7"        // 填充方式， PKCS#7 | PKCS#5 | NoPadding
- *     const plaintext = '<plaintext>';
- *     const ciphertext = '<plaintext>';
- *
- *     JsUtils.AES.encode(key, <plaintext>, {mode: <mode>, iv: <iv>, padding: <padding>});  // return hex string
- *     JsUtils.AES.encrypt(key, <plaintext>, {mode: <mode>, iv: <iv>, padding: <padding>}); // return Uint8Array
- *
- *     JsUtils.AES.decode(key, <ciphertext>, {mode: <mode>, iv: <iv>, padding: <padding>}); // return plaintext
- *     JsUtils.AES.decrypt(key, <ciphertext>, {mode: <mode>, iv: <iv>, padding: <padding>}); // return plaintext as Uint8Array
- *
- * </pre>
- *
- */
-export type AES = typeof provders & {
+export type Opts = Options & {
+    /**
+     * 加密模式
+     */
+    mode?: Mode;
+};
+export declare const _AES_: {
     /**
      * 获取允许的加密模式
      */
@@ -107,9 +74,7 @@ export type AES = typeof provders & {
      * @param opts 加密套件参数
      * @return 返回 Uint8Array 数据数组
      */
-    encrypt(key: string, text: string | Int8Array | Uint8Array, opts?: Options & {
-        mode?: Mode;
-    }): Uint8Array;
+    encrypt(key: string, text: string, opts?: Opts): Uint8Array;
     /**
      * 解密
      * @param text 加密的内容 hex内容格式
@@ -117,9 +82,7 @@ export type AES = typeof provders & {
      * @param opts 加密套件参数
      * @return 返回 Uint8Array 数据数组
      */
-    decrypt(key: string, text: string | Int8Array | Uint8Array, opts?: Options & {
-        mode?: Mode;
-    }): Uint8Array;
+    decrypt(key: string, text: string, opts?: Opts): Uint8Array;
     /**
      * 加密密钥
      * @param text 待加密内容
@@ -127,9 +90,7 @@ export type AES = typeof provders & {
      * @param opts 加密套件参数
      * @return  加密后的 hex 内容
      */
-    encode(key: string, text: string | Int8Array | Uint8Array, opts?: Options & {
-        mode?: Mode;
-    }): string;
+    encode(key: string, text: string, opts?: Opts): string;
     /**
      * 解密
      * @param text 加密的内容 hex内容格式
@@ -137,15 +98,43 @@ export type AES = typeof provders & {
      * @param opts 加密套件参数
      * @return 解密后的字符串
      */
-    decode(key: string, text: string | Int8Array | Uint8Array, opts?: Options & {
-        mode?: Mode;
-    }): string;
-};
-export type Opts = Options & {
-    /**
-     * 加密模式
-     */
-    mode?: Mode;
+    decode(key: string, text: string, opts?: Opts): any;
+    ECB: {
+        /**
+         * ECB 模式 加密
+         * @param key 加密密钥
+         * @param plaintext 待加密的数据内容
+         * @param opts
+         */
+        encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding">): Uint8Array<ArrayBufferLike>;
+        encode(key: string, plaintext: string, opts?: Pick<Options, "padding">): string;
+        decode(key: string, ciphertext: string, opts?: Pick<Options, "padding">): string;
+    };
+    CBC: {
+        encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
+        encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
+        decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
+    };
+    CFB: {
+        encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): Uint8Array<ArrayBufferLike>;
+        encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): string;
+        decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv" | "segmentSize">): string;
+    };
+    OFB: {
+        encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
+        encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
+        decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
+    };
+    CTR: {
+        encrypt(key: string, plaintext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array;
+        decrypt(key: string, ciphertext: Uint8Array | Int8Array, opts?: Pick<Options, "padding" | "iv">): Uint8Array<ArrayBufferLike>;
+        encode(key: string, plaintext: string, opts?: Pick<Options, "padding" | "iv">): string;
+        decode(key: string, ciphertext: string, opts?: Pick<Options, "padding" | "iv">): string;
+    };
 };
-export declare const _AES_: AES;
 export default _AES_;
+export declare type AES = typeof _AES_;

package/types/utils/Base64.d.ts

@@ -1,46 +1,46 @@
-export interface Base64 {
+/**
+ * 判断是否为base64 内容
+ * @param str
+ */
+export declare function is(str: any): boolean;
+/**
+ * base64 加密
+ * @param input 需要解密的内容
+ */
+export declare function encode(input: any): string;
+/**
+ * base64 解密
+ * @param input 待解密内容
+ */
+export declare function decode(input: any): string;
+export declare function encrypt(input: any): Int8Array;
+export declare function decrypt(input: any): Int8Array;
+declare const _Base64_: {
     /**
      * 判断是否为base64 内容
      * @param str
      */
-    is(str: string): boolean;
+    is: typeof is;
     /**
      * base64 加密
      * @param input 需要解密的内容
      */
-    encode(input: any): string | null | undefined;
+    encode: typeof encode;
     /**
      * base64 解密
      * @param input 待解密内容
      */
-    decode(input: any): string | null | undefined;
+    decode: typeof decode;
     /**
      * 加密数据
      * @param input
      */
-    encrypt(input: any): Int8Array;
+    decrypt: typeof decrypt;
     /**
      * 解密数据
      * @param input
      */
-    decrypt(input: any): Int8Array;
-}
-/**
- * 判断是否为base64 内容
- * @param str
- */
-export declare function is(str: any): boolean;
-/**
- * base64 加密
- * @param input 需要解密的内容
- */
-export declare function encode(input: any): string;
-/**
- * base64 解密
- * @param input 待解密内容
- */
-export declare function decode(input: any): string;
-export declare function encrypt(input: any): Int8Array;
-export declare function decrypt(input: any): Int8Array;
-declare const _Base64_: Base64;
+    encrypt: typeof encrypt;
+};
 export default _Base64_;
+export declare type Base64 = typeof _Base64_;

package/types/utils/Bytes.d.ts

@@ -1,40 +1,3 @@
-export declare type Bytes = {
-    /**
-     * 将 数字 转换成 byte, [-128, 127]
-     * @param num
-     */
-    byte(num: string | number): number;
-    /**
-     * 字符串转字节数组,
-     * @param str 字符串
-     */
-    toBytes(str: string): Int8Array;
-    /**
-     * 字节数组转字符串
-     * @param {Int8Array|Uint8Array|[Number]} bytes 字节数组
-     */
-    fromBytes(bytes: Int8Array | Uint8Array | [Number] | unknown): string;
-    /**
-     * 字符串转 16进制字符串
-     * @param str 字符串
-     */
-    toHex(str: string): string;
-    /**
-     * 将十六进制字符串 转化为 Int8Array
-     * @param hexs
-     */
-    fromHex(hexs: string): Int8Array;
-    /**
-     * 字符串转 hex 字符串
-     * @param str
-     */
-    str2hex(str: string): string;
-    /**
-     * 十六进制字符串转String
-     * @param hex
-     */
-    hex2str(hex: string): string;
-};
 /**
  * 字符串转字节数组,
  * @param str 字符串
@@ -44,7 +7,7 @@ declare function toBytes(str: string): Int8Array;
  * 字节数组转字符串
  * @param {Int8Array|Uint8Array|[Number]} bytes 字节数组
  */
-declare function fromBytes(bytes: Int8Array | Uint8Array | [Number] | unknown): string;
+declare function fromBytes(bytes: Int8Array | Uint8Array | number[] | unknown): string;
 /**
  * 将 数字 转换成 byte, [-128, 127]
  * @param num
@@ -59,7 +22,7 @@ declare function toHex(str: string | number | number[] | Int8Array | Uint8Array)
  * 将十六进制字符串 转化为 Int8Array
  * @param hexs
  */
-declare function fromHex(hexs: string): Int8Array;
+declare function fromHex(hexs: string): Int8Array<ArrayBuffer>;
 /**
  * 十六进制字符串转String
  * @param hex
@@ -70,6 +33,43 @@ declare function hex2str(hex: string): string;
  * @param str
  */
 declare function toUint8Array(str: string | Int8Array | Uint8Array | number[] | any): Uint8Array;
-declare const _Bytes_: Bytes;
+declare const _Bytes_: {
+    /**
+     * 将 数字 转换成 byte, [-128, 127]
+     * @param num
+     */
+    byte: typeof byte;
+    /**
+     * 字符串转字节数组,
+     * @param str 字符串
+     */
+    toBytes: typeof toBytes;
+    /**
+     * 字节数组转字符串
+     * @param {Int8Array|Uint8Array|[Number]} bytes 字节数组
+     */
+    fromBytes: typeof fromBytes;
+    /**
+     * 字符串转 16进制字符串
+     * @param str 字符串
+     */
+    toHex: typeof toHex;
+    /**
+     * 将十六进制字符串 转化为 Int8Array
+     * @param hexs
+     */
+    fromHex: typeof fromHex;
+    /**
+     * 字符串转 hex 字符串
+     * @param str
+     */
+    str2hex: typeof toHex;
+    /**
+     * 十六进制字符串转String
+     * @param hex
+     */
+    hex2str: typeof hex2str;
+};
 export { toBytes, fromBytes, toHex, hex2str, fromHex, byte, toUint8Array };
 export default _Bytes_;
+export type Bytes = typeof _Bytes_;

package/types/utils/Console.d.ts

@@ -0,0 +1,45 @@
+export interface ConsoleInstance {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert_static) */
+    assert(condition?: boolean, ...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear_static) */
+    clear(): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */
+    count(label?: string): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */
+    countReset(label?: string): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */
+    debug(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir_static) */
+    dir(item?: any, options?: any): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml_static) */
+    dirxml(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static) */
+    error(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */
+    group(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */
+    groupCollapsed(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */
+    groupEnd(): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */
+    info(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static) */
+    log(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table_static) */
+    table(tabularData?: any, properties?: string[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */
+    time(label?: string): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */
+    timeEnd(label?: string): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */
+    timeLog(label?: string, ...data: any[]): void;
+    timeStamp(label?: string): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */
+    trace(...data: any[]): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static) */
+    warn(...data: any[]): void;
+}
+export declare const Console: any;
+declare const _default: ConsoleInstance;
+export default _default;
+export declare const getNativeConsole: () => Console;

package/types/utils/DateUtils.d.ts

@@ -1,7 +1,4 @@
-/**
- * 日期工具类
- */
-export type DateUtils = {
+declare const _DateUtils_: {
     /**
      * 指定日期获取值，返回格式 yyyy-MM-dd hh:mm:ss
      * @param date 指定时间, 默认=当前时间
@@ -16,7 +13,7 @@ export type DateUtils = {
      * 指定日期获取值，返回格式 yyyyMMdd
      * @param date 指定时间, 默认=当前时间
      */
-    getDateInt(date?: Date): string;
+    getDateInt(date?: any): string;
     /**
      * 日期格式化<br>
      *
@@ -40,29 +37,28 @@ export type DateUtils = {
      * @param fmt 格式内容
      */
     format(date: Date, fmt: string): string;
+    /**
+     * 解析时间
+     * @param s
+     * @param fmt
+     */
+    parse(s: string | Date, fmt?: string): Date;
     /**
      * 获取时间差
      * @param start 开始时间
      * @param end 结束时间
      */
     diff(start: string | Date, end?: string | Date): {
-        /**
-         * 天数差值
-         */
         day: number;
-        /**
-         * 0-24 小时
-         */
         hour: number;
-        /**
-         * 0-59
-         */
         minute: number;
-        /**
-         * 0-59
-         */
         second: number;
+        millisecond: number;
+        diff: number;
     };
 };
-declare const _DateUtils_: DateUtils;
 export default _DateUtils_;
+/**
+ * 日期工具类
+ */
+export declare type DateUtils = typeof _DateUtils_;

package/types/utils/EnumBuilder.d.ts

@@ -1,4 +1,4 @@
-import { EnumItem } from "./index";
+import { EnumItem } from './index';
 type SimpleType = string | number | boolean | undefined | null;
 interface ET extends EnumItem {
 }

package/types/utils/Env.d.ts

@@ -1,2 +1,3 @@
-export type Env = typeof process.env;
+export type Env = typeof process.env & Record<any, any>;
+export declare const isDevelopment: (value: string) => value is "development" | "dev" | "debug" | "test" | "preview";
 export declare const getEnvironments: () => Env;

package/types/utils/ExpUtils.d.ts

@@ -0,0 +1,74 @@
+export declare function set_exp_utils(tool: any): void;
+declare const _ExpUtils_: {
+    defaultVars: {
+        Math: Math;
+        Date: DateConstructor;
+        RegExp: RegExpConstructor;
+        JSON: JSON;
+        String: StringConstructor;
+        Array: ArrayConstructor;
+        Object: ObjectConstructor;
+        Number: NumberConstructor;
+        Boolean: BooleanConstructor;
+        Function: FunctionConstructor;
+        Symbol: SymbolConstructor;
+        Map: MapConstructor;
+        WeakMap: WeakMapConstructor;
+        Set: SetConstructor;
+        WeakSet: WeakSetConstructor;
+        console: Console;
+        E: number;
+        LN10: number;
+        LN2: number;
+        LOG2E: number;
+        LOG10E: number;
+        PI: number;
+        SQRT1_2: number;
+        SQRT2: number;
+        abs(x: number): number;
+        acos(x: number): number;
+        asin(x: number): number;
+        atan(x: number): number;
+        atan2(y: number, x: number): number;
+        ceil(x: number): number;
+        cos(x: number): number;
+        exp(x: number): number;
+        floor(x: number): number;
+        log(x: number): number;
+        max(...values: number[]): number;
+        min(...values: number[]): number;
+        pow(x: number, y: number): number;
+        random(): number;
+        round(x: number): number;
+        sin(x: number): number;
+        sqrt(x: number): number;
+        tan(x: number): number;
+        clz32(x: number): number;
+        imul(x: number, y: number): number;
+        sign(x: number): number;
+        log10(x: number): number;
+        log2(x: number): number;
+        log1p(x: number): number;
+        expm1(x: number): number;
+        cosh(x: number): number;
+        sinh(x: number): number;
+        tanh(x: number): number;
+        acosh(x: number): number;
+        asinh(x: number): number;
+        atanh(x: number): number;
+        hypot(...values: number[]): number;
+        trunc(x: number): number;
+        fround(x: number): number;
+        cbrt(x: number): number;
+        f16round(x: number): number;
+        [Symbol.toStringTag]: string;
+    };
+    /**
+     * 执行表达式
+     * @param expression 表达式文本
+     * @param params 运行参数
+     */
+    execute(expression: string, params: Record<any, any>): any;
+};
+export default _ExpUtils_;
+export type ExpUtils = typeof _ExpUtils_;