hifun-tools 1.3.21 → 1.3.23

package/dist/init/__tests/utils.test.js

@@ -1,7 +1,7 @@
 /**
  * @jest-environment jsdom
  */
-import { isIPv4, extractRootDomain, isDomainMatch, toStandardUrl, getOptimalDecodedString, } from "../utils";
+import { isIPv4, isDomainMatch, toStandardUrl, getOptimalDecodedString, } from "../utils";
 // --------------------- isIPv4 -------------------------
 describe("isIPv4", () => {
     test("纯 IPv4", () => {
@@ -17,21 +17,6 @@ describe("isIPv4", () => {
         expect(isIPv4("localhost")).toBe(false);
     });
 });
-// --------------------- extractRootDomain -------------------------
-describe("extractRootDomain", () => {
-    test("普通域名", () => {
-        expect(extractRootDomain("https://sub.example.com")).toBe("example.com");
-    });
-    test("多级后缀", () => {
-        expect(extractRootDomain("a.b.example.com.cn")).toBe("example.com.cn");
-    });
-    test("无协议", () => {
-        expect(extractRootDomain("www.test.co.uk")).toBe("test.co.uk");
-    });
-    test("非法 URL 返回空", () => {
-        expect(extractRootDomain("%%%--非法")).toBe("");
-    });
-});
 // --------------------- isDomainMatch -------------------------
 describe("isDomainMatch", () => {
     test("匹配根域", () => {

package/dist/init/index.js

@@ -133,9 +133,9 @@ class InitCls {
             const response = await fetch(`/lineAddress.txt?t=${Date.now()}`);
             const configText = await response.text();
             let baseUrl = JSON.parse(AesDecrypt(configText));
-            const dict = this.getTenantDict();
+            const { lineGroup, tenant } = this.getTenantDict();
             const dictList = this.getTenantDictList();
-            baseUrl = filterSmartLines(dictList, baseUrl, dict?.lineGroup);
+            baseUrl = filterSmartLines(dictList, baseUrl, lineGroup, tenant);
             if (Array.isArray(baseUrl)) {
                 try {
                     this.domainBaseUrl = toStandardUrl(await getOptimalDecodedString(baseUrl));

package/dist/init/utils.d.ts

@@ -6,13 +6,6 @@ export type TenantDict = {
 };
 export declare function isIPv4(str: string): boolean;
 export declare function getOptimalDecodedString(encodedArray: string[]): Promise<string>;
-/**
- * 提取主域名（支持多级 TLD）
- */
-export declare function extractRootDomain(url: string): string;
-/**
- * 判断 b 是否匹配 a[] 中任意一个域名
- */
 export declare function isDomainMatch(list: string[], target: string): boolean;
 export declare function toStandardUrl(input: string): string;
 /**

package/dist/init/utils.js

@@ -61,74 +61,69 @@ export async function getOptimalDecodedString(encodedArray) {
     });
     return isIp ? await getOptimal(ipList) : await getOptimal(domainList);
 }
-/**
- * 常见多级后缀（Public Suffix List 的子集，可按需扩展）
- * 如 .co.uk、.com.cn、.gov.cn、.org.cn 等
- */
-const MULTI_LEVEL_TLDS = new Set([
-    "co.uk",
-    "org.uk",
-    "gov.uk",
-    "com.cn",
-    "net.cn",
-    "gov.cn",
-    "org.cn",
-    "co.jp",
-    "ne.jp",
-    "or.jp",
-    "go.jp",
-    "com.au",
-    "net.au",
-    "org.au",
-    "co.kr",
-    "ne.kr",
-    "or.kr",
-]);
-/**
- * 提取主域名（支持多级 TLD）
- */
-export function extractRootDomain(url) {
-    try {
-        url = url.trim(); // ✨ 增加
-        if (!/^https?:\/\//i.test(url)) {
-            url = "http://" + url;
-        }
-        const { hostname } = new URL(url);
-        const parts = hostname.split(".").filter(Boolean);
-        if (parts.length < 2)
-            return hostname;
-        const last2 = parts.slice(-2).join(".");
-        if (MULTI_LEVEL_TLDS.has(last2)) {
-            if (parts.length >= 3) {
-                return parts.slice(-3).join(".");
-            }
+function normalizeHost(hostname) {
+    hostname = hostname.trim().toLowerCase();
+    // 去掉典型协议
+    if (hostname.startsWith("http://") || hostname.startsWith("https://")) {
+        try {
+            hostname = new URL(hostname).hostname;
         }
-        return last2;
-    }
-    catch (e) {
-        return "";
+        catch (_) { }
     }
+    return hostname;
 }
 /**
- * 判断 b 是否匹配 a[] 中任意一个域名
+ * 域名是否严格匹配，允许 www 特例
+ *
+ * 允许：
+ *   www.a.com  <=>  a.com
+ *   完全相同
+ *
+ * 不允许：
+ *   1.a.com  vs 2.a.com
+ *   1.a.com  vs a.com
+ *   2.a.com  vs a.com
+ *   1.a.com  vs www.a.com
  */
+function isDomainStrictEqual(a, b) {
+    a = normalizeHost(a);
+    b = normalizeHost(b);
+    if (a === b)
+        return true;
+    // www 特例：只允许这种
+    // www.x.com <-> x.com
+    const stripWww = (h) => (h.startsWith("www.") ? h.slice(4) : h);
+    return stripWww(a) === stripWww(b);
+}
 export function isDomainMatch(list, target) {
-    const normalizedList = list.map(extractRootDomain).filter(Boolean);
-    const targetDomain = extractRootDomain(target);
-    return normalizedList.includes(targetDomain);
+    const t = normalizeHost(target);
+    return list.some((item) => {
+        const h = normalizeHost(item);
+        return isDomainStrictEqual(h, t);
+    });
 }
 export function toStandardUrl(input) {
     try {
-        input = input.trim(); // ✨ 增加
+        if (!input)
+            return "";
+        input = input.trim();
         let protocol = window?.location?.protocol || "https:";
+        // 如果没有 http / https，则自动补协议
         if (!/^https?:\/\//i.test(input)) {
             input = protocol + "//" + input;
         }
         const url = new URL(input);
-        return `${url.protocol}//${url.hostname}`;
+        const hostname = url.hostname;
+        // ❗ hostname 必须包含至少 1 个点 或是合法 IPv4，否则判断为无效
+        const isHostnameValid = /^[a-zA-Z0-9.-]+$/.test(hostname) &&
+            (hostname.includes(".") || isIPv4(hostname));
+        if (!isHostnameValid) {
+            return "";
+        }
+        return `${url.protocol}//${hostname}`;
     }
     catch (e) {
-        return input;
+        return "";
     }
 }
 /**
@@ -209,6 +204,7 @@ export function filterSmartLines(list1, list2, groupType, tenant) {
     if (groupType) {
         result = result.filter((item) => item.lineGroup === groupType);
     }
+    console.log("list2.map(toStandardUrl)", list2.map(toStandardUrl), list2);
     const lines = result.map((item) => toStandardUrl(item.line));
     return list2.map(toStandardUrl).filter((v) => isDomainMatch(lines, v)); // ✨ 使用域名匹配
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hifun-tools",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",