@zwa73/utils 1.0.192 → 1.0.194

package/dist/{QuickFunction.d.ts → QuickExport.d.ts}

@@ -1,4 +1,4 @@
 import { UtilFT } from "./UtilFileTools";
 import { UtilFunc } from "./UtilFunctions";
-export declare const outcome: typeof UtilFunc.outcome, matchProc: typeof UtilFunc.matchProc, sucesProc: typeof UtilFunc.sucesProc, isFailed: typeof UtilFunc.isFailed, isSafeNumber: typeof UtilFunc.isSafeNumber, isSuccess: typeof UtilFunc.isSuccess, likeNone: typeof UtilFunc.likeNone, expect: typeof UtilFunc.expect, assertType: typeof UtilFunc.assertType, assertLiteral: typeof UtilFunc.assertLiteral, deepClone: typeof UtilFunc.deepClone, sleep: typeof UtilFunc.sleep, stringifyJToken: typeof UtilFunc.stringifyJToken, getTime: typeof UtilFunc.getTime, mapEntries: typeof UtilFunc.mapEntries, dedent: typeof UtilFunc.dedent, throwError: typeof UtilFunc.throwError, eitherize: typeof UtilFunc.eitherize, taskEitherize: typeof UtilFunc.taskEitherize, memoize: typeof UtilFunc.memoize, ivk: typeof UtilFunc.ivk;
+export declare const outcome: typeof UtilFunc.outcome, matchProc: typeof UtilFunc.matchProc, sucesProc: typeof UtilFunc.sucesProc, isFailed: typeof UtilFunc.isFailed, isSafeNumber: typeof UtilFunc.isSafeNumber, isSuccess: typeof UtilFunc.isSuccess, likeNone: typeof UtilFunc.likeNone, expect: typeof UtilFunc.expect, assertType: typeof UtilFunc.assertType, assertLiteral: typeof UtilFunc.assertLiteral, deepClone: typeof UtilFunc.deepClone, sleep: typeof UtilFunc.sleep, stringifyJToken: typeof UtilFunc.stringifyJToken, getTime: typeof UtilFunc.getTime, mapEntries: typeof UtilFunc.mapEntries, dedent: typeof UtilFunc.dedent, throwError: typeof UtilFunc.throwError, eitherize: typeof UtilFunc.eitherize, taskEitherize: typeof UtilFunc.taskEitherize, memoize: typeof UtilFunc.memoize, ivk: typeof UtilFunc.ivk, l2s: typeof UtilFunc.l2s, s2l: typeof UtilFunc.s2l;
 export declare const stylizePath: typeof UtilFT.stylizePath, posixizePath: typeof UtilFT.posixizePath, win32izePath: typeof UtilFT.win32izePath, currosizePath: typeof UtilFT.currosizePath;

package/dist/{QuickFunction.js → QuickExport.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.currosizePath = exports.win32izePath = exports.posixizePath = exports.stylizePath = exports.ivk = exports.memoize = exports.taskEitherize = exports.eitherize = exports.throwError = exports.dedent = exports.mapEntries = exports.getTime = exports.stringifyJToken = exports.sleep = exports.deepClone = exports.assertLiteral = exports.assertType = exports.expect = exports.likeNone = exports.isSuccess = exports.isSafeNumber = exports.isFailed = exports.sucesProc = exports.matchProc = exports.outcome = void 0;
+exports.currosizePath = exports.win32izePath = exports.posixizePath = exports.stylizePath = exports.s2l = exports.l2s = exports.ivk = exports.memoize = exports.taskEitherize = exports.eitherize = exports.throwError = exports.dedent = exports.mapEntries = exports.getTime = exports.stringifyJToken = exports.sleep = exports.deepClone = exports.assertLiteral = exports.assertType = exports.expect = exports.likeNone = exports.isSuccess = exports.isSafeNumber = exports.isFailed = exports.sucesProc = exports.matchProc = exports.outcome = void 0;
 const UtilFileTools_1 = require("./UtilFileTools");
 const UtilFunctions_1 = require("./UtilFunctions");
 const UtilSymbol_1 = require("./UtilSymbol");
-exports.outcome = UtilFunctions_1.UtilFunc.outcome, exports.matchProc = UtilFunctions_1.UtilFunc.matchProc, exports.sucesProc = UtilFunctions_1.UtilFunc.sucesProc, exports.isFailed = UtilFunctions_1.UtilFunc.isFailed, exports.isSafeNumber = UtilFunctions_1.UtilFunc.isSafeNumber, exports.isSuccess = UtilFunctions_1.UtilFunc.isSuccess, exports.likeNone = UtilFunctions_1.UtilFunc.likeNone, exports.expect = UtilFunctions_1.UtilFunc.expect, exports.assertType = UtilFunctions_1.UtilFunc.assertType, exports.assertLiteral = UtilFunctions_1.UtilFunc.assertLiteral, exports.deepClone = UtilFunctions_1.UtilFunc.deepClone, exports.sleep = UtilFunctions_1.UtilFunc.sleep, exports.stringifyJToken = UtilFunctions_1.UtilFunc.stringifyJToken, exports.getTime = UtilFunctions_1.UtilFunc.getTime, exports.mapEntries = UtilFunctions_1.UtilFunc.mapEntries, exports.dedent = UtilFunctions_1.UtilFunc.dedent, exports.throwError = UtilFunctions_1.UtilFunc.throwError, exports.eitherize = UtilFunctions_1.UtilFunc.eitherize, exports.taskEitherize = UtilFunctions_1.UtilFunc.taskEitherize, exports.memoize = UtilFunctions_1.UtilFunc.memoize, exports.ivk = UtilFunctions_1.UtilFunc.ivk;
+exports.outcome = UtilFunctions_1.UtilFunc.outcome, exports.matchProc = UtilFunctions_1.UtilFunc.matchProc, exports.sucesProc = UtilFunctions_1.UtilFunc.sucesProc, exports.isFailed = UtilFunctions_1.UtilFunc.isFailed, exports.isSafeNumber = UtilFunctions_1.UtilFunc.isSafeNumber, exports.isSuccess = UtilFunctions_1.UtilFunc.isSuccess, exports.likeNone = UtilFunctions_1.UtilFunc.likeNone, exports.expect = UtilFunctions_1.UtilFunc.expect, exports.assertType = UtilFunctions_1.UtilFunc.assertType, exports.assertLiteral = UtilFunctions_1.UtilFunc.assertLiteral, exports.deepClone = UtilFunctions_1.UtilFunc.deepClone, exports.sleep = UtilFunctions_1.UtilFunc.sleep, exports.stringifyJToken = UtilFunctions_1.UtilFunc.stringifyJToken, exports.getTime = UtilFunctions_1.UtilFunc.getTime, exports.mapEntries = UtilFunctions_1.UtilFunc.mapEntries, exports.dedent = UtilFunctions_1.UtilFunc.dedent, exports.throwError = UtilFunctions_1.UtilFunc.throwError, exports.eitherize = UtilFunctions_1.UtilFunc.eitherize, exports.taskEitherize = UtilFunctions_1.UtilFunc.taskEitherize, exports.memoize = UtilFunctions_1.UtilFunc.memoize, exports.ivk = UtilFunctions_1.UtilFunc.ivk, exports.l2s = UtilFunctions_1.UtilFunc.l2s, exports.s2l = UtilFunctions_1.UtilFunc.s2l;
 exports.stylizePath = UtilFileTools_1.UtilFT.stylizePath, exports.posixizePath = UtilFileTools_1.UtilFT.posixizePath, exports.win32izePath = UtilFileTools_1.UtilFT.win32izePath, exports.currosizePath = UtilFileTools_1.UtilFT.currosizePath;
 if (false) {
     let aaser = (0, exports.assertLiteral)({ a: 1 });

package/dist/UtilClass.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hbs = exports.Stream = exports.Piper = void 0;
-const QuickFunction_1 = require("./QuickFunction");
+const QuickExport_1 = require("./QuickExport");
 const handlebars_1 = __importDefault(require("handlebars"));
 const UtilLogger_1 = require("./UtilLogger");
 /**函数管道器 */
@@ -74,7 +74,7 @@ class Stream {
             return [[...this]];
         const size = this.length;
         const result = [];
-        (0, QuickFunction_1.matchProc)(mode, {
+        (0, QuickExport_1.matchProc)(mode, {
             //轮询平均分
             'average': () => {
                 for (let i = 0; i < count; i++) {
@@ -135,22 +135,16 @@ class Stream {
     async append() {
         if (this._operation.length == 0)
             return this;
-        const pList = [];
         //均分处理
-        this.divide(this._concurrent).forEach((subList) => {
-            if (!subList)
-                return;
-            pList.push(new Promise(async (reslove) => {
-                const result = [];
-                for (let item of subList) {
-                    if (!item)
-                        continue;
-                    for (const operation of this._operation)
-                        item = await operation(item);
-                    result.push(item);
-                }
-                reslove(result);
-            }));
+        const pList = this.divide(this._concurrent)
+            .map(async (subList) => {
+            const result = [];
+            for (let item of subList) {
+                for (const operation of this._operation)
+                    item = await operation(item);
+                result.push(item);
+            }
+            return (result);
         });
         const rlist = await Promise.all(pList);
         //拼接结果 轮询均分

package/dist/UtilFP.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFP = void 0;
-const QuickFunction_1 = require("./QuickFunction");
+const QuickExport_1 = require("./QuickExport");
 /**常用函数式编程库 */
 var UtilFP;
 (function (UtilFP) {
@@ -55,9 +55,9 @@ var UtilFP;
     }
     UtilFP.map = map;
     /**创建在传入值为失败时不运行的函数 */
-    UtilFP.chain = (f) => (arg) => (0, QuickFunction_1.isFailed)(arg) ? arg : f(arg);
+    UtilFP.chain = (f) => (arg) => (0, QuickExport_1.isFailed)(arg) ? arg : f(arg);
     /**创建在传入值为失败时才会尝试运行的函数 */
-    UtilFP.alt = (f) => (arg) => (0, QuickFunction_1.isFailed)(arg) ? f(arg) : arg;
+    UtilFP.alt = (f) => (arg) => (0, QuickExport_1.isFailed)(arg) ? f(arg) : arg;
     /**
     let asd = bindTo("sss",123,{abc:223});//?
     let sumvoid = ()=>10;

package/dist/UtilFfmpegTools.js

@@ -32,7 +32,7 @@ const pathe_1 = __importDefault(require("pathe"));
 const fs = __importStar(require("fs"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilClass_1 = require("./UtilClass");
-const QuickFunction_1 = require("./QuickFunction");
+const QuickExport_1 = require("./QuickExport");
 /**ffmpeg工具类
  */
 class SFfmpegTool {
@@ -193,11 +193,11 @@ class SFfmpegTool {
     static async isMono(filePath) {
         const metadata = await SFfmpegTool.getAudioMetaData(filePath);
         if (metadata == null)
-            (0, QuickFunction_1.throwError)("SFfmpegTool.isMono 获取音频元数据失败");
+            (0, QuickExport_1.throwError)("SFfmpegTool.isMono 获取音频元数据失败");
         // 检查音频流的声道数
         const audioStream = metadata.streams.find(stream => stream.codec_type === 'audio');
         if (audioStream == null)
-            (0, QuickFunction_1.throwError)("SFfmpegTool.isMono 未找到音频流");
+            (0, QuickExport_1.throwError)("SFfmpegTool.isMono 未找到音频流");
         return audioStream.channels === 1;
     }
     //多线程处理

package/dist/UtilFunctions.d.ts

@@ -141,66 +141,6 @@ export declare class UtilFunc {
      * @returns 转换完成的字符串
      */
     static stringifyJToken(token: JToken | IJData, opt?: StringifyOpt): string;
-    /**代办表 用于队列处理等待 */
-    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>;
     /**验证一个变量的类型是否为 T
      * @template T - 验证类型
      * @param t    - 验证目标
@@ -259,16 +199,6 @@ export declare class UtilFunc {
     private static publicIp?;
     /**获取当前公网ipv4 */
     static getPublicIpv4(): Promise<string>;
-    /**将传入函数包装为显式处理错误的函数
-     * @param func - 待转换函数
-     * @returns 转换完成的函数
-     */
-    static eitherize<T extends AnyFunc>(func: 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>>>>;
     /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
      * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
      * 请注意，这个函数使用了eval()，可能会带来安全风险。
@@ -291,11 +221,6 @@ export declare class UtilFunc {
         result: any;
         timestamp: number;
     }>>;
-    /**立即执行传入的函数
-     * @param fn - 需要立即执行的函数。
-     * @returns 返回 fn 函数的执行结果。
-     */
-    static ivk<T extends () => any>(fn: T): ReturnType<T>;
     /**创建一个带有缓存有效期的memoize函数
      * 只在传入值均为JToken时有效
      * @param fn     - 需要被memoize的函数
@@ -303,6 +228,76 @@ export declare class UtilFunc {
      * @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: 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格式 */
@@ -311,5 +306,14 @@ export declare class UtilFunc {
     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 {};

package/dist/UtilFunctions.js

@@ -49,6 +49,7 @@ const HashMethodList = ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "bl
 const NeverResolvedPromise = new Promise(() => { });
 /**常用函数 */
 class UtilFunc {
+    //#region 杂项
     /**获取当前时间戳
      * @returns 时间戳
      */
@@ -103,8 +104,8 @@ class UtilFunc {
         return crypto.createHash(method).update(str).digest('hex');
     }
     static async sleep(timeMs, result) {
-        return new Promise(function (resolve, rejecte) {
-            let timer = setTimeout(function () {
+        return new Promise((resolve, rejecte) => {
+            const timer = setTimeout(() => {
                 resolve(result);
             }, timeMs);
         });
@@ -385,6 +386,150 @@ class UtilFunc {
         return JSON.stringify(token, compressReplacer, space)
             .replace(new RegExp(`"${ec}(.*?)${ec}"`, 'g'), (match, p1) => p1.replace(/\\([\\"])/g, '$1'));
     }
+    /**验证一个变量的类型是否为 T
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertType(t) { return t; }
+    /**验证一个变量的类型是否为字面量
+     * 仅限浅层
+     * @template T - 验证类型
+     * @param t    - 验证目标
+     */
+    static assertLiteral(t) { return t; }
+    /**深克隆 序列化并反序列化
+     * @template T - JToken类型的泛型
+     * @param obj  - 克隆目标
+     * @returns 克隆结果
+     */
+    static deepClone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    /**是否为安全的数字
+     * 非NaN 非null/undefined
+     * 且是数字
+     * @param num - 所要检测的数字
+     * @returns 是否安全
+     */
+    static isSafeNumber(num) {
+        if (num == null)
+            return false;
+        if (typeof num === 'number') {
+            if (isNaN(num))
+                return false;
+            return true;
+        }
+        return false;
+    }
+    /**移除多行字符串中每行开始的最小空格数。
+     *
+     * @param input   - 需要处理的多行 字符串模板 或 字符串。
+     * @param values  - 插入模板字符串中的值。
+     * @returns 返回处理后的字符串，每行开始的空格数已被最小化。
+     *
+     * @example
+     * const name = 'World';
+     * const str = dedent`
+     *     Hello,
+     *         ${name}!
+     * `;
+     * console.log(str);
+     * // 输出：
+     * // Hello,
+     * //     World!
+     */
+    static dedent(input, ...values) {
+        const str = typeof input === 'string'
+            ? input
+            : input.reduce((result, string, i) => result + string + (values[i] ?? ''), '');
+        const lines = str.split('\n');
+        const minIndent = Math.min(...lines.filter(line => line.trim() !== '').map(line => line.search(/\S/)));
+        return lines.map(line => line.slice(minIndent)).join('\n');
+    }
+    /**抛出错误
+     * @param message - 错误信息
+     * @param lvl     - 日志等级
+     * @param opt     - 额外参数
+     */
+    static throwError(message, lvl, opt) {
+        const e = new Error(message);
+        const stackLines = e.stack.split('\n');
+        e.stack = [stackLines[0]].concat(stackLines.slice(2)).join('\n'); // 移除第一行的堆栈信息
+        Object.assign(e, opt);
+        if (lvl) {
+            //SLogger.log(lvl,message);
+            UtilLogger_1.SLogger.log(lvl, e.stack);
+        }
+        throw e;
+    }
+    /**获取函数调用位置 getFunctionLocation
+     * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
+     */
+    static getFuncLoc(stack = 1) {
+        const stackLines = new Error().stack.split('\n');
+        const regex = /([a-zA-Z]+?:.+?):(\d+?:\d+)/;
+        //console.log(stackLines)
+        const match = regex.exec(stackLines[stack + 1]);
+        if (match) {
+            const filePath = match[1];
+            const lineNumber = match[2];
+            return { filePath, lineNumber };
+        }
+        return undefined;
+    }
+    static publicIp;
+    /**获取当前公网ipv4 */
+    static async getPublicIpv4() {
+        if (UtilFunc.publicIp === undefined)
+            UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip');
+        return UtilFunc.publicIp.publicIpv4();
+    }
+    /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
+     * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
+     * 请注意，这个函数使用了eval()，可能会带来安全风险。
+     *
+     * @param moduleName - 需要导入的模块的名称。
+     * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+     *
+     * @example
+     * async function main() {
+     *   const pip = (await dynamicImport('public-ip')).default;
+     *   console.log(await pip.v4());
+     * }
+     * main();
+     *
+     * @since Node.js 13.2，Node.js开始支持动态import。
+     */
+    static async dynamicImport(moduleName) {
+        return await eval(`import('${moduleName}')`);
+    }
+    /**缓存池 */
+    static cachePool = new WeakMap();
+    /**创建一个带有缓存有效期的memoize函数
+     * 只在传入值均为JToken时有效
+     * @param fn     - 需要被memoize的函数
+     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
+     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
+     */
+    static memoize(fn, expiry = Infinity) {
+        const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(() => {
+            const c = new Map();
+            UtilFunc.cachePool.set(fn, c);
+            return c;
+        });
+        return ((...args) => {
+            const key = JSON.stringify(args);
+            const now = Date.now();
+            const cached = cache.get(key);
+            if (cached && now - cached.timestamp < expiry)
+                return cached.result;
+            const result = fn(...args);
+            cache.set(key, { result, timestamp: now });
+            return result;
+        });
+    }
+    //#endregion
+    //#region 队列处理
     /**代办表 用于队列处理等待 */
     static pendingMap = {};
     /**队列处理
@@ -447,6 +592,8 @@ class UtilFunc {
         const pd = UtilFunc.pendingMap[flag];
         return pd != null ? pd.length : 0;
     }
+    //#endregion
+    //#region symbol化处理工具
     /**创建一个Outcome */
     static outcome(key, value) {
         return {
@@ -544,104 +691,8 @@ class UtilFunc {
             UtilFunc.throwError(errLog ?? "expect验证了一个None值", "error");
         return t;
     }
-    /**验证一个变量的类型是否为 T
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertType(t) { return t; }
-    /**验证一个变量的类型是否为字面量
-     * 仅限浅层
-     * @template T - 验证类型
-     * @param t    - 验证目标
-     */
-    static assertLiteral(t) { return t; }
-    /**深克隆 序列化并反序列化
-     * @template T - JToken类型的泛型
-     * @param obj  - 克隆目标
-     * @returns 克隆结果
-     */
-    static deepClone(obj) {
-        return JSON.parse(JSON.stringify(obj));
-    }
-    /**是否为安全的数字
-     * 非NaN 非null/undefined
-     * 且是数字
-     * @param num - 所要检测的数字
-     * @returns 是否安全
-     */
-    static isSafeNumber(num) {
-        if (num == null)
-            return false;
-        if (typeof num === 'number') {
-            if (isNaN(num))
-                return false;
-            return true;
-        }
-        return false;
-    }
-    /**移除多行字符串中每行开始的最小空格数。
-     *
-     * @param input   - 需要处理的多行 字符串模板 或 字符串。
-     * @param values  - 插入模板字符串中的值。
-     * @returns 返回处理后的字符串，每行开始的空格数已被最小化。
-     *
-     * @example
-     * const name = 'World';
-     * const str = dedent`
-     *     Hello,
-     *         ${name}!
-     * `;
-     * console.log(str);
-     * // 输出：
-     * // Hello,
-     * //     World!
-     */
-    static dedent(input, ...values) {
-        const str = typeof input === 'string'
-            ? input
-            : input.reduce((result, string, i) => result + string + (values[i] ?? ''), '');
-        const lines = str.split('\n');
-        const minIndent = Math.min(...lines.filter(line => line.trim() !== '').map(line => line.search(/\S/)));
-        return lines.map(line => line.slice(minIndent)).join('\n');
-    }
-    /**抛出错误
-     * @param message - 错误信息
-     * @param lvl     - 日志等级
-     * @param opt     - 额外参数
-     */
-    static throwError(message, lvl, opt) {
-        const e = new Error(message);
-        const stackLines = e.stack.split('\n');
-        e.stack = [stackLines[0]].concat(stackLines.slice(2)).join('\n'); // 移除第一行的堆栈信息
-        Object.assign(e, opt);
-        if (lvl) {
-            //SLogger.log(lvl,message);
-            UtilLogger_1.SLogger.log(lvl, e.stack);
-        }
-        throw e;
-    }
-    /**获取函数调用位置 getFunctionLocation
-     * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
-     */
-    static getFuncLoc(stack = 1) {
-        const stackLines = new Error().stack.split('\n');
-        const regex = /([a-zA-Z]+?:.+?):(\d+?:\d+)/;
-        //console.log(stackLines)
-        const match = regex.exec(stackLines[stack + 1]);
-        if (match) {
-            const filePath = match[1];
-            const lineNumber = match[2];
-            return { filePath, lineNumber };
-        }
-        return undefined;
-    }
-    static publicIp;
-    /**获取当前公网ipv4 */
-    static async getPublicIpv4() {
-        if (UtilFunc.publicIp === undefined)
-            UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip');
-        return UtilFunc.publicIp.publicIpv4();
-    }
+    //#endregion
+    //#region 显式处理错误工具
     /**将传入函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数
@@ -676,57 +727,8 @@ class UtilFunc {
             }
         };
     }
-    /**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。
-     * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。
-     * 请注意，这个函数使用了eval()，可能会带来安全风险。
-     *
-     * @param moduleName - 需要导入的模块的名称。
-     * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
-     *
-     * @example
-     * async function main() {
-     *   const pip = (await dynamicImport('public-ip')).default;
-     *   console.log(await pip.v4());
-     * }
-     * main();
-     *
-     * @since Node.js 13.2，Node.js开始支持动态import。
-     */
-    static async dynamicImport(moduleName) {
-        return await eval(`import('${moduleName}')`);
-    }
-    /**缓存池 */
-    static cachePool = new WeakMap();
-    /**立即执行传入的函数
-     * @param fn - 需要立即执行的函数。
-     * @returns 返回 fn 函数的执行结果。
-     */
-    static ivk(fn) {
-        return fn();
-    }
-    /**创建一个带有缓存有效期的memoize函数
-     * 只在传入值均为JToken时有效
-     * @param fn     - 需要被memoize的函数
-     * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
-     * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
-     */
-    static memoize(fn, expiry = Infinity) {
-        const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(() => {
-            const c = new Map();
-            UtilFunc.cachePool.set(fn, c);
-            return c;
-        });
-        return ((...args) => {
-            const key = JSON.stringify(args);
-            const now = Date.now();
-            const cached = cache.get(key);
-            if (cached && now - cached.timestamp < expiry)
-                return cached.result;
-            const result = fn(...args);
-            cache.set(key, { result, timestamp: now });
-            return result;
-        });
-    }
+    //#endregion
+    //#region 解析srt
     /**将hh:mm:ss,ms格式转换为毫秒 */
     static parseSrtTime(time) {
         const [hours, minutes, seconds] = time.split(':');
@@ -770,6 +772,23 @@ class UtilFunc {
             return `${index + 1}\n${UtilFunc.formatSrtTime(segment.start)} --> ${UtilFunc.formatSrtTime(segment.end)}\n${segment.text}\n`;
         }).join('\n');
     }
+    //#endregion
+    //#region 常用直传的快速调用函数
+    /**立即执行传入的函数
+     * @param fn - 需要立即执行的函数。
+     * @returns 返回 fn 函数的执行结果。
+     */
+    static ivk(fn) {
+        return fn();
+    }
+    /**一个可供sort使用的从小到大排序的函数 */
+    static s2l(a, b) {
+        return a - b;
+    }
+    /**一个可供sort使用的从大到小排序的函数 */
+    static l2s(a, b) {
+        return b - a;
+    }
 }
 exports.UtilFunc = UtilFunc;
 __decorate([

package/dist/index.d.ts

@@ -9,5 +9,5 @@ export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
 export * from './UtilFP';
-export * from './QuickFunction';
+export * from './QuickExport';
 export * from './UtilI18n';

package/dist/index.js

@@ -25,5 +25,5 @@ __exportStar(require("./UtilDecorators"), exports);
 __exportStar(require("./UtilFileTools"), exports);
 __exportStar(require("./UtilLogger"), exports);
 __exportStar(require("./UtilFP"), exports);
-__exportStar(require("./QuickFunction"), exports);
+__exportStar(require("./QuickExport"), exports);
 __exportStar(require("./UtilI18n"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.192",
+	"version": "1.0.194",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/src/{QuickFunction.ts → QuickExport.ts}

@@ -24,7 +24,7 @@ export const {
     eitherize,
     taskEitherize,
     memoize,
-    ivk,
+    ivk,l2s,s2l,
 } = UtilFunc;
 
 export const {
@@ -67,5 +67,4 @@ if(false){
     let matt = matchProc(null as any as Outcome<symbol,123>,{
 
     })
-}
-
+}

package/src/UtilClass.ts

@@ -1,4 +1,4 @@
-import { matchProc } from "./QuickFunction";
+import { matchProc } from "./QuickExport";
 import { Keyable, Literal } from "./UtilInterfaces";
 import Handlebars from 'handlebars';
 import { SLogger } from "./UtilLogger";
@@ -137,23 +137,17 @@ export class Stream<T> implements Iterable<T>{
     async append(): Promise<Stream<T>> {
         if (this._operation.length == 0) return this;
 
-        const pList: Promise<T[]>[] = [];
         //均分处理
-        this.divide(this._concurrent).forEach((subList)=>{
-            if (!subList) return;
-            pList.push(
-                new Promise(async (reslove) => {
+        const pList = this.divide(this._concurrent)
+            .map(async (subList)=>{
                     const result:T[] = [];
                     for (let item of subList) {
-                        if (!item) continue;
                         for (const operation of this._operation)
                             item = await operation(item);
                         result.push(item);
                     }
-                    reslove(result);
-                })
-            );
-        })
+                    return (result);
+                });
         const rlist = await Promise.all(pList);
 
         //拼接结果 轮询均分

package/src/UtilFP.ts

@@ -1,4 +1,4 @@
-import { isFailed, likeNone } from "./QuickFunction";
+import { isFailed, likeNone } from "./QuickExport";
 import { AnyRecord, Keyable, Literal, Matchable, MatchableFlag, ProperSubset, ProperSubsetCheck } from "./UtilInterfaces";
 import { Failed, FailedLike, None } from "./UtilSymbol";
 

package/src/UtilFfmpegTools.ts

@@ -4,7 +4,7 @@ import path from "pathe";
 import * as fs from "fs";
 import { SLogger } from "@/src/UtilLogger";
 import { Stream } from "./UtilClass";
-import { throwError } from "./QuickFunction";
+import { throwError } from "./QuickExport";
 
 /**输入输出路径映射
  * 输入路径:输入路径

package/src/UtilFunctions.ts

@@ -73,6 +73,8 @@ type EachFieldCallback = (key: string, value: JToken,parent: JObject) => void;
 
 /**常用函数 */
 export class UtilFunc{
+
+//#region 杂项
 /**获取当前时间戳  
  * @returns 时间戳
  */
@@ -133,7 +135,6 @@ static calcHash(str:string,method:HashMethod='md5') {
     return crypto.createHash(method).update(str).digest('hex');
 }
 
-
 /**等待 timeMs 毫秒  
  * @async
  * @param timeMs - 等待的毫秒数
@@ -148,8 +149,8 @@ static async sleep<T>(timeMs: number): Promise<void>
  */
 static async sleep<T>(timeMs: number, result:T): Promise<T>
 static async sleep<T>(timeMs: number, result?:T): Promise<T|undefined> {
-    return new Promise(function (resolve, rejecte) {
-        let timer = setTimeout(function () {
+    return new Promise((resolve, rejecte) => {
+        const timer = setTimeout(() => {
             resolve(result);
         }, timeMs);
     });
@@ -456,6 +457,167 @@ static stringifyJToken(token:JToken|IJData,opt?:StringifyOpt){
             p1.replace(/\\([\\"])/g, '$1'));
 }
 
+/**验证一个变量的类型是否为 T
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertType<T>(t:T):T{return t;}
+
+/**验证一个变量的类型是否为字面量  
+ * 仅限浅层  
+ * @template T - 验证类型
+ * @param t    - 验证目标
+ */
+static assertLiteral<T>(t:Literal<T>):T{return t as T;}
+
+/**深克隆 序列化并反序列化  
+ * @template T - JToken类型的泛型
+ * @param obj  - 克隆目标
+ * @returns 克隆结果
+ */
+static deepClone<T extends JToken>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+}
+
+/**是否为安全的数字  
+ * 非NaN 非null/undefined  
+ * 且是数字  
+ * @param num - 所要检测的数字
+ * @returns 是否安全
+ */
+static isSafeNumber(num: unknown): boolean {
+    if (num == null) return false;
+    if(typeof num === 'number') {
+        if(isNaN(num)) return false;
+        return true;
+    }
+    return false;
+}
+
+/**移除多行字符串中每行开始的最小空格数。
+ *
+ * @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 {
+    const str = typeof input === 'string'
+        ? input
+        : input.reduce((result, string, i) => result + string + (values[i] ?? ''), '');
+    const lines = str.split('\n');
+    const minIndent = Math.min(
+        ...lines.filter(line => line.trim() !== '').map(line => line.search(/\S/))
+    );
+    return lines.map(line => line.slice(minIndent)).join('\n');
+}
+
+/**抛出错误
+ * @param message - 错误信息
+ * @param lvl     - 日志等级
+ * @param opt     - 额外参数
+ */
+static throwError(message:string,lvl?:LogLevel,opt?:{}):never{
+    const e = new Error(message);
+    const stackLines = e.stack!.split('\n');
+    e.stack = [stackLines[0]].concat(stackLines.slice(2)).join('\n'); // 移除第一行的堆栈信息
+    Object.assign(e, opt);
+    if(lvl){
+        //SLogger.log(lvl,message);
+        SLogger.log(lvl,e.stack);
+    }
+    throw e;
+}
+
+/**获取函数调用位置 getFunctionLocation 
+ * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
+ */
+static getFuncLoc(stack=1) {
+    const stackLines = new Error().stack!.split('\n');
+    const regex = /([a-zA-Z]+?:.+?):(\d+?:\d+)/;
+    //console.log(stackLines)
+    const match = regex.exec(stackLines[stack+1]);
+    if(match){
+        const filePath = match[1];
+        const lineNumber = match[2] as `${number}:${number}`;
+        return {filePath,lineNumber}
+    }
+    return undefined;
+}
+
+private static publicIp?:typeof publicIp;
+/**获取当前公网ipv4 */
+static async getPublicIpv4(){
+    if(UtilFunc.publicIp===undefined)
+        UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip') as typeof publicIp;
+    return UtilFunc.publicIp.publicIpv4();
+}
+
+/**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。  
+ * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。  
+ * 请注意，这个函数使用了eval()，可能会带来安全风险。  
+ *
+ * @param moduleName - 需要导入的模块的名称。
+ * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
+ *
+ * @example
+ * async function main() {
+ *   const pip = (await dynamicImport('public-ip')).default;
+ *   console.log(await pip.v4());
+ * }
+ * main();
+ *
+ * @since Node.js 13.2，Node.js开始支持动态import。
+ */
+static async dynamicImport(moduleName:string):Promise<any> {
+    return await eval(`import('${moduleName}')`);
+}
+
+/**缓存池 */
+static cachePool = new 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 = Infinity):
+    T extends (...args:infer In)=>any
+        ? AllExtends<In,JToken> extends true ? T : never
+        : never {
+    const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(()=>{
+        const c = new Map();
+        UtilFunc.cachePool.set(fn, c);
+        return c;
+    });
+
+    return ((...args: Parameters<T>): ReturnType<T> => {
+        const key = JSON.stringify(args);
+        const now = Date.now();
+        const cached = cache.get(key);
+
+        if (cached && now - cached.timestamp < expiry)
+            return cached.result;
+
+        const result = fn(...args);
+        cache.set(key, { result, timestamp: now });
+        return result;
+    }) as any;
+}
+//#endregion
+
+//#region 队列处理
 /**代办表 用于队列处理等待 */
 static pendingMap:Record<Keyable,AnyFunc[]> = {};
 
@@ -511,6 +673,7 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
     // 返回Promise，以便调用者可以等待任务完成
     return promise;
 }
+
 /**队列获取目标的代办事件数  
  * @param flag - 队列标签
  */
@@ -518,9 +681,9 @@ static queueLength(flag:Keyable){
     const pd = UtilFunc.pendingMap[flag]
     return pd!=null ? pd.length : 0;
 }
+//#endregion
 
-
-
+//#region symbol化处理工具
 /**创建一个Outcome */
 static outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
     return {
@@ -529,7 +692,6 @@ static outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
     }
 }
 
-
 /**处理联合值
  * @param t       - 目标值
  * @param procObj - 所有可能的id组成的处理函数映射 (status, result)=>any
@@ -581,8 +743,6 @@ static matchPartialProc<
     return undefined;
 }
 
-
-
 /**根据典型的成功或失败状态运行函数  
  * @param t - 目标值
  * @param sucessFunc - 成功则运行的函数 (result)=>any
@@ -605,6 +765,7 @@ static sucesProc<T extends Matchable<StatusSymbol>,
     if(t!==None) SLogger.warn(`sucesProc 传入了一个不匹配的值, 将作为None运行: `,t);
     return noneFunc() as any;
 }
+
 /**是失败的 */
 static isFailed<T>
     (tg:T):'E' extends ProperSubsetCheck<symbol,T>? boolean
@@ -654,113 +815,9 @@ static expect<T>(t:T,errLog?:string):Exclude<T,None>{
     if(t===None) UtilFunc.throwError(errLog??"expect验证了一个None值","error");
     return t as Exclude<T,None>;
 }
+//#endregion
 
-/**验证一个变量的类型是否为 T
- * @template T - 验证类型
- * @param t    - 验证目标
- */
-static assertType<T>(t:T):T{return t;}
-/**验证一个变量的类型是否为字面量  
- * 仅限浅层  
- * @template T - 验证类型
- * @param t    - 验证目标
- */
-static assertLiteral<T>(t:Literal<T>):T{return t as T;}
-
-/**深克隆 序列化并反序列化  
- * @template T - JToken类型的泛型
- * @param obj  - 克隆目标
- * @returns 克隆结果
- */
-static deepClone<T extends JToken>(obj: T): T {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-/**是否为安全的数字  
- * 非NaN 非null/undefined  
- * 且是数字  
- * @param num - 所要检测的数字
- * @returns 是否安全
- */
-static isSafeNumber(num: unknown): boolean {
-    if (num == null) return false;
-    if(typeof num === 'number') {
-        if(isNaN(num)) return false;
-        return true;
-    }
-    return false;
-}
-
-/**移除多行字符串中每行开始的最小空格数。
- *
- * @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 {
-    const str = typeof input === 'string'
-        ? input
-        : input.reduce((result, string, i) => result + string + (values[i] ?? ''), '');
-    const lines = str.split('\n');
-    const minIndent = Math.min(
-        ...lines.filter(line => line.trim() !== '').map(line => line.search(/\S/))
-    );
-    return lines.map(line => line.slice(minIndent)).join('\n');
-}
-/**抛出错误
- * @param message - 错误信息
- * @param lvl     - 日志等级
- * @param opt     - 额外参数
- */
-static throwError(message:string,lvl?:LogLevel,opt?:{}):never{
-    const e = new Error(message);
-    const stackLines = e.stack!.split('\n');
-    e.stack = [stackLines[0]].concat(stackLines.slice(2)).join('\n'); // 移除第一行的堆栈信息
-    Object.assign(e, opt);
-    if(lvl){
-        //SLogger.log(lvl,message);
-        SLogger.log(lvl,e.stack);
-    }
-    throw e;
-}
-
-/**获取函数调用位置 getFunctionLocation 
- * @param stack - 深度 默认1, 即getFuncLoc函数被调用的位置
- */
-static getFuncLoc(stack=1) {
-    const stackLines = new Error().stack!.split('\n');
-    const regex = /([a-zA-Z]+?:.+?):(\d+?:\d+)/;
-    //console.log(stackLines)
-    const match = regex.exec(stackLines[stack+1]);
-    if(match){
-        const filePath = match[1];
-        const lineNumber = match[2] as `${number}:${number}`;
-        return {filePath,lineNumber}
-    }
-    return undefined;
-}
-
-
-private static publicIp?:typeof publicIp;
-
-/**获取当前公网ipv4 */
-static async getPublicIpv4(){
-    if(UtilFunc.publicIp===undefined)
-        UtilFunc.publicIp = await UtilFunc.dynamicImport('public-ip') as typeof publicIp;
-    return UtilFunc.publicIp.publicIpv4();
-}
-
+//#region 显式处理错误工具
 /**将传入函数包装为显式处理错误的函数
  * @param func - 待转换函数
  * @returns 转换完成的函数
@@ -793,72 +850,9 @@ static taskEitherize<T extends (...args:any)=>Promise<any>>(func:T) {
         }
     };
 }
+//#endregion
 
-/**动态导入模块的函数。这个函数是为了在TypeScript的模块系统配置为CommonJS时，防止动态import被转译为require而设计的。  
- * 使用这个函数，你可以在TypeScript中动态地导入模块，而不需要担心import()被转译为require()。  
- * 请注意，这个函数使用了eval()，可能会带来安全风险。  
- *
- * @param moduleName - 需要导入的模块的名称。
- * @returns 返回一个Promise。当模块被成功导入时，这个Promise会解析为导入的模块。如果导入失败，这个Promise会被拒绝。
- *
- * @example
- * async function main() {
- *   const pip = (await dynamicImport('public-ip')).default;
- *   console.log(await pip.v4());
- * }
- * main();
- *
- * @since Node.js 13.2，Node.js开始支持动态import。
- */
-static async dynamicImport(moduleName:string):Promise<any> {
-    return await eval(`import('${moduleName}')`);
-}
-
-/**缓存池 */
-static cachePool = new WeakMap<Function, Map<string, { result: any, timestamp: number }>>();
-
-
-
-/**立即执行传入的函数  
- * @param fn - 需要立即执行的函数。
- * @returns 返回 fn 函数的执行结果。
- */
-static ivk<T extends ()=>any>(fn:T): ReturnType<T> {
-    return fn();
-}
-
-/**创建一个带有缓存有效期的memoize函数  
- * 只在传入值均为JToken时有效
- * @param fn     - 需要被memoize的函数
- * @param expiry - 缓存的有效期 毫秒 默认为Infinity, 表示缓存永不过期。
- * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
- */
-static memoize<T extends (...args:any[])=>any> (fn: T, expiry = Infinity):
-    T extends (...args:infer In)=>any
-        ? AllExtends<In,JToken> extends true ? T : never
-        : never {
-    const cache = UtilFunc.cachePool.get(fn) ?? UtilFunc.ivk(()=>{
-        const c = new Map();
-        UtilFunc.cachePool.set(fn, c);
-        return c;
-    });
-
-    return ((...args: Parameters<T>): ReturnType<T> => {
-        const key = JSON.stringify(args);
-        const now = Date.now();
-        const cached = cache.get(key);
-
-        if (cached && now - cached.timestamp < expiry)
-            return cached.result;
-
-        const result = fn(...args);
-        cache.set(key, { result, timestamp: now });
-        return result;
-    }) as any;
-}
-
-
-
+//#region 解析srt
 /**将hh:mm:ss,ms格式转换为毫秒 */
 static parseSrtTime(time: string): number {
     const [hours, minutes, seconds] = time.split(':');
@@ -908,5 +902,24 @@ static createSrt(segments: SrtSegment[]): string {
         return `${index + 1}\n${UtilFunc.formatSrtTime(segment.start)} --> ${UtilFunc.formatSrtTime(segment.end)}\n${segment.text}\n`;
     }).join('\n');
 }
+//#endregion
+
+//#region 常用直传的快速调用函数
+/**立即执行传入的函数  
+ * @param fn - 需要立即执行的函数。
+ * @returns 返回 fn 函数的执行结果。
+ */
+static ivk<T extends ()=>any>(fn:T): ReturnType<T> {
+    return fn();
+}
+/**一个可供sort使用的从小到大排序的函数 */
+static s2l(a:number,b:number) {
+    return a-b;
+}
+/**一个可供sort使用的从大到小排序的函数 */
+static l2s(a:number,b:number) {
+    return b-a;
+}
+//#endregion
 
 }

package/src/index.ts

@@ -9,5 +9,5 @@ export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
 export * from './UtilFP';
-export * from './QuickFunction';
+export * from './QuickExport';
 export * from './UtilI18n';

package/dist/ServiceManager.js

@@ -1 +0,0 @@
-"use strict";