@anjianshi/utils 2.7.0 → 2.8.0

package/md5.js

@@ -0,0 +1,308 @@
+/* eslint-disable no-multi-assign */
+/**
+ * MD5 算法来自：https://github.com/emn178/js-md5
+ */
+export function md5(content) {
+    const md5 = new MD5();
+    md5.update(content);
+    return md5.hex();
+}
+// -------------------------------------------------------------------
+/**
+ * 使用方法：
+ * const md5 = new MD5()
+ * md5.update(xxx)  // 对于大文件，可以拆分开，多次调用 md5.update()
+ * const hash = md5.hex()
+ */
+export class MD5 {
+    buffer8;
+    blocks;
+    h0 = 0;
+    h1 = 0;
+    h2 = 0;
+    h3 = 0;
+    start = 0;
+    bytes = 0;
+    hBytes = 0;
+    lastByteIndex = 0;
+    finalized = false;
+    hashed = false;
+    first = true;
+    constructor() {
+        const buffer = new ArrayBuffer(68);
+        this.buffer8 = new Uint8Array(buffer);
+        this.blocks = new Uint32Array(buffer);
+    }
+    update(message) {
+        if (this.finalized)
+            return;
+        if (message instanceof ArrayBuffer) {
+            message = new Uint8Array(message);
+        }
+        if (typeof message !== 'string' && !Array.isArray(message) && !ArrayBuffer.isView(message)) {
+            throw new Error('input is invalid type');
+        }
+        const length = message.length;
+        const { blocks, buffer8 } = this;
+        let code;
+        let index = 0;
+        let i;
+        while (index < length) {
+            if (this.hashed) {
+                this.hashed = false;
+                blocks[0] = blocks[16];
+                // prettier-ignore
+                blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] =
+                    blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] =
+                        blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+            }
+            if (typeof message !== 'string') {
+                for (i = this.start; index < length && i < 64; ++index) {
+                    buffer8[i++] = message[index];
+                }
+            }
+            else {
+                for (i = this.start; index < length && i < 64; ++index) {
+                    code = message.charCodeAt(index);
+                    if (code < 0x80) {
+                        buffer8[i++] = code;
+                    }
+                    else if (code < 0x800) {
+                        buffer8[i++] = 0xc0 | (code >> 6);
+                        buffer8[i++] = 0x80 | (code & 0x3f);
+                    }
+                    else if (code < 0xd800 || code >= 0xe000) {
+                        buffer8[i++] = 0xe0 | (code >> 12);
+                        buffer8[i++] = 0x80 | ((code >> 6) & 0x3f);
+                        buffer8[i++] = 0x80 | (code & 0x3f);
+                    }
+                    else {
+                        code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
+                        buffer8[i++] = 0xf0 | (code >> 18);
+                        buffer8[i++] = 0x80 | ((code >> 12) & 0x3f);
+                        buffer8[i++] = 0x80 | ((code >> 6) & 0x3f);
+                        buffer8[i++] = 0x80 | (code & 0x3f);
+                    }
+                }
+            }
+            this.lastByteIndex = i;
+            this.bytes += i - this.start;
+            if (i >= 64) {
+                this.start = i - 64;
+                this.hash();
+                this.hashed = true;
+            }
+            else {
+                this.start = i;
+            }
+        }
+        if (this.bytes > 4294967295) {
+            this.hBytes += (this.bytes / 4294967296) << 0;
+            this.bytes = this.bytes % 4294967296;
+        }
+    }
+    finalize() {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        const { blocks } = this;
+        const i = this.lastByteIndex;
+        const EXTRA = [128, 32768, 8388608, -2147483648];
+        blocks[i >> 2] |= EXTRA[i & 3];
+        if (i >= 56) {
+            if (!this.hashed)
+                this.hash();
+            blocks[0] = blocks[16];
+            // prettier-ignore
+            blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] =
+                blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] =
+                    blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+        }
+        blocks[14] = this.bytes << 3;
+        blocks[15] = (this.hBytes << 3) | (this.bytes >>> 29);
+        this.hash();
+    }
+    hash() {
+        let a, b, c, d, bc, da;
+        const { blocks } = this;
+        if (this.first) {
+            a = blocks[0] - 680876937;
+            a = (((a << 7) | (a >>> 25)) - 271733879) << 0;
+            d = (-1732584194 ^ (a & 2004318071)) + blocks[1] - 117830708;
+            d = (((d << 12) | (d >>> 20)) + a) << 0;
+            c = (-271733879 ^ (d & (a ^ -271733879))) + blocks[2] - 1126478375;
+            c = (((c << 17) | (c >>> 15)) + d) << 0;
+            b = (a ^ (c & (d ^ a))) + blocks[3] - 1316259209;
+            b = (((b << 22) | (b >>> 10)) + c) << 0;
+        }
+        else {
+            a = this.h0;
+            b = this.h1;
+            c = this.h2;
+            d = this.h3;
+            a += (d ^ (b & (c ^ d))) + blocks[0] - 680876936;
+            a = (((a << 7) | (a >>> 25)) + b) << 0;
+            d += (c ^ (a & (b ^ c))) + blocks[1] - 389564586;
+            d = (((d << 12) | (d >>> 20)) + a) << 0;
+            c += (b ^ (d & (a ^ b))) + blocks[2] + 606105819;
+            c = (((c << 17) | (c >>> 15)) + d) << 0;
+            b += (a ^ (c & (d ^ a))) + blocks[3] - 1044525330;
+            b = (((b << 22) | (b >>> 10)) + c) << 0;
+        }
+        a += (d ^ (b & (c ^ d))) + blocks[4] - 176418897;
+        a = (((a << 7) | (a >>> 25)) + b) << 0;
+        d += (c ^ (a & (b ^ c))) + blocks[5] + 1200080426;
+        d = (((d << 12) | (d >>> 20)) + a) << 0;
+        c += (b ^ (d & (a ^ b))) + blocks[6] - 1473231341;
+        c = (((c << 17) | (c >>> 15)) + d) << 0;
+        b += (a ^ (c & (d ^ a))) + blocks[7] - 45705983;
+        b = (((b << 22) | (b >>> 10)) + c) << 0;
+        a += (d ^ (b & (c ^ d))) + blocks[8] + 1770035416;
+        a = (((a << 7) | (a >>> 25)) + b) << 0;
+        d += (c ^ (a & (b ^ c))) + blocks[9] - 1958414417;
+        d = (((d << 12) | (d >>> 20)) + a) << 0;
+        c += (b ^ (d & (a ^ b))) + blocks[10] - 42063;
+        c = (((c << 17) | (c >>> 15)) + d) << 0;
+        b += (a ^ (c & (d ^ a))) + blocks[11] - 1990404162;
+        b = (((b << 22) | (b >>> 10)) + c) << 0;
+        a += (d ^ (b & (c ^ d))) + blocks[12] + 1804603682;
+        a = (((a << 7) | (a >>> 25)) + b) << 0;
+        d += (c ^ (a & (b ^ c))) + blocks[13] - 40341101;
+        d = (((d << 12) | (d >>> 20)) + a) << 0;
+        c += (b ^ (d & (a ^ b))) + blocks[14] - 1502002290;
+        c = (((c << 17) | (c >>> 15)) + d) << 0;
+        b += (a ^ (c & (d ^ a))) + blocks[15] + 1236535329;
+        b = (((b << 22) | (b >>> 10)) + c) << 0;
+        a += (c ^ (d & (b ^ c))) + blocks[1] - 165796510;
+        a = (((a << 5) | (a >>> 27)) + b) << 0;
+        d += (b ^ (c & (a ^ b))) + blocks[6] - 1069501632;
+        d = (((d << 9) | (d >>> 23)) + a) << 0;
+        c += (a ^ (b & (d ^ a))) + blocks[11] + 643717713;
+        c = (((c << 14) | (c >>> 18)) + d) << 0;
+        b += (d ^ (a & (c ^ d))) + blocks[0] - 373897302;
+        b = (((b << 20) | (b >>> 12)) + c) << 0;
+        a += (c ^ (d & (b ^ c))) + blocks[5] - 701558691;
+        a = (((a << 5) | (a >>> 27)) + b) << 0;
+        d += (b ^ (c & (a ^ b))) + blocks[10] + 38016083;
+        d = (((d << 9) | (d >>> 23)) + a) << 0;
+        c += (a ^ (b & (d ^ a))) + blocks[15] - 660478335;
+        c = (((c << 14) | (c >>> 18)) + d) << 0;
+        b += (d ^ (a & (c ^ d))) + blocks[4] - 405537848;
+        b = (((b << 20) | (b >>> 12)) + c) << 0;
+        a += (c ^ (d & (b ^ c))) + blocks[9] + 568446438;
+        a = (((a << 5) | (a >>> 27)) + b) << 0;
+        d += (b ^ (c & (a ^ b))) + blocks[14] - 1019803690;
+        d = (((d << 9) | (d >>> 23)) + a) << 0;
+        c += (a ^ (b & (d ^ a))) + blocks[3] - 187363961;
+        c = (((c << 14) | (c >>> 18)) + d) << 0;
+        b += (d ^ (a & (c ^ d))) + blocks[8] + 1163531501;
+        b = (((b << 20) | (b >>> 12)) + c) << 0;
+        a += (c ^ (d & (b ^ c))) + blocks[13] - 1444681467;
+        a = (((a << 5) | (a >>> 27)) + b) << 0;
+        d += (b ^ (c & (a ^ b))) + blocks[2] - 51403784;
+        d = (((d << 9) | (d >>> 23)) + a) << 0;
+        c += (a ^ (b & (d ^ a))) + blocks[7] + 1735328473;
+        c = (((c << 14) | (c >>> 18)) + d) << 0;
+        b += (d ^ (a & (c ^ d))) + blocks[12] - 1926607734;
+        b = (((b << 20) | (b >>> 12)) + c) << 0;
+        bc = b ^ c;
+        a += (bc ^ d) + blocks[5] - 378558;
+        a = (((a << 4) | (a >>> 28)) + b) << 0;
+        d += (bc ^ a) + blocks[8] - 2022574463;
+        d = (((d << 11) | (d >>> 21)) + a) << 0;
+        da = d ^ a;
+        c += (da ^ b) + blocks[11] + 1839030562;
+        c = (((c << 16) | (c >>> 16)) + d) << 0;
+        b += (da ^ c) + blocks[14] - 35309556;
+        b = (((b << 23) | (b >>> 9)) + c) << 0;
+        bc = b ^ c;
+        a += (bc ^ d) + blocks[1] - 1530992060;
+        a = (((a << 4) | (a >>> 28)) + b) << 0;
+        d += (bc ^ a) + blocks[4] + 1272893353;
+        d = (((d << 11) | (d >>> 21)) + a) << 0;
+        da = d ^ a;
+        c += (da ^ b) + blocks[7] - 155497632;
+        c = (((c << 16) | (c >>> 16)) + d) << 0;
+        b += (da ^ c) + blocks[10] - 1094730640;
+        b = (((b << 23) | (b >>> 9)) + c) << 0;
+        bc = b ^ c;
+        a += (bc ^ d) + blocks[13] + 681279174;
+        a = (((a << 4) | (a >>> 28)) + b) << 0;
+        d += (bc ^ a) + blocks[0] - 358537222;
+        d = (((d << 11) | (d >>> 21)) + a) << 0;
+        da = d ^ a;
+        c += (da ^ b) + blocks[3] - 722521979;
+        c = (((c << 16) | (c >>> 16)) + d) << 0;
+        b += (da ^ c) + blocks[6] + 76029189;
+        b = (((b << 23) | (b >>> 9)) + c) << 0;
+        bc = b ^ c;
+        a += (bc ^ d) + blocks[9] - 640364487;
+        a = (((a << 4) | (a >>> 28)) + b) << 0;
+        d += (bc ^ a) + blocks[12] - 421815835;
+        d = (((d << 11) | (d >>> 21)) + a) << 0;
+        da = d ^ a;
+        c += (da ^ b) + blocks[15] + 530742520;
+        c = (((c << 16) | (c >>> 16)) + d) << 0;
+        b += (da ^ c) + blocks[2] - 995338651;
+        b = (((b << 23) | (b >>> 9)) + c) << 0;
+        a += (c ^ (b | ~d)) + blocks[0] - 198630844;
+        a = (((a << 6) | (a >>> 26)) + b) << 0;
+        d += (b ^ (a | ~c)) + blocks[7] + 1126891415;
+        d = (((d << 10) | (d >>> 22)) + a) << 0;
+        c += (a ^ (d | ~b)) + blocks[14] - 1416354905;
+        c = (((c << 15) | (c >>> 17)) + d) << 0;
+        b += (d ^ (c | ~a)) + blocks[5] - 57434055;
+        b = (((b << 21) | (b >>> 11)) + c) << 0;
+        a += (c ^ (b | ~d)) + blocks[12] + 1700485571;
+        a = (((a << 6) | (a >>> 26)) + b) << 0;
+        d += (b ^ (a | ~c)) + blocks[3] - 1894986606;
+        d = (((d << 10) | (d >>> 22)) + a) << 0;
+        c += (a ^ (d | ~b)) + blocks[10] - 1051523;
+        c = (((c << 15) | (c >>> 17)) + d) << 0;
+        b += (d ^ (c | ~a)) + blocks[1] - 2054922799;
+        b = (((b << 21) | (b >>> 11)) + c) << 0;
+        a += (c ^ (b | ~d)) + blocks[8] + 1873313359;
+        a = (((a << 6) | (a >>> 26)) + b) << 0;
+        d += (b ^ (a | ~c)) + blocks[15] - 30611744;
+        d = (((d << 10) | (d >>> 22)) + a) << 0;
+        c += (a ^ (d | ~b)) + blocks[6] - 1560198380;
+        c = (((c << 15) | (c >>> 17)) + d) << 0;
+        b += (d ^ (c | ~a)) + blocks[13] + 1309151649;
+        b = (((b << 21) | (b >>> 11)) + c) << 0;
+        a += (c ^ (b | ~d)) + blocks[4] - 145523070;
+        a = (((a << 6) | (a >>> 26)) + b) << 0;
+        d += (b ^ (a | ~c)) + blocks[11] - 1120210379;
+        d = (((d << 10) | (d >>> 22)) + a) << 0;
+        c += (a ^ (d | ~b)) + blocks[2] + 718787259;
+        c = (((c << 15) | (c >>> 17)) + d) << 0;
+        b += (d ^ (c | ~a)) + blocks[9] - 343485551;
+        b = (((b << 21) | (b >>> 11)) + c) << 0;
+        if (this.first) {
+            this.h0 = (a + 1732584193) << 0;
+            this.h1 = (b - 271733879) << 0;
+            this.h2 = (c - 1732584194) << 0;
+            this.h3 = (d + 271733878) << 0;
+            this.first = false;
+        }
+        else {
+            this.h0 = (this.h0 + a) << 0;
+            this.h1 = (this.h1 + b) << 0;
+            this.h2 = (this.h2 + c) << 0;
+            this.h3 = (this.h3 + d) << 0;
+        }
+    }
+    hex() {
+        this.finalize();
+        const { h0, h1, h2, h3 } = this;
+        const HEX_CHARS = '0123456789abcdef'.split('');
+        return (
+        // prettier-ignore
+        HEX_CHARS[(h0 >> 4) & 0x0f] + HEX_CHARS[h0 & 0x0f] + HEX_CHARS[(h0 >> 12) & 0x0f] + HEX_CHARS[(h0 >> 8) & 0x0f] + HEX_CHARS[(h0 >> 20) & 0x0f] +
+            HEX_CHARS[(h0 >> 16) & 0x0f] + HEX_CHARS[(h0 >> 28) & 0x0f] + HEX_CHARS[(h0 >> 24) & 0x0f] + HEX_CHARS[(h1 >> 4) & 0x0f] + HEX_CHARS[h1 & 0x0f] +
+            HEX_CHARS[(h1 >> 12) & 0x0f] + HEX_CHARS[(h1 >> 8) & 0x0f] + HEX_CHARS[(h1 >> 20) & 0x0f] + HEX_CHARS[(h1 >> 16) & 0x0f] + HEX_CHARS[(h1 >> 28) & 0x0f] +
+            HEX_CHARS[(h1 >> 24) & 0x0f] + HEX_CHARS[(h2 >> 4) & 0x0f] + HEX_CHARS[h2 & 0x0f] + HEX_CHARS[(h2 >> 12) & 0x0f] + HEX_CHARS[(h2 >> 8) & 0x0f] +
+            HEX_CHARS[(h2 >> 20) & 0x0f] + HEX_CHARS[(h2 >> 16) & 0x0f] + HEX_CHARS[(h2 >> 28) & 0x0f] + HEX_CHARS[(h2 >> 24) & 0x0f] + HEX_CHARS[(h3 >> 4) & 0x0f] +
+            HEX_CHARS[h3 & 0x0f] + HEX_CHARS[(h3 >> 12) & 0x0f] + HEX_CHARS[(h3 >> 8) & 0x0f] + HEX_CHARS[(h3 >> 20) & 0x0f] + HEX_CHARS[(h3 >> 16) & 0x0f] +
+            HEX_CHARS[(h3 >> 28) & 0x0f] + HEX_CHARS[(h3 >> 24) & 0x0f]);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -9,32 +9,20 @@
   },
   "license": "MIT",
   "author": "anjianshi <anjianshi@gmail.com>",
-  "repository": "github:anjianshi/js-packages",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anjianshi/js-packages.git"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "directory": "dist"
+    "access": "public"
   },
   "type": "module",
-  "scripts": {
-    "watch": "npm run clear && tsc --watch",
-    "build": "npm run clear && tsc",
-    "clear": "rm -rf dist",
-    "prepublishOnly": "npm run build && node publish-prepare.cjs",
-    "postpublish": "rm dist/package.json",
-    "lint": "tsc --noEmit && node ../node_modules/eslint/bin/eslint.js './src/'"
-  },
   "main": "index.js",
   "dependencies": {
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@anjianshi/presets-eslint-base": "workspace:*",
-    "@anjianshi/presets-eslint-node": "workspace:*",
-    "@anjianshi/presets-eslint-react": "workspace:*",
-    "@anjianshi/presets-eslint-typescript": "workspace:*",
-    "@anjianshi/presets-prettier": "workspace:*",
-    "@anjianshi/presets-typescript": "workspace:*",
     "@types/lodash": "^4.17.20",
     "@types/node": "^22.16.0",
     "@types/react": "^19.1.8",
@@ -42,7 +30,13 @@
     "eslint": "^9.30.1",
     "redis": "^5.5.6",
     "typescript": "^5.8.3",
-    "vconsole": "^3.15.1"
+    "vconsole": "^3.15.1",
+    "@anjianshi/presets-eslint-base": "6.0.0",
+    "@anjianshi/presets-eslint-node": "6.0.0",
+    "@anjianshi/presets-eslint-typescript": "6.0.0",
+    "@anjianshi/presets-eslint-react": "6.0.0",
+    "@anjianshi/presets-typescript": "3.2.4",
+    "@anjianshi/presets-prettier": "3.0.4"
   },
   "peerDependencies": {
     "@emotion/react": "^11.14.0",
@@ -81,4 +75,4 @@
     }
   },
   "prettier": "@anjianshi/presets-prettier/prettierrc"
-}
+}

package/url.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 从 URL 中解析出 query 对象
+ * 注意：不带 ? 号的纯 query 内容需手动加上 ? 再传入。
+ *
+ * [array]
+ * 是否把重复出现的 key 保存为数组（默认不开启）
+ * a=1&a=2 => { a: [1,2] }
+ *
+ * [loose]
+ * 是否开启“宽松模式”（默认不开启）
+ * 1. hash 里的内容也会被解析，以兼容拼接错误的 URL（把 query 拼到了 hash 后面）。
+ * 2. 出现多个 ? 符号时，会把 ? 也当做 & 分隔符（index.html?a=1&b=2?c=3）
+ *
+ * [decode]
+ * 是否对 query 值进行 decode（默认开启）
+ */
+declare function parseQuery(url: string, options?: {
+    array?: false;
+    loose?: boolean;
+    decode?: boolean;
+}): Record<string, string>;
+declare function parseQuery(url: string, options: {
+    array: true;
+    loose?: boolean;
+    decode?: boolean;
+}): Record<string, string | string[]>;
+export { parseQuery };
+/**
+ * 把对象合并成 query string。
+ * - 支持字符串、数值、布尔值、数组。
+ * - 布尔值会替换成 0 和 1。
+ * - 数组会多次赋值：{ a: [1,2,3] } => 'a=1&a=2&a=3'，不支持嵌套数组
+ * - encode 为 true 时会对 value 执行 encodeURIComponent（默认为 true）
+ */
+export type StringifyVal = string | number | boolean;
+export type StringifyQuery = Record<string, StringifyVal | StringifyVal[] | undefined>;
+export declare function stringifyQuery(obj: StringifyQuery, encode?: boolean): string;
+/**
+ * 拆分 URL 的各个部分
+ *
+ * bare 为 true，则 search 不带 '?'，hash 不带 '#'
+ * 否则和 location.search / hash 一样
+ * （默认为 true）
+ */
+export declare function splitUrl(url: string, bare?: boolean): {
+    base: string;
+    search: string;
+    hash: string;
+};
+/**
+ * 把 query 和 hash 内容合并到 url 上
+ *
+ * query   object    与现有 search 合并，替换同名项（值为数组的，用新数组代替老的，不会合并数组）
+ * hash    string    带不带开头的 '#' 皆可。会代替 url 已有的 hash。
+ */
+export declare function combineUrl(origUrl: string, query?: StringifyQuery, hash?: string): string;
+/**
+ * 移除路径中所有非必须的 "/"
+ * 清理后的字符串只有这几种可能的格式：''、'abc'、'abc/def'
+ * 例如 /abc/def 和 abc/def/ 都会变成 abc/def
+ *
+ * 注意：此操作不会统一大小写，因此不保证处理后两个字符串在代码层面全等（a === b）
+ */
+export declare function clearSlash(path: string): string;
+/**
+ * 合并几段路径，保证合并处只有一个斜杠
+ */
+export declare function joinPath(...nodes: string[]): string;
+/**
+ * decodeURIComponent() 对于不规范编码的字符串可能会报错（例如字符串里出现了“%”）
+ * 用此函数代替可避免此问题
+ */
+export declare function safeDecode(content: string): string;
+/**
+ * 将 URL 中的 http:// 协议改成 https://
+ */
+export declare function ensureHttps(url: string | undefined): string | undefined;

package/url.js

@@ -0,0 +1,149 @@
+/**
+ * URL 工具函数
+ * 部分灵感来自：https://www.npmjs.com/package/qs
+ *
+ * [名词定义]
+ * query: 指 a=1&b=2 格式的“查询字符串”或此类字符串的解析结果。
+ * search: URL 中的 search 部分，与 location.search 一致，空字符串或以 '?' 开头。
+ * hash: URL 中的 hash 部分，与 location.hash 一直，空字符串或以 '#' 开头。
+ */
+import isPlainObject from 'lodash/isPlainObject.js';
+function parseQuery(url, options) {
+    const { array = false, loose = false, decode = true } = options ?? {};
+    // 正常状态下，将仅剩 a=1&b=1（即不会再有 ? 和 #）；loose 模式下，可能为 a=1&b=2#c=3?d=4
+    const queryString = (loose ? /(\?|#)(.+)/ : /(\?)(.+?)(#|$)/).exec(url)?.[2] ?? '';
+    if (!queryString)
+        return {};
+    const query = {};
+    const reg = /([^#?&]*)=([^#?&]*)/g;
+    let re = reg.exec(queryString);
+    while (re) {
+        const [name, rawValue] = [re[1], re[2]];
+        const value = decode ? safeDecode(rawValue) : rawValue;
+        if (array && query[name] !== undefined) {
+            const prev = query[name];
+            query[name] = Array.isArray(prev) ? [...prev, value] : [prev, value];
+        }
+        else {
+            query[name] = value;
+        }
+        re = reg.exec(queryString);
+    }
+    return query;
+}
+export { parseQuery };
+export function stringifyQuery(obj, encode = true) {
+    if (!isPlainObject(obj))
+        return '';
+    return (Object.entries(obj)
+        // 过滤值为 undefined 的项目，使其完全不出现在最终的 query 中
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => stringifyQueryItem(name, value, encode))
+        .join('&'));
+}
+function stringifyQueryItem(name, value, encode) {
+    if (Array.isArray(value))
+        return value.map(subValue => stringifyQueryItem(name, subValue, encode)).join('&');
+    if (typeof value === 'boolean')
+        value = value ? '1' : '0';
+    if (typeof value === 'number')
+        value = value.toString();
+    if (encode)
+        value = encodeURIComponent(value);
+    return `${name}=${value}`;
+}
+/**
+ * 拆分 URL 的各个部分
+ *
+ * bare 为 true，则 search 不带 '?'，hash 不带 '#'
+ * 否则和 location.search / hash 一样
+ * （默认为 true）
+ */
+export function splitUrl(url, bare = true) {
+    let hashIndex = url.indexOf('#');
+    if (hashIndex === -1)
+        hashIndex = url.length;
+    const bareHash = url.slice(hashIndex + 1);
+    let searchIndex = url.slice(0, hashIndex).indexOf('?');
+    if (searchIndex === -1)
+        searchIndex = hashIndex;
+    const bareSearch = url.slice(searchIndex + 1, hashIndex);
+    return {
+        base: url.slice(0, searchIndex),
+        search: bare ? bareSearch : bareSearch ? '?' + bareSearch : '',
+        hash: bare ? bareHash : bareHash ? '#' + bareHash : '',
+    };
+}
+/**
+ * 把 query 和 hash 内容合并到 url 上
+ *
+ * query   object    与现有 search 合并，替换同名项（值为数组的，用新数组代替老的，不会合并数组）
+ * hash    string    带不带开头的 '#' 皆可。会代替 url 已有的 hash。
+ */
+export function combineUrl(origUrl, query = {}, hash = '') {
+    if (hash.startsWith('#'))
+        hash = hash.slice(1);
+    // 拆分原 url 的 search、hash
+    const { base, search: origSearch, hash: origHash } = splitUrl(origUrl);
+    // 拼接新 URL
+    let newUrl = base;
+    const newSearch = stringifyQuery({ ...parseQuery(origSearch), ...query });
+    const newHash = hash || origHash;
+    if (newSearch)
+        newUrl += `?${newSearch}`;
+    if (newHash)
+        newUrl += `#${newHash}`;
+    return newUrl;
+}
+/**
+ * 移除路径中所有非必须的 "/"
+ * 清理后的字符串只有这几种可能的格式：''、'abc'、'abc/def'
+ * 例如 /abc/def 和 abc/def/ 都会变成 abc/def
+ *
+ * 注意：此操作不会统一大小写，因此不保证处理后两个字符串在代码层面全等（a === b）
+ */
+export function clearSlash(path) {
+    if (path.startsWith('/'))
+        path = path.slice(1);
+    if (path.endsWith('/'))
+        path = path.slice(0, -1);
+    path = path.replace(/\/+/g, '/');
+    return path;
+}
+/**
+ * 合并几段路径，保证合并处只有一个斜杠
+ */
+export function joinPath(...nodes) {
+    // - node 为 '' 时忽略 node
+    // - path 可能的格式：'' 'a' 'a/' ‘/a/'
+    //   - path 为 ''，则 node 开头 '/' 保持原样
+    //   - 否则，根据 path 结尾有没有 '/'，决定 node 开头带不带 '/'
+    // - node 开头、结尾若有多个 '/' 均替换成单个
+    return nodes.reduce((path, node) => {
+        if (!node)
+            return path;
+        const [, origPrefix, content, origSuffix] = /^(\/*)(.*?)(\/*)$/.exec(node);
+        const prefix = (path === '' ? !!origPrefix : !path.endsWith('/')) ? '/' : '';
+        const suffix = origSuffix ? '/' : '';
+        const result = `${path}${prefix}${content}${suffix}`;
+        return result;
+    }, '');
+}
+/**
+ * decodeURIComponent() 对于不规范编码的字符串可能会报错（例如字符串里出现了“%”）
+ * 用此函数代替可避免此问题
+ */
+export function safeDecode(content) {
+    try {
+        return decodeURIComponent(content);
+    }
+    catch (e) {
+        return content;
+    }
+}
+/**
+ * 将 URL 中的 http:// 协议改成 https://
+ */
+export function ensureHttps(url) {
+    return url?.replace(/http:\/\//g, 'https://');
+}

package/validators/array.d.ts

@@ -0,0 +1,30 @@
+import { type CommonOptions, type Validator, type Validated } from './base.js';
+/** 验证元素数量任意、元素类型相同的数组 */
+export interface ArrayOptions extends CommonOptions {
+    /** 验证数组各元素 */
+    item: Validator<unknown, CommonOptions>;
+    /** 数组最小长度 */
+    min?: number;
+    /** 数组最大长度 */
+    max?: number;
+    /** 是否对数组元素进行去重 @defaults false */
+    unique?: boolean;
+    /** 如果传入的不是数组，是否要将其视为数组内元素，包裹成数组 */
+    toArray?: boolean;
+}
+type ArrayValues<Options extends ArrayOptions> = Validated<Options extends {
+    item: Validator<infer T, CommonOptions>;
+} ? T : never, Options extends {
+    item: Validator<unknown, infer T>;
+} ? T : never>[];
+export declare function getArrayValidator<Options extends ArrayOptions>(options: Options): Validator<ArrayValues<Options>, Options>;
+/** 验证元素数量固定、类型可以不同的数组 */
+export interface TupleOptions extends CommonOptions {
+    /** 验证数组各元素（validator 与元素一一对应） */
+    tuple: Validator<unknown, CommonOptions>[];
+}
+type TupleValues<Options extends TupleOptions> = {
+    [Key in keyof Options['tuple']]: Options['tuple'][Key] extends Validator<infer Value, infer Options> ? Validated<Value, Options> : never;
+};
+export declare function getTupleValidator<const Options extends TupleOptions>(options: Options): Validator<TupleValues<Options>, Options>;
+export {};

package/validators/array.js

@@ -0,0 +1,47 @@
+import { success, failed } from '../lang/index.js';
+import { getValidatorGenerator, } from './base.js';
+export function getArrayValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
+        if (!Array.isArray(value)) {
+            if (options.toArray)
+                value = [value];
+            else
+                return failed(`${field} should be an array`);
+        }
+        let formatted = [];
+        if (typeof options.min === 'number' && value.length < options.min)
+            return failed(`array ${field}'s length should >= ${options.min}`);
+        if (typeof options.max === 'number' && value.length > options.max)
+            return failed(`array ${field}'s length should <= ${options.max}`);
+        const itemValidator = options.item;
+        for (let i = 0; i < value.length; i++) {
+            const itemResult = itemValidator(`${field}[${i}]`, value[i]);
+            if (itemResult.success)
+                formatted.push(itemResult.data);
+            else
+                return itemResult;
+        }
+        if (options.unique === true)
+            formatted = [...new Set(formatted)];
+        return success(formatted);
+    })(options);
+}
+export function getTupleValidator(options) {
+    return getValidatorGenerator(function validate(field, value, options) {
+        if (!Array.isArray(value))
+            return failed(`${field} should be an array`);
+        if (value.length > options.tuple.length)
+            return failed(`${field} should be a tuple with ${options.tuple.length} items`);
+        const formatted = [];
+        // 这种情况不能遍历 value，因为它的长度可能小于 opt.tuple
+        for (let i = 0; i < options.tuple.length; i++) {
+            const itemValidator = options.tuple[i];
+            const itemResult = itemValidator(`${field}[${i}]`, value[i]);
+            if (itemResult.success)
+                formatted.push(itemResult.data);
+            else
+                return itemResult;
+        }
+        return success(formatted);
+    })(options);
+}