hifun-tools 1.3.29 → 1.3.31

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./request";
 export * from "./init";
 export * from "./utils";
+export * from "./msg";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./request";
 export * from "./init";
 export * from "./utils";
+export * from "./msg";

package/dist/init/index.d.ts

@@ -1,42 +1,57 @@
-import { filterSmartLines, getOptimalDecodedString, isDomainMatch, matchBrowser, TenantDict, toStandardUrl } from "./utils";
+import { isDomainMatch, filterSmartLines, getOptimalDecodedString, matchBrowser, TenantDict, toStandardUrl } from "./utils";
 import { AesDecrypt, AesEncrypt } from "./ende";
-type TenantConfig = {
-    PUBLIC_TITLE: string;
-    SITE_TITLE: string;
-    SITE_URL: string;
-    USER_TENANT: string;
-};
 declare class InitCls {
+    AesDecrypt: typeof AesDecrypt;
+    AesEncrypt: typeof AesEncrypt;
+    private appLine;
+    private appTenant;
+    private defaultBaseUrl;
     private domainBaseUrl;
+    private initialized;
+    private localPath;
+    private tenant;
     private tenantConfig;
     private tenantDict;
     private tenantDictList;
-    private initialized;
-    private tenant;
-    private defaultBaseUrl;
-    private localPath;
-    getBaseUrl(): string;
-    /** 获取配置 */
+    /** 初始化配置入口 */
+    InitConfig(options: {
+        fileType?: string[];
+        defaultBaseUrl?: string;
+        localPath?: string;
+        appLine?: string;
+        appTenant?: string;
+    }): Promise<(string | null)[]>;
+    /** 是否 App 环境 */
+    getIsApp(): boolean;
+    /** 获取租户名 */
+    getTenant(): string;
+    /** 获取租户配置 */
     getTenantConfig(): TenantConfig | null;
+    /** 获取租户字典 */
     getTenantDict(): TenantDict | null;
+    /** 获取租户字典列表 */
     getTenantDictList(): TenantDict[];
-    /** 获取租户名 */
-    getTenant(): string;
+    /** 获取基础 URL */
+    getBaseUrl(): string;
+    /** 获取图片路径 */
     getImgPath(imgName: string): string;
+    /** 严格初始化租户信息 */
+    private _initializeTenant;
     /** 严格同步获取租户信息 */
-    private getTenantInfoStrictSync;
-    /** 严格初始化（必须在应用启动时调用） */
-    private initialize;
-    InitConfig({ fileType, defaultBaseUrl, localPath, appDomain, appTenant, }: {
-        fileType?: string[];
-        defaultBaseUrl?: string;
-        localPath?: string;
-        appDomain?: string;
-        appTenant?: string;
-    }): Promise<any[]>;
-    private LoadGatewayConfig;
-    AesEncrypt: typeof AesEncrypt;
-    AesDecrypt: typeof AesDecrypt;
+    private _getTenantInfoStrictSync;
+    /** 匹配默认租户 */
+    private _matchDefaultTenant;
+    refreshHttp(): void;
+    /** 获取 lineDict.txt 内容 */
+    private _fetchLineDict;
+    /** 获取并处理 lineAddress.txt */
+    private _loadGatewayConfig;
 }
 declare const HF: InitCls;
+export type TenantConfig = {
+    PUBLIC_TITLE: string;
+    SITE_TITLE: string;
+    SITE_URL: string;
+    USER_TENANT: string;
+};
 export { HF, isDomainMatch, toStandardUrl, AesEncrypt, AesDecrypt, filterSmartLines, matchBrowser, getOptimalDecodedString, };

package/dist/init/index.js

@@ -1,188 +1,215 @@
+// index.ts
 import { getResource } from "./getResource";
-import { filterSmartLines, getOptimalDecodedString, isDomainMatch, matchBrowser, toStandardUrl, } from "./utils";
+import { isDomainMatch, filterSmartLines, getOptimalDecodedString, matchBrowser, toStandardUrl, difArr, } from "./utils";
 import { AesDecrypt, AesEncrypt } from "./ende";
+import { rewardMsg } from "../msg";
 class InitCls {
+    AesDecrypt = AesDecrypt;
+    AesEncrypt = AesEncrypt;
+    appLine = "";
+    appTenant = "";
+    defaultBaseUrl = "";
     domainBaseUrl = "";
+    initialized = false;
+    localPath = "";
+    tenant = "";
     tenantConfig = null;
     tenantDict = null;
     tenantDictList = [];
-    initialized = false;
-    tenant = "";
-    defaultBaseUrl = "";
-    localPath = "";
-    getBaseUrl() {
-        if (!this.domainBaseUrl) {
-            throw new Error("域名尚未初始化或初始化失败");
+    /** 初始化配置入口 */
+    async InitConfig(options) {
+        const { fileType, defaultBaseUrl, localPath, appLine, appTenant } = options;
+        if (defaultBaseUrl)
+            this.defaultBaseUrl = defaultBaseUrl;
+        if (localPath)
+            this.localPath = localPath;
+        if (appLine && appTenant) {
+            this.appLine = appLine;
+            this.appTenant = appTenant;
+            console.info("📱 appLine:", appLine, "appTenant:", appTenant);
         }
-        return this.domainBaseUrl;
+        console.info("📝 加载类型:", fileType);
+        const results = [];
+        if (fileType?.includes("lineDict")) {
+            console.info("初始化 lineDict...");
+            results.push(await this._initializeTenant());
+        }
+        if (fileType?.includes("lineAddress")) {
+            console.info("初始化 lineAddress...");
+            results.push(await this._loadGatewayConfig());
+        }
+        console.info("✅ 所有初始化完成:", results);
+        return results;
+    }
+    /** 是否 App 环境 */
+    getIsApp() {
+        return !!this.appTenant && !!this.appLine;
     }
-    /** 获取配置 */
+    /** 获取租户名 */
+    getTenant() {
+        return this.tenant;
+    }
+    /** 获取租户配置 */
     getTenantConfig() {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败getTenantConfig");
+            throw new Error("租户尚未初始化");
         }
         return this.tenantConfig;
     }
+    /** 获取租户字典 */
     getTenantDict() {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败getTenantDict");
+            throw new Error("租户尚未初始化");
         }
         return this.tenantDict;
     }
+    /** 获取租户字典列表 */
     getTenantDictList() {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败getTenantDictList");
+            throw new Error("租户尚未初始化");
         }
         return this.tenantDictList;
     }
-    /** 获取租户名 */
-    getTenant() {
-        return this.tenant;
+    /** 获取基础 URL */
+    getBaseUrl() {
+        if (!this.domainBaseUrl)
+            throw new Error("域名尚未初始化");
+        return this.domainBaseUrl;
     }
+    /** 获取图片路径 */
     getImgPath(imgName) {
         if (!this.initialized || !this.tenant) {
-            throw new Error("租户尚未初始化或初始化失败getImgPath");
+            throw new Error("租户尚未初始化");
         }
         return getResource(`${this.tenant}/image/${imgName}`);
     }
-    /** 严格同步获取租户信息 */
-    async getTenantInfoStrictSync() {
-        try {
-            const response = await fetch(`/lineDict.txt?t=${Date.now()}`, {
-                method: "GET",
-                cache: "no-store",
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP 状态码错误: ${response.status}`);
-            }
-            const rawText = await response.text();
-            const rawData = AesDecrypt(rawText);
-            const data = JSON.parse(rawData);
-            const host = location.host;
-            const matchedEntry = data.find((item) => {
-                return isDomainMatch([item.line], host);
-            });
-            this.tenantDictList = data;
-            if (matchedEntry) {
-                this.tenantDict = matchedEntry;
-                console.info(`🏠 匹配租户: ${matchedEntry.tenant}`);
-                return { tenant: matchedEntry.tenant };
-            }
-            // 默认租户匹配
-            if (host.includes("iggame") || host.includes("localhost")) {
-                console.info(`🏠 iggame匹配到默认租户2`);
-                return { tenant: "iggame" };
-            }
-            throw new Error("未找到匹配租户");
-        }
-        catch (error) {
-            console.error("解析 lineDict.txt 失败:", error);
-            const host = location.host;
-            if (host.includes("iggame") ||
-                host.includes("localhost") ||
-                (!!this.localPath &&
-                    location.origin.includes(this.localPath.replace(/\/+$/, "")))) {
-                console.info(`🏠 iggame匹配到默认租户1`);
-                return { tenant: "iggame" };
-            }
-            throw new Error("无法获取有效的租户信息");
-        }
-    }
-    /** 严格初始化（必须在应用启动时调用） */
-    async initialize(tenant) {
+    /** 严格初始化租户信息 */
+    async _initializeTenant() {
         if (this.initialized)
             return this.tenant;
         try {
-            if (tenant)
-                this.tenant = tenant;
-            else {
-                const tenantInfo = await this.getTenantInfoStrictSync();
-                this.tenant = tenantInfo.tenant;
-            }
+            const tenantInfo = await this._getTenantInfoStrictSync();
+            this.tenant = tenantInfo.tenant;
             this.tenantConfig = getResource(`${this.tenant}/config.json`);
             this.initialized = true;
-            console.info(`🏢 严格加载租户成功: ${this.tenant}`);
+            console.info("🏢 租户初始化成功:", this.tenant);
             return this.tenant;
         }
-        catch (error) {
-            console.error("严格租户加载失败:", error);
-            throw error;
+        catch (err) {
+            console.error("❌ 租户初始化失败:", err);
+            throw err;
         }
     }
-    async InitConfig({ fileType, defaultBaseUrl, localPath, appDomain, appTenant, }) {
-        if (appDomain && appTenant) {
-            this.initialize(appTenant);
-            this.domainBaseUrl = appDomain;
-            const results = [this.tenant, this.domainBaseUrl];
-            console.log("所有初始化完成:", results);
-            return results;
-        }
-        if (defaultBaseUrl) {
-            this.defaultBaseUrl = defaultBaseUrl;
+    /** 严格同步获取租户信息 */
+    async _getTenantInfoStrictSync() {
+        try {
+            const rawText = await this._fetchLineDict();
+            const data = JSON.parse(AesDecrypt(rawText));
+            const host = location.host;
+            this.tenantDictList = [...data];
+            if (this.getIsApp()) {
+                this.tenantDict = {
+                    browserCheck: [],
+                    line: host,
+                    lineGroup: this.appLine,
+                    tenant: this.appTenant,
+                };
+                this.tenantDictList.push(this.tenantDict);
+                console.info("🏠 匹配 App 租户:", this.tenantDict);
+                return { tenant: this.appTenant };
+            }
+            const matched = data.find((item) => isDomainMatch([item.line], host));
+            if (matched) {
+                this.tenantDict = matched;
+                console.info("🏠 匹配租户:", matched.tenant);
+                return { tenant: matched.tenant };
+            }
+            return this._matchDefaultTenant();
         }
-        if (localPath) {
-            this.localPath = localPath;
+        catch (err) {
+            console.warn("⚠️ 解析 lineDict.txt 失败:", err);
+            return this._matchDefaultTenant();
         }
-        console.log("加载类型:", fileType);
-        const results = [];
-        if (fileType?.includes("lineDict")) {
-            console.log("初始化 lineDict...");
-            const res1 = await this.initialize();
-            results.push(res1);
+    }
+    /** 匹配默认租户 */
+    _matchDefaultTenant() {
+        const host = location.host;
+        if (host.includes("iggame") ||
+            host.includes("localhost") ||
+            (!!this.localPath &&
+                location.origin.includes(this.localPath.replace(/\/+$/, "")))) {
+            console.info("🏠 匹配默认租户 iggame");
+            return { tenant: "iggame" };
+        }
+        throw new Error("无法获取有效的租户信息");
+    }
+    refreshHttp() {
+        try {
+            getOptimalDecodedString([this.getBaseUrl()]);
         }
-        if (fileType?.includes("lineAddress")) {
-            console.log("初始化 lineAddress...");
-            const res2 = await this.LoadGatewayConfig();
-            results.push(res2);
+        catch (error) {
+            rewardMsg({
+                title: "提示",
+                text: "网络环境异常，刷新页面以重置",
+                onSubmit() {
+                    location.reload();
+                },
+            });
         }
-        console.log("所有初始化完成:", results);
-        return results;
     }
-    async LoadGatewayConfig() {
+    /** 获取 lineDict.txt 内容 */
+    async _fetchLineDict() {
+        const response = await fetch(`/lineDict.txt?t=${Date.now()}`, {
+            method: "GET",
+            cache: "no-store",
+        });
+        if (!response.ok)
+            throw new Error(`HTTP 错误: ${response.status}`);
+        return response.text();
+    }
+    /** 获取并处理 lineAddress.txt */
+    async _loadGatewayConfig() {
         if (this.domainBaseUrl)
             return this.domainBaseUrl;
         try {
             const response = await fetch(`/lineAddress.txt?t=${Date.now()}`);
             const configText = await response.text();
-            let baseUrl = JSON.parse(AesDecrypt(configText));
-            const { lineGroup } = this.getTenantDict();
+            const OriginBaseUrl = JSON.parse(AesDecrypt(configText));
             const dictList = this.getTenantDictList();
-            baseUrl = filterSmartLines(dictList, baseUrl, lineGroup);
-            if (Array.isArray(baseUrl)) {
+            const lineGroup = this.getTenantDict()?.lineGroup;
+            let baseUrl = filterSmartLines(dictList, OriginBaseUrl, lineGroup);
+            try {
+                this.domainBaseUrl = toStandardUrl(await getOptimalDecodedString(baseUrl));
+                console.info("✅ 成功加载生产环境配置:", this.domainBaseUrl);
+            }
+            catch {
+                // 备用策略
+                let allBaseUrl = filterSmartLines(dictList, OriginBaseUrl);
                 try {
-                    this.domainBaseUrl = toStandardUrl(await getOptimalDecodedString(baseUrl));
-                    console.log("✅ 成功加载生产环境配置(测速选择):", this.domainBaseUrl);
+                    this.domainBaseUrl = toStandardUrl(await getOptimalDecodedString(difArr(allBaseUrl, baseUrl)));
+                    console.info("✅ 备用配置成功:", this.domainBaseUrl);
                 }
-                catch (error) {
-                    this.domainBaseUrl = toStandardUrl(baseUrl[0]);
-                    console.warn("⚠️ 测速失败，使用第一个配置:", this.domainBaseUrl, error);
+                catch {
+                    this.domainBaseUrl = toStandardUrl(allBaseUrl[0]);
+                    console.warn("⚠️ 备选测速失败，使用备用配置:", allBaseUrl);
                 }
             }
-            else {
-                this.domainBaseUrl = toStandardUrl(baseUrl);
-                console.log("✅ 成功加载生产环境配置:", this.domainBaseUrl);
-            }
             return this.domainBaseUrl;
         }
-        catch (error) {
-            console.error(error);
+        catch (err) {
+            console.error("⚠️ 加载 lineAddress.txt 失败:", err);
             if ((this.defaultBaseUrl &&
                 (location.host.includes("iggame") ||
                     location.host.includes("localhost"))) ||
                 (!!this.localPath &&
                     location.origin.includes(this.localPath.replace(/\/+$/, "")))) {
-                console.info(`🏠 iggame匹配到默认链接`, this.defaultBaseUrl);
                 this.domainBaseUrl = toStandardUrl(this.defaultBaseUrl);
+                console.info("🏠 使用默认 BaseUrl:", this.domainBaseUrl);
                 return this.domainBaseUrl;
             }
-            else {
-                console.warn("⚠️ 加载 lineAddress.txt 失败:", error);
-                return null;
-            }
+            return null;
         }
     }
-    AesEncrypt = AesEncrypt;
-    AesDecrypt = AesDecrypt;
 }
 const HF = new InitCls();
 export { HF, isDomainMatch, toStandardUrl, AesEncrypt, AesDecrypt, filterSmartLines, matchBrowser, getOptimalDecodedString, };

package/dist/init/utils.d.ts

@@ -4,9 +4,28 @@ export type TenantDict = {
     lineGroup: string;
     tenant: string;
 };
-export declare function isIPv4(str: string): boolean;
-export declare function getOptimalDecodedString(encodedArray: string[], filterIp?: boolean): Promise<string>;
+/** 保留端口，去掉协议 */
+export declare function normalizeHost(hostname: string): string;
+/** 域名严格匹配，允许 www 特例 */
+export declare function isDomainStrictEqual(a: string, b: string): boolean;
 export declare function isDomainMatch(list: string[], target: string): boolean;
-export declare function toStandardUrl(input: string): string;
+/** 检查是否 IPv4 */
+export declare function isIPv4(str: string): boolean;
+export declare function detectBrowser(): string;
+/** 匹配浏览器 */
 export declare function matchBrowser(checkItem: string, currentBrowser: string): boolean;
-export declare function filterSmartLines(list1: TenantDict[], list2: string[], groupType?: string, tenant?: string): string[];
+/** 标准化 URL */
+export declare function toStandardUrl(input: string): string;
+/** 根据浏览器和租户过滤线路 */
+export declare function filterSmartLines(tenantList: TenantDict[], lineList: string[], groupType?: string, tenant?: string): string[];
+/** 并发测速获取最佳 URL（限制超时和并发） */
+export declare function getOptimalDecodedString(arr: string[], options?: {
+    error?: (arr: string[]) => void;
+    filterIp?: boolean;
+}): Promise<string>;
+/**
+ * 返回两个数组的差集（对称差集）
+ * @param arr1 第一个数组
+ * @param arr2 第二个数组
+ */
+export declare function difArr(arr1: string[], arr2: string[]): string[];

package/dist/init/utils.js

@@ -1,135 +1,45 @@
-export function isIPv4(str) {
-    if (str.startsWith("http://") || str.startsWith("https://")) {
-        try {
-            const url = new URL(str);
-            str = url.hostname;
-        }
-        catch {
-            return false;
-        }
-    }
-    if (str === "localhost")
-        return false;
-    const ipv4Regex = /^(25[0-5]|2[0-4]\d|1?\d{1,2})(\.(25[0-5]|2[0-4]\d|1?\d{1,2})){3}$/;
-    return ipv4Regex.test(str);
-}
-export async function getOptimalDecodedString(encodedArray, filterIp = true) {
-    if (!encodedArray?.length)
-        throw new Error("输入数组为空或无效");
-    const hostname = window.location.hostname;
-    const isIp = isIPv4(hostname);
-    const decodedList = encodedArray
-        .filter(Boolean)
-        .map((v) => v.trim());
-    const ipList = decodedList.filter((v) => isIPv4(v));
-    const domainList = decodedList.filter((v) => !isIPv4(v));
-    const getOptimal = (arr) => new Promise((resolve) => {
-        if (!arr.length) {
-            resolve("");
-            return;
-        }
-        const currentProtocol = window.location.protocol;
-        const filteredArr = arr.filter((url) => url.startsWith("http") ? url.startsWith(currentProtocol) : true);
-        const targetArr = filteredArr.length ? filteredArr : arr;
-        if (targetArr.length === 1)
-            return resolve(targetArr[0]);
-        let hasResolved = false;
-        targetArr.forEach((url) => {
-            const testUrl = `${toStandardUrl(url)}/health?t=${Date.now()}`;
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => {
-                controller.abort();
-            }, 3000);
-            fetch(testUrl, { method: "GET", signal: controller.signal })
-                .then(() => {
-                clearTimeout(timeoutId);
-                if (!hasResolved) {
-                    hasResolved = true;
-                    resolve(url);
-                }
-            })
-                .catch(() => clearTimeout(timeoutId));
-        });
-        setTimeout(() => {
-            if (!hasResolved) {
-                hasResolved = true;
-                resolve(targetArr[0]);
-            }
-        }, 3500);
-    });
-    return !filterIp
-        ? await getOptimal(decodedList)
-        : isIp
-            ? await getOptimal(ipList)
-            : await getOptimal(domainList);
-}
-/**
- * normalizeHost：保留端口，只清理协议
- */
-function normalizeHost(hostname) {
+/** 浏览器识别（结果缓存） */
+let cachedBrowser = null;
+/** 保留端口，去掉协议 */
+export function normalizeHost(hostname) {
     hostname = hostname.trim().toLowerCase();
-    // 如果没有协议，加上 http:// 方便 URL 解析
-    let urlStr = hostname;
-    if (!/^https?:\/\//i.test(hostname)) {
-        urlStr = "http://" + hostname;
-    }
+    const urlStr = /^https?:\/\//i.test(hostname)
+        ? hostname
+        : `http://${hostname}`;
     try {
         const url = new URL(urlStr);
-        // 保留 hostname + port
         return url.port ? `${url.hostname}:${url.port}` : url.hostname;
     }
-    catch (_) {
-        return hostname; // 保留原始字符串
+    catch {
+        return hostname;
     }
 }
-/**
- * 域名严格匹配，允许 www 特例
- */
-function isDomainStrictEqual(a, b) {
-    a = normalizeHost(a);
-    b = normalizeHost(b);
-    if (a === b)
-        return true;
+/** 域名严格匹配，允许 www 特例 */
+export function isDomainStrictEqual(a, b) {
     const stripWww = (h) => (h.startsWith("www.") ? h.slice(4) : h);
-    return stripWww(a) === stripWww(b);
+    return stripWww(normalizeHost(a)) === stripWww(normalizeHost(b));
 }
 export function isDomainMatch(list, target) {
     const t = normalizeHost(target);
-    return list.some((item) => {
-        const h = normalizeHost(item);
-        return isDomainStrictEqual(h, t);
-    });
+    return list.some((item) => isDomainStrictEqual(item, t));
 }
-export function toStandardUrl(input) {
-    try {
-        if (!input)
-            return "";
-        input = input.trim();
-        let protocol = window?.location?.protocol || "https:";
-        if (!/^https?:\/\//i.test(input)) {
-            input = protocol + "//" + input;
+/** 检查是否 IPv4 */
+export function isIPv4(str) {
+    if (str.startsWith("http")) {
+        try {
+            str = new URL(str).hostname;
         }
-        const url = new URL(input);
-        const hostname = url.hostname;
-        const port = url.port;
-        const isHostnameValid = hostname === "localhost" ||
-            (/^[a-zA-Z0-9.-]+$/.test(hostname) &&
-                (hostname.includes(".") || isIPv4(hostname)));
-        if (!isHostnameValid) {
-            return "";
+        catch {
+            return false;
         }
-        return port
-            ? `${url.protocol}//${hostname}:${port}`
-            : `${url.protocol}//${hostname}`;
-    }
-    catch (e) {
-        return "";
     }
+    if (str === "localhost")
+        return false;
+    return /^(25[0-5]|2[0-4]\d|1?\d{1,2})(\.(25[0-5]|2[0-4]\d|1?\d{1,2})){3}$/.test(str);
 }
-/**
- * 浏览器识别
- */
-function detectBrowser() {
+export function detectBrowser() {
+    if (cachedBrowser)
+        return cachedBrowser;
     const ua = navigator.userAgent.toLowerCase();
     const rules = [
         { key: "baidu", regex: /baidubrowser|baiduboxapp|baidu/i },
@@ -152,43 +62,128 @@ function detectBrowser() {
         { key: "alipay", regex: /alipayclient/i },
         { key: "douyin", regex: /aweme|douyin/i },
     ];
-    for (const item of rules) {
-        if (item.exclude && item.exclude.test(ua))
+    for (const { key, regex, exclude } of rules) {
+        if (exclude && exclude.test(ua))
             continue;
-        if (item.regex.test(ua))
-            return item.key;
+        if (regex.test(ua))
+            return (cachedBrowser = key);
     }
-    return "unknown";
+    return (cachedBrowser = "unknown");
 }
+/** 匹配浏览器 */
 export function matchBrowser(checkItem, currentBrowser) {
     if (!checkItem || !currentBrowser)
         return false;
-    const normalized = checkItem.toString().toLowerCase();
+    const normalized = checkItem.toLowerCase();
     const browser = currentBrowser.toLowerCase();
     if (normalized.startsWith("/") && normalized.endsWith("/")) {
         try {
-            const body = normalized.slice(1, -1);
-            const regex = new RegExp(body, "i");
-            return regex.test(browser);
+            return new RegExp(normalized.slice(1, -1), "i").test(browser);
         }
-        catch (_) { }
+        catch { }
     }
     return browser.includes(normalized);
 }
-export function filterSmartLines(list1, list2, groupType, tenant) {
-    if (!Array.isArray(list1) || !Array.isArray(list2)) {
-        throw new Error("前两个参数必须是数组");
+/** 标准化 URL */
+export function toStandardUrl(input) {
+    if (!input)
+        return "";
+    input = input.trim();
+    const protocol = window?.location?.protocol || "https:";
+    if (!/^https?:\/\//i.test(input))
+        input = `${protocol}//${input}`;
+    try {
+        const url = new URL(input);
+        const hostname = url.hostname;
+        const port = url.port;
+        if (hostname !== "localhost" &&
+            !(/^[a-zA-Z0-9.-]+$/.test(hostname) &&
+                (hostname.includes(".") || isIPv4(hostname)))) {
+            return "";
+        }
+        return port
+            ? `${url.protocol}//${hostname}:${port}`
+            : `${url.protocol}//${hostname}`;
     }
+    catch {
+        return "";
+    }
+}
+/** 根据浏览器和租户过滤线路 */
+export function filterSmartLines(tenantList, lineList, groupType, tenant) {
+    if (!Array.isArray(tenantList) || !Array.isArray(lineList))
+        throw new Error("参数必须是数组");
     const currentBrowser = detectBrowser();
-    let result = list1.filter((item) => {
-        const checks = item.browserCheck || [];
-        const blocked = checks.some((checkItem) => matchBrowser(checkItem, currentBrowser));
-        return !blocked;
-    });
+    let filtered = tenantList.filter((item) => !(item.browserCheck || []).some((check) => matchBrowser(check, currentBrowser)));
     if (tenant)
-        result = result.filter((item) => item.tenant === tenant);
+        filtered = filtered.filter((item) => item.tenant === tenant);
     if (groupType)
-        result = result.filter((item) => item.lineGroup === groupType);
-    const lines = result.map((item) => toStandardUrl(item.line));
-    return list2.map(toStandardUrl).filter((v) => isDomainMatch(lines, v));
+        filtered = filtered.filter((item) => item.lineGroup === groupType);
+    const lines = filtered.map((item) => toStandardUrl(item.line));
+    return lineList.map(toStandardUrl).filter((v) => isDomainMatch(lines, v));
+}
+/** 并发测速获取最佳 URL（限制超时和并发） */
+export async function getOptimalDecodedString(arr, options) {
+    if (!arr?.length)
+        throw new Error("输入数组为空");
+    const { error, filterIp = true } = options || {};
+    const hostname = window.location.hostname;
+    const isIp = isIPv4(hostname);
+    // 过滤逻辑
+    let targetArr = arr.filter(Boolean).map((v) => v.trim());
+    if (filterIp) {
+        targetArr = isIp
+            ? targetArr.filter(isIPv4)
+            : targetArr.filter((v) => !isIPv4(v));
+    }
+    if (!targetArr.length)
+        throw new Error("无可用地址");
+    const failedUrls = [];
+    const controllerMap = {};
+    return new Promise((resolve, reject) => {
+        let resolved = false;
+        targetArr.forEach((url) => {
+            const controller = new AbortController();
+            controllerMap[url] = controller;
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+                failedUrls.push(url);
+            }, 3000);
+            fetch(`${toStandardUrl(url)}/health?t=${Date.now()}`, {
+                signal: controller.signal,
+            })
+                .then(() => {
+                clearTimeout(timeoutId);
+                if (!resolved) {
+                    resolved = true;
+                    resolve(url);
+                }
+            })
+                .catch(() => {
+                clearTimeout(timeoutId);
+                failedUrls.push(url);
+            });
+        });
+        // 等待所有请求完成
+        setTimeout(() => {
+            if (failedUrls.length && error) {
+                error(failedUrls);
+            }
+            if (!resolved) {
+                reject({ message: "测速全部失败", failedUrls });
+            }
+        }, 3500);
+    });
+}
+/**
+ * 返回两个数组的差集（对称差集）
+ * @param arr1 第一个数组
+ * @param arr2 第二个数组
+ */
+export function difArr(arr1, arr2) {
+    const set1 = new Set(arr1.map((v) => v.trim()));
+    const set2 = new Set(arr2.map((v) => v.trim()));
+    const diff1 = [...set1].filter((v) => !set2.has(v));
+    const diff2 = [...set2].filter((v) => !set1.has(v));
+    return [...diff1, ...diff2];
 }

package/dist/msg/index.d.ts

@@ -0,0 +1,18 @@
+export interface MsgOptions {
+    type?: "info" | "success" | "warning" | "error";
+    duration?: number;
+    closable?: boolean;
+    onClose?: () => void;
+}
+export declare function msg(message: string, options?: MsgOptions): void;
+export interface RewardOptions {
+    title?: string;
+    text?: string;
+    topImg?: string;
+    submitText?: string;
+    cancelText?: string;
+    onSubmit?: () => void;
+    onCancel?: () => void;
+    onClose?: () => void;
+}
+export declare function rewardMsg(options: RewardOptions): void;

package/dist/msg/index.js

@@ -0,0 +1,270 @@
+let isRewardShowing = false;
+// --------------------------- 普通消息 ---------------------------
+let messageStackContainer = null;
+// --------------------------- reward 弹窗 ---------------------------
+let rewardMask = null;
+const rewardQueue = [];
+let rewardStackContainer = null;
+function getMessageStackContainer() {
+    if (!messageStackContainer) {
+        messageStackContainer = document.createElement("div");
+        Object.assign(messageStackContainer.style, {
+            position: "fixed",
+            bottom: "10vh",
+            left: "50%",
+            transform: "translateX(-50%)",
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            gap: "10px",
+            zIndex: "9999",
+            pointerEvents: "none",
+            width: "100%",
+            maxWidth: "calc(100% - 40px)",
+        });
+        document.body.appendChild(messageStackContainer);
+    }
+    return messageStackContainer;
+}
+function hideMsg(element, callback) {
+    element.style.opacity = "0";
+    element.style.transform += " translateY(20px)";
+    setTimeout(() => {
+        element.parentNode?.removeChild(element);
+        callback?.();
+    }, 300);
+}
+function getColorByType(type) {
+    switch (type) {
+        case "success":
+            return "#67C23A";
+        case "warning":
+            return "#E6A23C";
+        case "error":
+            return "#F56C6C";
+        case "info":
+            return "#409EFF";
+        default:
+            return "#409EFF";
+    }
+}
+function getRewardMask() {
+    if (!rewardMask) {
+        rewardMask = document.createElement("div");
+        Object.assign(rewardMask.style, {
+            position: "fixed",
+            top: "0",
+            left: "0",
+            width: "100vw",
+            height: "100vh",
+            background: "rgba(0,0,0,0.5)",
+            zIndex: "100000",
+            pointerEvents: "auto",
+            display: "flex",
+            justifyContent: "center",
+            alignItems: "center",
+        });
+        document.body.appendChild(rewardMask);
+    }
+    return rewardMask;
+}
+function getRewardStackContainer() {
+    if (!rewardStackContainer) {
+        rewardStackContainer = document.createElement("div");
+        Object.assign(rewardStackContainer.style, {
+            position: "relative",
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            gap: "12px",
+            width: "100%",
+            maxWidth: "calc(100% - 40px)",
+        });
+        getRewardMask().appendChild(rewardStackContainer);
+    }
+    return rewardStackContainer;
+}
+function showNextReward() {
+    if (isRewardShowing || rewardQueue.length === 0)
+        return;
+    const options = rewardQueue.shift();
+    isRewardShowing = true;
+    const mask = getRewardMask();
+    const originalOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    const container = document.createElement("div");
+    container.className = "rewardWindow";
+    Object.assign(container.style, {
+        position: "relative",
+        width: "calc(100% - 60px)",
+        maxWidth: "370px",
+        paddingTop: options.topImg ? "88px" : "23px",
+        backgroundColor: "#fff",
+        borderRadius: "12px",
+        boxSizing: "border-box",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        textAlign: "center",
+        opacity: "0",
+        transform: "scale(0.9)",
+        transition: "all 0.3s cubic-bezier(0.4,0,0.2,1)",
+        overflow: "hidden",
+        zIndex: "100001",
+    });
+    if (options.title) {
+        const titleEl = document.createElement("div");
+        titleEl.textContent = options.title;
+        Object.assign(titleEl.style, {
+            fontSize: "16px",
+            fontWeight: "600",
+            color: "#303442",
+        });
+        container.appendChild(titleEl);
+    }
+    if (options.topImg) {
+        const imgEl = document.createElement("img");
+        imgEl.src = options.topImg;
+        Object.assign(imgEl.style, {
+            position: "absolute",
+            top: "-68px",
+            height: "150px",
+            width: "150px",
+        });
+        container.appendChild(imgEl);
+    }
+    if (options.text) {
+        const textEl = document.createElement("div");
+        textEl.innerHTML = options.text;
+        Object.assign(textEl.style, {
+            padding: "14px 22px 12px",
+            fontSize: "12px",
+            fontWeight: "500",
+            lineHeight: "16px",
+            textAlign: "center",
+            width: "100%",
+            overflow: "hidden",
+            wordBreak: "break-word",
+            color: "#7981A4",
+        });
+        container.appendChild(textEl);
+    }
+    const btnContainer = document.createElement("div");
+    Object.assign(btnContainer.style, {
+        display: "flex",
+        width: "100%",
+        height: "44px",
+        borderTop: "1px solid #f2f2f6",
+        padding: "8px 0",
+    });
+    const btnStyle = {
+        flex: "1",
+        border: "none",
+        background: "transparent",
+        cursor: "pointer",
+        fontSize: "14px",
+        fontWeight: "500",
+    };
+    if (options.cancelText) {
+        const cancelBtn = document.createElement("button");
+        cancelBtn.textContent = options.cancelText;
+        Object.assign(cancelBtn.style, {
+            ...btnStyle,
+            borderRight: "1px solid #f2f2f6",
+            color: "#303442",
+        });
+        cancelBtn.onclick = () => closeReward(container, options.onCancel ?? options.onClose, originalOverflow);
+        btnContainer.appendChild(cancelBtn);
+    }
+    const confirmBtn = document.createElement("button");
+    confirmBtn.textContent = options.submitText || "确认";
+    Object.assign(confirmBtn.style, {
+        ...btnStyle,
+        color: "#179CFF",
+    });
+    confirmBtn.onclick = () => {
+        options.onSubmit?.();
+        closeReward(container, options.onClose, originalOverflow);
+    };
+    btnContainer.appendChild(confirmBtn);
+    container.appendChild(btnContainer);
+    const stack = getRewardStackContainer();
+    stack.appendChild(container);
+    requestAnimationFrame(() => {
+        container.style.opacity = "1";
+        container.style.transform = "scale(1)";
+    });
+}
+function closeReward(container, callback, originalOverflow) {
+    container.style.opacity = "0";
+    container.style.transform = "scale(0.9)";
+    setTimeout(() => {
+        container.parentNode?.removeChild(container);
+        callback?.();
+        if (rewardStackContainer?.childElementCount === 0) {
+            rewardMask?.remove();
+            rewardMask = null;
+            rewardStackContainer = null;
+            document.body.style.overflow = originalOverflow ?? "";
+        }
+        isRewardShowing = false;
+        showNextReward(); // 显示下一个弹窗
+    }, 300);
+}
+export function msg(message, options = {}) {
+    const { type = "info", duration = 3000, closable = false, onClose } = options;
+    const container = document.createElement("div");
+    Object.assign(container.style, {
+        backgroundColor: getColorByType(type),
+        color: "#fff",
+        borderRadius: "12px",
+        fontSize: "12px",
+        fontWeight: "500",
+        padding: "10px 16px",
+        maxWidth: "400px",
+        minWidth: "120px",
+        textAlign: "center",
+        display: "-webkit-box",
+        WebkitLineClamp: "2",
+        WebkitBoxOrient: "vertical",
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        wordWrap: "break-word",
+        boxShadow: "0 6px 18px rgba(0,0,0,0.12)",
+        opacity: "0",
+        transform: "translateY(20px)",
+        transition: "all 0.3s cubic-bezier(0.4,0,0.2,1)",
+        pointerEvents: "auto",
+        position: "relative",
+    });
+    container.textContent = message;
+    if (closable) {
+        const closeBtn = document.createElement("span");
+        closeBtn.innerHTML = "×";
+        Object.assign(closeBtn.style, {
+            position: "absolute",
+            top: "50%",
+            right: "10px",
+            transform: "translateY(-50%)",
+            cursor: "pointer",
+            fontSize: "14px",
+            fontWeight: "bold",
+        });
+        closeBtn.onclick = () => hideMsg(container, onClose);
+        container.appendChild(closeBtn);
+        container.style.paddingRight = "30px";
+    }
+    const stack = getMessageStackContainer();
+    stack.appendChild(container);
+    requestAnimationFrame(() => {
+        container.style.opacity = "1";
+        container.style.transform = "translateY(0)";
+    });
+    if (duration > 0) {
+        setTimeout(() => hideMsg(container, onClose), duration);
+    }
+}
+export function rewardMsg(options) {
+    rewardQueue.push(options);
+    showNextReward();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hifun-tools",
-  "version": "1.3.29",
+  "version": "1.3.31",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,9 +17,13 @@
     "dist"
   ],
   "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
     "@types/jest": "^30.0.0",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
+    "jscodeshift": "^17.3.0",
+    "prettier": "^3.6.2",
     "ts-jest": "^29.4.5",
     "typescript": "^5.6.3"
   },