@zwa73/utils 1.0.206 → 1.0.208

package/dist/UtilDecorators.js

@@ -1,227 +1,17 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogTime = LogTime;
-exports.LogTimeAsync = LogTimeAsync;
-exports.LogCall = LogCall;
-exports.LogCallAsync = LogCallAsync;
-exports.LogErr = LogErr;
-exports.LogErrAsync = LogErrAsync;
-exports.Defer = Defer;
-exports.DeferAsync = DeferAsync;
-exports.Catch = Catch;
-exports.CatchAsync = CatchAsync;
-exports.AwaitInited = AwaitInited;
-const UtilFunctions_1 = require("./UtilFunctions");
-const UtilLogger_1 = require("./UtilLogger");
-/**用于打印方法运行时间
- * @param flag      - 时间标签
- * @param suffixUID - 是否尾随uid
- */
-function LogTime(flag, suffixUID) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
-            UtilLogger_1.SLogger.time(flag + uid);
-            let result = originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.timeEnd(flag + uid);
-            return result;
-        };
-        return descriptor;
-    };
-}
-/**用于打印异步方法运行时间
- * @param flag      - 时间标签
- * @param suffixUID - 是否尾随uid
- */
-function LogTimeAsync(flag, suffixUID) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            const uid = suffixUID ? UtilFunctions_1.UtilFunc.genUUID() : "";
-            UtilLogger_1.SLogger.time(flag + uid);
-            let result = await originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.timeEnd(flag + uid);
-            return result;
-        };
-        return descriptor;
-    };
-}
-/**用于打印方法的调用 */
-function LogCall() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            let result = originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.info(`调用函数: ${propertyKey}(${args}) => ${result}`);
-            return result;
-        };
-        return descriptor;
-    };
-}
-/**用于打印异步方法的调用 */
-function LogCallAsync() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            let result = await originalMethod.apply(this, args);
-            UtilLogger_1.SLogger.info(`调用函数: ${propertyKey}(${args}) => ${result}`);
-            return result;
-        };
-        return descriptor;
-    };
-}
-/**用于打印方法的调用 */
-function LogErr() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            try {
-                const result = originalMethod.apply(this, args);
-                return result;
-            }
-            catch (err) {
-                UtilFunctions_1.UtilFunc.throwError(`函数出现错误: ${propertyKey}(${args}): ${err}`, 'warn');
-            }
-        };
-        return descriptor;
-    };
-}
-/**用于打印异步方法的调用 */
-function LogErrAsync() {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            try {
-                const result = await originalMethod.apply(this, args);
-                return result;
-            }
-            catch (err) {
-                UtilFunctions_1.UtilFunc.throwError(`函数出现错误: ${propertyKey}(${args}): ${err}`, 'warn');
-            }
-        };
-        return descriptor;
-    };
-}
-/**try-finally包装 */
-function Defer(deferLogic) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            try {
-                const result = originalMethod.apply(this, args);
-                return result;
-            }
-            finally {
-                deferLogic(...args);
-            }
-        };
-        return descriptor;
-    };
-}
-/**异步的try-finally包装 */
-function DeferAsync(deferLogic) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            try {
-                const result = await originalMethod.apply(this, args);
-                await deferLogic(...args);
-                return result;
-            }
-            finally {
-                await deferLogic(...args);
-            }
-        };
-        return descriptor;
-    };
-}
-/**try-catch包装 */
-function Catch(catchLogic) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
-            try {
-                const result = originalMethod.apply(this, args);
-                return result;
-            }
-            catch (err) {
-                //SLogger.warn(`一个函数出现了错误 ${propertyKey}: ${err}`);
-                return catchLogic(err, ...args);
-            }
-        };
-        return descriptor;
-    };
-}
-/**异步的try-catch包装 */
-function CatchAsync(catchLogic) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            try {
-                const result = await originalMethod.apply(this, args);
-                return result;
-            }
-            catch (err) {
-                //SLogger.warn(`一个函数出现了错误 ${propertyKey}: ${err}`);
-                return await catchLogic(err, ...args);
-            }
-        };
-        return descriptor;
-    };
-}
-/**等待完成init */
-function AwaitInited(target, propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    descriptor.value = async function (...args) {
-        await this.inited;
-        return await originalMethod.apply(this, args);
-    };
-    return descriptor;
-}
-function AddNumberDecorator(n) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function (num) {
-            const result = originalMethod.apply(this, [num]);
-            return result + n;
-        };
-        return descriptor;
-    };
-}
-class Example {
-    myMethod(num) {
-        return num;
-    }
-    static async myMethod1(num, ss) {
-        return 312;
-    }
-}
-__decorate([
-    AddNumberDecorator(10),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Number)
-], Example.prototype, "myMethod", null);
-__decorate([
-    LogCall(),
-    Defer((a, b) => null),
-    CatchAsync(async (a, b) => 123),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, String]),
-    __metadata("design:returntype", Promise)
-], Example, "myMethod1", null);
-//let e = new Example();
-//e.myMethod1(1,"");
-//console.log(123);
-//let a = new Example();
-//a.myMethod(10);//?
+exports.AwaitInited = exports.CatchAsync = exports.Catch = exports.DeferAsync = exports.Defer = exports.LogErrAsync = exports.LogErr = exports.LogCallAsync = exports.LogCall = exports.LogTimeAsync = exports.LogTime = void 0;
+//#region UtilDecorators转导
+var js_utils_1 = require("@zwa73/js-utils");
+Object.defineProperty(exports, "LogTime", { enumerable: true, get: function () { return js_utils_1.LogTime; } });
+Object.defineProperty(exports, "LogTimeAsync", { enumerable: true, get: function () { return js_utils_1.LogTimeAsync; } });
+Object.defineProperty(exports, "LogCall", { enumerable: true, get: function () { return js_utils_1.LogCall; } });
+Object.defineProperty(exports, "LogCallAsync", { enumerable: true, get: function () { return js_utils_1.LogCallAsync; } });
+Object.defineProperty(exports, "LogErr", { enumerable: true, get: function () { return js_utils_1.LogErr; } });
+Object.defineProperty(exports, "LogErrAsync", { enumerable: true, get: function () { return js_utils_1.LogErrAsync; } });
+Object.defineProperty(exports, "Defer", { enumerable: true, get: function () { return js_utils_1.Defer; } });
+Object.defineProperty(exports, "DeferAsync", { enumerable: true, get: function () { return js_utils_1.DeferAsync; } });
+Object.defineProperty(exports, "Catch", { enumerable: true, get: function () { return js_utils_1.Catch; } });
+Object.defineProperty(exports, "CatchAsync", { enumerable: true, get: function () { return js_utils_1.CatchAsync; } });
+Object.defineProperty(exports, "AwaitInited", { enumerable: true, get: function () { return js_utils_1.AwaitInited; } });
+//#endregion

package/dist/UtilFunctions.d.ts

@@ -1,6 +1,7 @@
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, StatusVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment, MPromise } from "./UtilInterfaces";
-import { LogLevel } from "./UtilLogger";
-import { Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
+import { LogLevel } from "./UtilInterfaces";
+import { JsFunc } from "@zwa73/js-utils";
+import { ComposedClass } from "@zwa73/modular-mixer";
+export { PromiseRetries, PromiseRetryResult } from "@zwa73/js-utils";
 declare const HashMethodList: readonly ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
 type HashMethod = typeof HashMethodList[number];
 /**执行选项 */
@@ -12,66 +13,8 @@ type ExecOpt = Partial<{
     /**工作路径 */
     cwd: string;
 }>;
-/**序列化选项 */
-type StringifyOpt = Partial<{
-    /**使用紧凑风格 将会用/@@@.+@@@/作为特殊标记, 原始文本内若出现相同格式将会产生错误 */
-    compress: boolean;
-    /**紧凑风格 压缩阈值 默认100 */
-    compressThreshold: number;
-    /**插入的空格 数字为空格数量 默认为制表符\t */
-    space: string | number | null | undefined;
-}>;
-/**Promise重试选项 */
-export type PromiseRetries = Partial<{
-    /**重试次数 默认3*/
-    count?: number;
-    /**尝试间隔时间 超过此事件会重新创建新的Promise
-     * 同时等待新的与旧的Promise 毫秒 默认180_000
-     */
-    tryInterval?: number;
-    /**尝试延迟 重新尝试时会先等待此毫秒数 毫秒 默认0*/
-    tryDelay?: number;
-    /**是否使用指数回退 默认false 仅在tryDelay被设置时有效 */
-    expBackoff?: boolean;
-    /**指数回退上限值 默认无限*/
-    expBackoffMax?: number;
-}>;
-type SuccessOut<T> = Outcome<Success, T>;
-type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
-/**完成的重试请求 */
-export type PromiseRetryResult<T> = {
-    completed: T | undefined;
-    /**还未完成的其他Promise 若是验证失败则会返回undefined */
-    pending: Promise<T | undefined>[];
-};
-/**遍历对象的回调函数
- * @param key       - 字段名
- * @param value     - 字段值
- * @param parent    - 父对象
- */
-type EachFieldCallback = (key: string, value: JToken, parent: JObject) => void;
 /**常用函数 */
-export declare class UtilFunc {
-    /**获取当前时间戳
-     * @returns 时间戳
-     */
-    static getTime(): number;
-    /**初始化对象的字段
-     * 会改变obj
-     * @param obj        - 所要初始化的对象
-     * @param field      - 所要初始化的字段
-     * @param defaultVal - 默认值
-     * @returns 最终值
-     */
-    static initField<T extends AnyRecord, K extends keyof T>(obj: T, field: K, defaultVal: T[K]): T[K];
-    /**初始化一个数据对象
-     * @param obj       - 目标对象
-     * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
-     * @returns 完成初始化的对象
-     */
-    static initObject<T extends JObject>(obj: T, checkObj: {
-        [P in keyof T]: T[P] | (() => void | T[P]);
-    }): any;
+declare class _UtilFunc {
     /**生成一串uuid
      * @returns uuid
      */
@@ -82,19 +25,6 @@ export declare class UtilFunc {
      * @returns hash
      */
     static calcHash(str: string, method?: HashMethod): string;
-    /**等待 timeMs 毫秒
-     * @async
-     * @param timeMs - 等待的毫秒数
-     * @returns
-     */
-    static sleep<T>(timeMs: number): Promise<void>;
-    /**等待 timeMs 毫秒
-     * @async
-     * @param timeMs - 等待的毫秒数
-     * @param result - 结果
-     * @returns
-     */
-    static sleep<T>(timeMs: number, result: T): Promise<T>;
     /**是否需要检查环境 */
     private static checkEnv;
     /**是否有正在运行的exec */
@@ -111,98 +41,6 @@ export declare class UtilFunc {
         stdout: string;
         stderr: string;
     }>;
-    /**获得一个永不完成的Promise单例 */
-    static getNeverResolvedPromise<T>(): Promise<T>;
-    /**重复尝试promise
-     * @async
-     * @param proc      - 发起函数
-     * @param verify    - 验证函数
-     * @param retries         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
-     * @returns 重复结果
-     */
-    static retryPromise<T>(proc: () => Promise<T>, verify?: StatusVerifyFn<T>, retries?: PromiseRetries): Promise<PromiseRetryResult<T>>;
-    /**创建一个限时的Promise
-     * @param func      - 处理函数
-     * @param timeLimit - 毫秒限时
-     * @returns 超时则返回 处理函数委托 完成则返回结果
-     */
-    static timelimitPromise<T>(func: () => MPromise<T>, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
-    /**对对象的每个属性应用映射函数，并返回一个新的对象。
-     * @template T      - 对象的类型
-     * @param obj       - 要处理的对象
-     * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
-     * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
-     */
-    static mapEntries<T extends AnyRecord>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
-    /**遍历对象的所有字段
-     * @param obj       - 对象
-     * @param callback  - 回调函数
-     */
-    static eachField(obj: JToken, callback: EachFieldCallback): void;
-    /**将JToken转换为字符串
-     * @param token - 待转换的Token
-     * @param opt   - 可选参数
-     * @param opt.space             - 插入的空格 数字为空格数量 默认为制表符\t
-     * @param opt.compress          - 使用紧凑风格 将会用/\uF121\uF122\uF123.+\uF121\uF122\uF123/作为特殊标记, 原始文本内若出现相同格式将会产生错误
-     * @param opt.compressThreshold - 紧凑风格 压缩阈值 默认100
-     * @returns 转换完成的字符串
-     */
-    static stringifyJToken(token: JToken | IJData, opt?: StringifyOpt): string;
-    /**验证一个变量的类型是否为 T
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertType<T>(t: T): T;
-    /**验证一个变量的类型是否为字面量
-     * 仅限浅层
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertLiteral<T>(t: Literal<T>): T;
-    /**深克隆 序列化并反序列化
-     * @template T - JToken类型的泛型
-     * @param obj  - 克隆目标
-     * @returns 克隆结果
-     */
-    static deepClone<T extends JToken>(obj: T): T;
-    /**是否为安全的数字
-     * 非NaN 非null/undefined
-     * 且是数字
-     * @param num - 所要检测的数字
-     * @returns 是否安全
-     */
-    static isSafeNumber(num: unknown): boolean;
-    /**移除多行字符串中每行开始的最小空格数。
-     *
-     * @param input   - 需要处理的多行 字符串模板 或 字符串。
-     * @param values  - 插入模板字符串中的值。
-     * @returns 返回处理后的字符串，每行开始的空格数已被最小化。
-     *
-     * @example
-     * const name = 'World';
-     * const str = dedent`
-     *     Hello,
-     *         ${name}!
-     * `;
-     * console.log(str);
-     * // 输出：
-     * // Hello,
-     * //     World!
-     */
-    static dedent(input: TemplateStringsArray | string, ...values: any[]): string;
-    /**抛出错误
-     * @param message - 错误信息
-     * @param lvl     - 日志等级
-     * @param opt     - 额外参数
-     */
-    static throwError(message: string, lvl?: LogLevel, opt?: {}): never;
-    /**获取函数调用位置 getFunctionLocation
-     * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
-     */
-    static getFuncLoc(stack?: number): {
-        filePath: string;
-        lineNumber: `${number}:${number}`;
-    } | undefined;
     private static publicIp?;
     /**获取当前公网ipv4 */
     static getPublicIpv4(): Promise<string>;
@@ -223,104 +61,8 @@ export declare class UtilFunc {
      * @since Node.js 13.2，Node.js开始支持动态import。
      */
     static dynamicImport(moduleName: string): Promise<any>;
-    /**缓存池 */
-    static cachePool: WeakMap<Function, Map<string, {
-        result: any;
-        timestamp: number;
-    }>>;
-    /**创建一个带有缓存有效期的memoize函数
-     * 只在传入值均为JToken时有效
-     * @param fn     - 需要被memoize的函数
-     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
-     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
-     */
-    static memoize<T extends (...args: any[]) => any>(fn: T, expiry?: number): T extends (...args: infer In) => any ? AllExtends<In, JToken> extends true ? T : never : never;
-    /**代办表 用于队列处理等待 */
-    static pendingMap: Record<Keyable, AnyFunc[]>;
-    /**队列处理
-     * 等待标签为 flag 的队列
-     * 直到排在之前的任务全部完成再处理当前Promise
-     * @param flag - 队列标签
-     * @param task - 任务逻辑
-     * @returns 处理结果
-     */
-    static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T>;
-    /**队列获取目标的代办事件数
-     * @param flag - 队列标签
-     */
-    static queueLength(flag: Keyable): number;
-    /**创建一个Outcome */
-    static outcome<K extends Keyable, V>(key: K, value: V): Outcome<K, V>;
-    /**处理联合值
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
-     * @returns 任意处理函数的返回值
-     */
-    static matchProc<T extends Matchable<Keyable>, P extends UnionToIntersection<{
-        [K in MatchableFlag<T>]: (k: K, v: ExtractOutcome<T, MatchableFlag<K>>['result']) => unknown;
-    }>>(t: T, procObj: P): P extends Record<any, AnyFunc> ? {
-        [K in keyof P]: ReturnType<P[K]>;
-    }[keyof P] : never;
-    /**处理部分联合值
-     * @param t       - 目标值
-     * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
-     * @returns 任意处理函数的返回值
-     */
-    static matchPartialProc<T extends Matchable<Keyable>, P extends Partial<{
-        [K in MatchableFlag<T>]: (k: K, v: ExtractOutcome<T, MatchableFlag<K>>['result']) => unknown;
-    }>>(t: T, procObj: P): (P extends PRecord<Keyable, AnyFunc> ? {
-        [K in keyof P]: P[K] extends AnyFunc ? ReturnType<P[K]> : undefined;
-    }[keyof P] : never) | undefined;
-    /**根据典型的成功或失败状态运行函数
-     * @param t - 目标值
-     * @param sucessFunc - 成功则运行的函数 (result)=>any
-     * @param failedFunc - 失败则运行的函数 (result)=>any
-     * @param noneFunc   - 无结果或不匹配时运行的函数 ()=>any
-     * @returns 非成功或失败时返回 None
-     */
-    static sucesProc<T extends Matchable<StatusSymbol>, S extends (arg: ExtractOutcome<T, SuccessLike>['result']) => unknown, F extends (arg: ExtractOutcome<T, FailedLike>['result']) => unknown = (arg: ExtractOutcome<T, FailedLike>['result']) => None, N extends () => unknown = () => None>(t: T, sucessFunc: S, failedFunc?: F, noneFunc?: N): ReturnType<S> | ReturnType<F> | ReturnType<N>;
-    /**是失败的 */
-    static isFailed<T>(tg: T): 'E' extends ProperSubsetCheck<symbol, T> ? boolean : T extends Matchable<FailedLike> ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>, FailedLike> ? false : boolean;
-    /**是成功的 */
-    static isSuccess<T>(tg: T): 'E' extends ProperSubsetCheck<symbol, T> ? boolean : T extends Matchable<SuccessLike> ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>, SuccessLike> ? false : boolean;
-    /**类似空值  undefined null None
-     * @param t          - 检测目标
-     * @param strictLog  - 应该严格等于None 否则将输出警告 但任然返回true
-     */
-    static likeNone(t: unknown, strictLog?: boolean): t is None;
-    /**验证一个值是否为空
-     * 为空则抛异
-     * @param t      - 验证目标
-     * @param errLog - 异常信息
-     * @returns 排除None的原值
-     */
-    static expect<T>(t: T, errLog?: string): Exclude<T, None>;
-    /**将传入函数包装为显式处理错误的函数
-     * @param func - 待转换函数
-     * @returns 转换完成的函数
-     */
-    static eitherize<T extends AnyFunc>(func: ReturnType<T> extends Promise<any> ? Error & "对异步函数请使用taskEitherize" : T): (...args: Parameters<T>) => Outcome<typeof Success, ReturnType<T>> | Outcome<typeof Failed, Error>;
-    /**将传入的异步函数包装为显式处理错误的函数
-     * @param func - 待转换函数
-     * @returns 转换完成的函数
-     */
-    static taskEitherize<T extends (...args: any) => Promise<any>>(func: T): (...args: Parameters<T>) => Promise<Outcome<typeof Failed, Error> | Outcome<typeof Success, Awaited<ReturnType<T>>>>;
-    /**将hh:mm:ss,ms格式转换为毫秒 */
-    static parseSrtTime(time: string): number;
-    /**将毫秒转换为hh:mm:ss,ms格式 */
-    static formatSrtTime(milliseconds: number): string;
-    /**解析srt文本为SrtSegment[] */
-    static parseSrt(srtText: string): SrtSegment[];
-    /**转换json为srt文本 */
-    static createSrt(segments: SrtSegment[]): string;
-    /**立即执行传入的函数
-     * @param fn - 需要立即执行的函数。
-     * @returns 返回 fn 函数的执行结果。
-     */
-    static ivk<T extends () => any>(fn: T): ReturnType<T>;
-    /**一个可供sort使用的从小到大排序的函数 */
-    static s2l(a: number, b: number): number;
-    /**一个可供sort使用的从大到小排序的函数 */
-    static l2s(a: number, b: number): number;
 }
-export {};
+declare const mixkey: "__utilFunc";
+declare const fields: Exclude<(keyof typeof _UtilFunc)[], "prototype" | "length" | "name">;
+export type UtilFunc = ComposedClass<typeof JsFunc, typeof _UtilFunc, typeof mixkey, typeof fields[number]>;
+export declare const UtilFunc: UtilFunc;