ddan-js 2.9.0 → 2.9.2

package/bin/lib/modules/convert/md5.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utf8_1 = require("./utf8");
+const base_1 = require("./base");
+const base64_1 = require("./base64");
+function rotateLeft(lValue, iShiftBits) {
+    return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
+}
+function addUnsigned(lX, lY) {
+    let lX4;
+    let lY4;
+    let lX8;
+    let lY8;
+    let lResult;
+    lX8 = lX & 0x80000000;
+    lY8 = lY & 0x80000000;
+    lX4 = lX & 0x40000000;
+    lY4 = lY & 0x40000000;
+    lResult = (lX & 0x3fffffff) + (lY & 0x3fffffff);
+    if (lX4 & lY4) {
+        return lResult ^ 0x80000000 ^ lX8 ^ lY8;
+    }
+    if (lX4 | lY4) {
+        if (lResult & 0x40000000) {
+            return lResult ^ 0xc0000000 ^ lX8 ^ lY8;
+        }
+        else {
+            return lResult ^ 0x40000000 ^ lX8 ^ lY8;
+        }
+    }
+    else {
+        return lResult ^ lX8 ^ lY8;
+    }
+}
+function F(x, y, z) {
+    return (x & y) | (~x & z);
+}
+function G(x, y, z) {
+    return (x & z) | (y & ~z);
+}
+function H(x, y, z) {
+    return x ^ y ^ z;
+}
+function I(x, y, z) {
+    return y ^ (x | ~z);
+}
+function FF(a, b, c, d, x, s, ac) {
+    a = addUnsigned(a, addUnsigned(addUnsigned(F(b, c, d), x), ac));
+    return addUnsigned(rotateLeft(a, s), b);
+}
+function GG(a, b, c, d, x, s, ac) {
+    a = addUnsigned(a, addUnsigned(addUnsigned(G(b, c, d), x), ac));
+    return addUnsigned(rotateLeft(a, s), b);
+}
+function HH(a, b, c, d, x, s, ac) {
+    a = addUnsigned(a, addUnsigned(addUnsigned(H(b, c, d), x), ac));
+    return addUnsigned(rotateLeft(a, s), b);
+}
+function II(a, b, c, d, x, s, ac) {
+    a = addUnsigned(a, addUnsigned(addUnsigned(I(b, c, d), x), ac));
+    return addUnsigned(rotateLeft(a, s), b);
+}
+function convertToWordArray(data) {
+    let lWordCount;
+    const lMessageLength = data.length;
+    const lNumberOfWordsTemp1 = lMessageLength + 8;
+    const lNumberOfWordsTemp2 = (lNumberOfWordsTemp1 - (lNumberOfWordsTemp1 % 64)) / 64;
+    const lNumberOfWords = (lNumberOfWordsTemp2 + 1) * 16;
+    const lWordArray = Array(lNumberOfWords - 1).fill(0);
+    let lBytePosition = 0;
+    let lByteCount = 0;
+    // Process each byte from the Uint8Array
+    while (lByteCount < lMessageLength) {
+        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+        lBytePosition = (lByteCount % 4) * 8;
+        lWordArray[lWordCount] = lWordArray[lWordCount] | (data[lByteCount] << lBytePosition);
+        lByteCount++;
+    }
+    // Append padding bits
+    lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+    lBytePosition = (lByteCount % 4) * 8;
+    lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
+    // Append message length in bits
+    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
+    lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
+    return lWordArray;
+}
+function wordToHex(lValue) {
+    let wordToHexValue = '';
+    let wordToHexValueTemp = '';
+    let lByte;
+    let lCount;
+    for (lCount = 0; lCount <= 3; lCount++) {
+        lByte = (lValue >>> (lCount * 8)) & 255;
+        wordToHexValueTemp = '0' + lByte.toString(16);
+        wordToHexValue = wordToHexValue + wordToHexValueTemp.substr(wordToHexValueTemp.length - 2, 2);
+    }
+    return wordToHexValue;
+}
+function hash(bytes) {
+    let x = [];
+    let k;
+    let AA;
+    let BB;
+    let CC;
+    let DD;
+    let a;
+    let b;
+    let c;
+    let d;
+    const S11 = 7;
+    const S12 = 12;
+    const S13 = 17;
+    const S14 = 22;
+    const S21 = 5;
+    const S22 = 9;
+    const S23 = 14;
+    const S24 = 20;
+    const S31 = 4;
+    const S32 = 11;
+    const S33 = 16;
+    const S34 = 23;
+    const S41 = 6;
+    const S42 = 10;
+    const S43 = 15;
+    const S44 = 21;
+    x = convertToWordArray(bytes);
+    a = 0x67452301;
+    b = 0xefcdab89;
+    c = 0x98badcfe;
+    d = 0x10325476;
+    for (k = 0; k < x.length; k += 16) {
+        AA = a;
+        BB = b;
+        CC = c;
+        DD = d;
+        a = FF(a, b, c, d, x[k + 0], S11, 0xd76aa478);
+        d = FF(d, a, b, c, x[k + 1], S12, 0xe8c7b756);
+        c = FF(c, d, a, b, x[k + 2], S13, 0x242070db);
+        b = FF(b, c, d, a, x[k + 3], S14, 0xc1bdceee);
+        a = FF(a, b, c, d, x[k + 4], S11, 0xf57c0faf);
+        d = FF(d, a, b, c, x[k + 5], S12, 0x4787c62a);
+        c = FF(c, d, a, b, x[k + 6], S13, 0xa8304613);
+        b = FF(b, c, d, a, x[k + 7], S14, 0xfd469501);
+        a = FF(a, b, c, d, x[k + 8], S11, 0x698098d8);
+        d = FF(d, a, b, c, x[k + 9], S12, 0x8b44f7af);
+        c = FF(c, d, a, b, x[k + 10], S13, 0xffff5bb1);
+        b = FF(b, c, d, a, x[k + 11], S14, 0x895cd7be);
+        a = FF(a, b, c, d, x[k + 12], S11, 0x6b901122);
+        d = FF(d, a, b, c, x[k + 13], S12, 0xfd987193);
+        c = FF(c, d, a, b, x[k + 14], S13, 0xa679438e);
+        b = FF(b, c, d, a, x[k + 15], S14, 0x49b40821);
+        a = GG(a, b, c, d, x[k + 1], S21, 0xf61e2562);
+        d = GG(d, a, b, c, x[k + 6], S22, 0xc040b340);
+        c = GG(c, d, a, b, x[k + 11], S23, 0x265e5a51);
+        b = GG(b, c, d, a, x[k + 0], S24, 0xe9b6c7aa);
+        a = GG(a, b, c, d, x[k + 5], S21, 0xd62f105d);
+        d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
+        c = GG(c, d, a, b, x[k + 15], S23, 0xd8a1e681);
+        b = GG(b, c, d, a, x[k + 4], S24, 0xe7d3fbc8);
+        a = GG(a, b, c, d, x[k + 9], S21, 0x21e1cde6);
+        d = GG(d, a, b, c, x[k + 14], S22, 0xc33707d6);
+        c = GG(c, d, a, b, x[k + 3], S23, 0xf4d50d87);
+        b = GG(b, c, d, a, x[k + 8], S24, 0x455a14ed);
+        a = GG(a, b, c, d, x[k + 13], S21, 0xa9e3e905);
+        d = GG(d, a, b, c, x[k + 2], S22, 0xfcefa3f8);
+        c = GG(c, d, a, b, x[k + 7], S23, 0x676f02d9);
+        b = GG(b, c, d, a, x[k + 12], S24, 0x8d2a4c8a);
+        a = HH(a, b, c, d, x[k + 5], S31, 0xfffa3942);
+        d = HH(d, a, b, c, x[k + 8], S32, 0x8771f681);
+        c = HH(c, d, a, b, x[k + 11], S33, 0x6d9d6122);
+        b = HH(b, c, d, a, x[k + 14], S34, 0xfde5380c);
+        a = HH(a, b, c, d, x[k + 1], S31, 0xa4beea44);
+        d = HH(d, a, b, c, x[k + 4], S32, 0x4bdecfa9);
+        c = HH(c, d, a, b, x[k + 7], S33, 0xf6bb4b60);
+        b = HH(b, c, d, a, x[k + 10], S34, 0xbebfbc70);
+        a = HH(a, b, c, d, x[k + 13], S31, 0x289b7ec6);
+        d = HH(d, a, b, c, x[k + 0], S32, 0xeaa127fa);
+        c = HH(c, d, a, b, x[k + 3], S33, 0xd4ef3085);
+        b = HH(b, c, d, a, x[k + 6], S34, 0x4881d05);
+        a = HH(a, b, c, d, x[k + 9], S31, 0xd9d4d039);
+        d = HH(d, a, b, c, x[k + 12], S32, 0xe6db99e5);
+        c = HH(c, d, a, b, x[k + 15], S33, 0x1fa27cf8);
+        b = HH(b, c, d, a, x[k + 2], S34, 0xc4ac5665);
+        a = II(a, b, c, d, x[k + 0], S41, 0xf4292244);
+        d = II(d, a, b, c, x[k + 7], S42, 0x432aff97);
+        c = II(c, d, a, b, x[k + 14], S43, 0xab9423a7);
+        b = II(b, c, d, a, x[k + 5], S44, 0xfc93a039);
+        a = II(a, b, c, d, x[k + 12], S41, 0x655b59c3);
+        d = II(d, a, b, c, x[k + 3], S42, 0x8f0ccc92);
+        c = II(c, d, a, b, x[k + 10], S43, 0xffeff47d);
+        b = II(b, c, d, a, x[k + 1], S44, 0x85845dd1);
+        a = II(a, b, c, d, x[k + 8], S41, 0x6fa87e4f);
+        d = II(d, a, b, c, x[k + 15], S42, 0xfe2ce6e0);
+        c = II(c, d, a, b, x[k + 6], S43, 0xa3014314);
+        b = II(b, c, d, a, x[k + 13], S44, 0x4e0811a1);
+        a = II(a, b, c, d, x[k + 4], S41, 0xf7537e82);
+        d = II(d, a, b, c, x[k + 11], S42, 0xbd3af235);
+        c = II(c, d, a, b, x[k + 2], S43, 0x2ad7d2bb);
+        b = II(b, c, d, a, x[k + 9], S44, 0xeb86d391);
+        a = addUnsigned(a, AA);
+        b = addUnsigned(b, BB);
+        c = addUnsigned(c, CC);
+        d = addUnsigned(d, DD);
+    }
+    return wordToHex(a) + wordToHex(b) + wordToHex(c) + wordToHex(d);
+}
+const md5 = (input) => {
+    if (typeof input !== 'string' && !(input instanceof Uint8Array)) {
+        return '';
+    }
+    const bytes = typeof input === 'string' ? utf8_1.default.toUtf8Bytes(input) : input;
+    return hash(bytes);
+};
+const md5Base64 = (input) => {
+    const hex = md5(input);
+    if (!hex)
+        return '';
+    const bytes = base_1.default.hex2bytes(hex);
+    return base64_1.default.bytesToBase64(bytes);
+};
+exports.default = { md5, md5Base64 };

package/bin/lib/modules/hook/modules/bezier.js

@@ -98,7 +98,7 @@ type = '') => {
             const p1 = _points[i];
             const p2 = _points[i + 1];
             if (axis >= p1.x && axis <= p2.x) {
-                if (type === 'bezier') {
+                if (type === 'lerp') {
                     const t = proportion(p1.x, p2.x, axis);
                     value = bezier1(p1, p2, t).y;
                 }

package/bin/lib/modules/html.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAllowed = exports.queryPermission = exports.legacyCopy = exports.copyText = void 0;
 // import math from './math'
 const qs_1 = require("./qs");
 // interface IDowloadCallback {
@@ -58,7 +57,13 @@ const _downloadUrl = (url, filename) => {
         console.error(`[ddan] _downloadUrl ${url}`, err);
     }
 };
-const downloadUrl = (url, filename = '', checkSomeOrigin = false) => {
+const downloadUrl = (url, filename = '', checkSomeOrigin = false
+// opts?: {
+//   success?: () => void
+//   progress?: (percentage: number, current: number, total: number) => void
+//   fail?: (error: any) => void
+// }
+) => {
     try {
         if (!url)
             return;
@@ -183,27 +188,26 @@ const watermark = (text, { width = 400, height = 300, angle = 0, fillStyle = 'rg
 const copyText = (text, legacy = false) => {
     return new Promise((resolve) => {
         if (legacy || !navigator.clipboard) {
-            resolve((0, exports.legacyCopy)(text));
+            resolve(legacyCopy(text));
             return;
         }
-        (0, exports.queryPermission)('clipboard-write')
+        queryPermission('clipboard-write')
             .then((state) => {
-            if ((0, exports.isAllowed)(state, false)) {
+            if (isAllowed(state, false)) {
                 navigator.clipboard
                     .writeText(text)
                     .then(() => resolve(true))
-                    .catch(() => resolve((0, exports.legacyCopy)(text)));
+                    .catch(() => resolve(legacyCopy(text)));
             }
             else {
-                resolve((0, exports.legacyCopy)(text));
+                resolve(legacyCopy(text));
             }
         })
             .catch(() => {
-            resolve((0, exports.legacyCopy)(text));
+            resolve(legacyCopy(text));
         });
     });
 };
-exports.copyText = copyText;
 const legacyCopy = (text) => {
     try {
         const _textarea = document.createElement('textarea');
@@ -228,7 +232,6 @@ const legacyCopy = (text) => {
         return false;
     }
 };
-exports.legacyCopy = legacyCopy;
 const queryPermission = (name, def = 'denied') => {
     return new Promise((resolve) => {
         const permissions = navigator?.permissions;
@@ -241,13 +244,36 @@ const queryPermission = (name, def = 'denied') => {
             .catch(() => resolve(def));
     });
 };
-exports.queryPermission = queryPermission;
 const isAllowed = (status, prompt = true) => {
     if (prompt && status === 'prompt')
         return true;
     return status === 'granted';
 };
-exports.isAllowed = isAllowed;
+const takeHtmlLinks = (htmlContent) => {
+    if (!htmlContent)
+        return [];
+    const regexs = [
+        /<script[^>]+src="([^"]+)"/g,
+        /<link[^>]+rel="stylesheet"[^>]+href="([^"]+)"/g,
+        /<link[^>]+rel="icon"[^>]+href="([^"]+)"/g,
+    ];
+    const results = [];
+    regexs.forEach((e) => {
+        const r = takeHtml(htmlContent, e);
+        results.push(r);
+    });
+    return [].concat(...results);
+};
+const takeHtml = (htmlContent, regex) => {
+    if (!htmlContent || !regex)
+        return [];
+    const results = [];
+    let match;
+    while ((match = regex.exec(htmlContent)) !== null) {
+        results.push(match[1]);
+    }
+    return results;
+};
 exports.default = {
     dataURLtoFile,
     dataURLtoBlob,
@@ -258,8 +284,10 @@ exports.default = {
     downloadFile,
     downloadImage,
     watermark,
-    copyText: exports.copyText,
-    queryPermission: exports.queryPermission,
-    isAllowed: exports.isAllowed,
-    legacyCopy: exports.legacyCopy,
+    copyText,
+    queryPermission,
+    isAllowed,
+    legacyCopy,
+    takeHtmlLinks,
+    takeHtml,
 };

package/bin/lib/modules/string/index.js

@@ -95,6 +95,14 @@ const jsonFormat = (jsonString) => {
         return jsonString;
     }
 };
+const toLines = (content, separator = '\n') => {
+    if (!content)
+        return [];
+    return content
+        .split(separator)
+        .map((line) => line.trim())
+        .filter((txt) => !!txt);
+};
 exports.default = {
     toString,
     startCase,
@@ -108,5 +116,6 @@ exports.default = {
     splitOnFirst,
     parseValue,
     replace,
-    jsonFormat
+    jsonFormat,
+    toLines,
 };

package/bin/types/browser.d.ts

@@ -88,6 +88,8 @@ declare const dUtil: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -164,6 +166,7 @@ declare const dUtil: {
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
         jsonFormat: (jsonString: string) => string;
+        toLines: (content: string, separator?: string | RegExp) => string[];
     };
     time: {
         now: () => import("./modules/time/dtime").default;
@@ -323,6 +326,7 @@ declare const dHook: {
     }) => any;
     replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
     jsonFormat: (jsonString: string) => string;
+    toLines: (content: string, separator?: string | RegExp) => string[];
     sleep: (ms?: number) => Promise<unknown>;
     run: <T_1 = any>(task?: import("./typings").Ddan.PFunction<T_1> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_1]>;
     exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<any>;
@@ -339,7 +343,7 @@ declare const dHook: {
     bezier3: (p0: import("./typings").Ddan.IPoint, p1: import("./typings").Ddan.IPoint, p2: import("./typings").Ddan.IPoint, p3: import("./typings").Ddan.IPoint, t: number) => import("./typings").Ddan.IPoint;
     bezier: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
     bezierCurve: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
-    lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+    lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
     proportion: (start: number, end: number, current: number) => number;
     logString: (data: any) => string;
     logParse: (logStr: string) => string;
@@ -381,6 +385,8 @@ declare const dHook: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -495,6 +501,8 @@ declare const dMini: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
 };
 declare const dCdn: {
@@ -637,6 +645,8 @@ declare const dWeb: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
     rsa: {
         generateKeys: () => Promise<{
@@ -698,7 +708,7 @@ declare const _default: {
         bezier: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
         bezierCurve: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
         lerp: (start: number, end: number, t: number) => number;
-        lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+        lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
         proportion: (start: number, end: number, current: number) => number;
         logString: (data: any) => string;
         logParse: (logStr: string) => string;
@@ -814,6 +824,7 @@ declare const _default: {
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
         jsonFormat: (jsonString: string) => string;
+        toLines: (content: string, separator?: string | RegExp) => string[];
     };
     obj: {
         copy: (source: any, options?: {
@@ -964,6 +975,8 @@ declare const _default: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
     icon: import("./class/icon").DIcon;
     rule: {
@@ -1000,6 +1013,8 @@ declare const _default: {
         textEncode: (text: string) => Uint8Array;
         textDecode: (buf: ArrayBufferLike) => string;
         toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+        md5: (input: string | Uint8Array) => string;
+        md5Base64: (input: string | Uint8Array) => string;
         toBase64: (input?: string) => string;
         fromBase64: (input?: string) => string;
         bytesToBase64: (bytes: Uint8Array) => string;

package/bin/types/index.d.ts

@@ -88,6 +88,8 @@ declare const dUtil: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -164,6 +166,7 @@ declare const dUtil: {
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
         jsonFormat: (jsonString: string) => string;
+        toLines: (content: string, separator?: string | RegExp) => string[];
     };
     time: {
         now: () => import("./modules/time/dtime").default;
@@ -323,6 +326,7 @@ declare const dHook: {
     }) => any;
     replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
     jsonFormat: (jsonString: string) => string;
+    toLines: (content: string, separator?: string | RegExp) => string[];
     sleep: (ms?: number) => Promise<unknown>;
     run: <T_1 = any>(task?: import("./typings").Ddan.PFunction<T_1> | undefined, wait?: number) => Promise<[any, undefined] | [null, T_1]>;
     exec: (func: import("./typings").Ddan.Function, taskId?: string) => import("./typings").Ddan.PSafeResult<any>;
@@ -339,7 +343,7 @@ declare const dHook: {
     bezier3: (p0: import("./typings").Ddan.IPoint, p1: import("./typings").Ddan.IPoint, p2: import("./typings").Ddan.IPoint, p3: import("./typings").Ddan.IPoint, t: number) => import("./typings").Ddan.IPoint;
     bezier: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
     bezierCurve: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
-    lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+    lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
     proportion: (start: number, end: number, current: number) => number;
     logString: (data: any) => string;
     logParse: (logStr: string) => string;
@@ -381,6 +385,8 @@ declare const dHook: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;
@@ -495,6 +501,8 @@ declare const dMini: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
 };
 declare const dCdn: {
@@ -637,6 +645,8 @@ declare const dWeb: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
     rsa: {
         generateKeys: () => Promise<{
@@ -734,7 +744,7 @@ declare const _default: {
         bezier: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
         bezierCurve: (points: import("./typings").Ddan.IPoint[], t: number) => import("./typings").Ddan.IPoint;
         lerp: (start: number, end: number, t: number) => number;
-        lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+        lerpAverage: (points: import("./typings").Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
         proportion: (start: number, end: number, current: number) => number;
         logString: (data: any) => string;
         logParse: (logStr: string) => string;
@@ -850,6 +860,7 @@ declare const _default: {
         }) => any;
         replace: (source: string, rules: import("./typings").Ddan.IRegexRule | import("./typings").Ddan.IRegexRule[]) => string;
         jsonFormat: (jsonString: string) => string;
+        toLines: (content: string, separator?: string | RegExp) => string[];
     };
     obj: {
         copy: (source: any, options?: {
@@ -1000,6 +1011,8 @@ declare const _default: {
         queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
         isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
         legacyCopy: (text: string) => boolean;
+        takeHtmlLinks: (htmlContent: string) => never[];
+        takeHtml: (htmlContent: string, regex: RegExp) => string[];
     };
     icon: import("./class/icon").DIcon;
     rule: {
@@ -1036,6 +1049,8 @@ declare const _default: {
         textEncode: (text: string) => Uint8Array;
         textDecode: (buf: ArrayBufferLike) => string;
         toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+        md5: (input: string | Uint8Array) => string;
+        md5Base64: (input: string | Uint8Array) => string;
         toBase64: (input?: string) => string;
         fromBase64: (input?: string) => string;
         bytesToBase64: (bytes: Uint8Array) => string;

package/bin/types/modules/convert/index.d.ts

@@ -7,6 +7,8 @@ declare const _default: {
     textEncode: (text: string) => Uint8Array;
     textDecode: (buf: ArrayBufferLike) => string;
     toDataUrl: (textOrBuf: string | ArrayBuffer, contentType?: string) => string;
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
     toBase64: (input?: string) => string;
     fromBase64: (input?: string) => string;
     bytesToBase64: (bytes: Uint8Array) => string;

package/bin/types/modules/convert/md5.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    md5: (input: string | Uint8Array) => string;
+    md5Base64: (input: string | Uint8Array) => string;
+};
+export default _default;

package/bin/types/modules/hook/index.d.ts

@@ -31,7 +31,7 @@ declare const _default: {
     bezier: (points: Ddan.IPoint[], t: number) => Ddan.IPoint;
     bezierCurve: (points: Ddan.IPoint[], t: number) => Ddan.IPoint;
     lerp: (start: number, end: number, t: number) => number;
-    lerpAverage: (points: Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+    lerpAverage: (points: Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
     proportion: (start: number, end: number, current: number) => number;
     logString: (data: any) => string;
     logParse: (logStr: string) => string;

package/bin/types/modules/hook/modules/bezier.d.ts

@@ -6,7 +6,7 @@ declare const _default: {
     bezier: (points: Ddan.IPoint[], t: number) => Ddan.IPoint;
     bezierCurve: (points: Ddan.IPoint[], t: number) => Ddan.IPoint;
     lerp: (start: number, end: number, t: number) => number;
-    lerpAverage: (points: Ddan.IPoint[], step: number, type?: "" | "bezier") => number;
+    lerpAverage: (points: Ddan.IPoint[], step: number, type?: "" | "lerp") => number;
     proportion: (start: number, end: number, current: number) => number;
 };
 export default _default;

package/bin/types/modules/html.d.ts

@@ -1,7 +1,3 @@
-export declare const copyText: (text: string, legacy?: boolean) => Promise<boolean>;
-export declare const legacyCopy: (text: string) => boolean;
-export declare const queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
-export declare const isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
 declare const _default: {
     dataURLtoFile: (dataurl: any, filename: any) => File;
     dataURLtoBlob: (dataurl: any) => Blob;
@@ -24,5 +20,7 @@ declare const _default: {
     queryPermission: (name: string, def?: PermissionState) => Promise<PermissionState>;
     isAllowed: (status: PermissionState | undefined, prompt?: boolean) => boolean;
     legacyCopy: (text: string) => boolean;
+    takeHtmlLinks: (htmlContent: string) => never[];
+    takeHtml: (htmlContent: string, regex: RegExp) => string[];
 };
 export default _default;

package/bin/types/modules/string/index.d.ts

@@ -17,5 +17,6 @@ declare const _default: {
     }) => any;
     replace: (source: string, rules: Ddan.IRegexRule | Ddan.IRegexRule[]) => string;
     jsonFormat: (jsonString: string) => string;
+    toLines: (content: string, separator?: string | RegExp) => string[];
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "",
   "keywords": [
     "ddan-js",