Initial clean project import

2026-06-19 18:41:41 +08:00
commit a13b804c7a
1306 changed files with 220568 additions and 0 deletions
@@ -0,0 +1,865 @@
+import chardet from "chardet";
+import dayjs from "dayjs";
+import iconvLite from "iconv-lite";
+import {Base64} from "js-base64";
+import * as crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import Showdown from "showdown";
+// import {Iconv} from "iconv"
+import {isMac, isWin} from "./env";
+import FileIndex from "../mapi/file";
+
+export const EncodeUtil = {
+    base32Alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+    base32Encode(str: string) {
+        const buffer = Buffer.from(str, "utf8");
+        let bits = "";
+        let output = "";
+        // 将每个字节转为8位二进制
+        for (let i = 0; i < buffer.length; i++) {
+            const byte = buffer[i];
+            bits += byte.toString(2).padStart(8, "0");
+        }
+        // 每5位一组，转为 Base32 字符
+        for (let i = 0; i < bits.length; i += 5) {
+            const chunk = bits.slice(i, i + 5);
+            const paddedChunk = chunk.padEnd(5, "0"); // 不足5位补0
+            const index = parseInt(paddedChunk, 2);
+            output += EncodeUtil.base32Alphabet[index];
+        }
+        return output;
+    },
+    base32Decode(str: string) {
+        const base32Alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+        let bits = "";
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            const index = base32Alphabet.indexOf(char);
+            if (index === -1) {
+                throw new Error("Invalid Base32 character: " + char);
+            }
+            bits += index.toString(2).padStart(5, "0");
+        }
+
+        const bytes: number[] = [];
+        for (let i = 0; i + 8 <= bits.length; i += 8) {
+            const byte = bits.slice(i, i + 8);
+            bytes.push(parseInt(byte, 2));
+        }
+
+        return Buffer.from(bytes).toString("utf8");
+    },
+    base64Encode(str: string) {
+        return Base64.encode(str);
+    },
+    base64Decode(str: string) {
+        return Base64.decode(str);
+    },
+    md5(str: string) {
+        return crypto.createHash("md5").update(str).digest("hex");
+    },
+    aesEncode(str: string, key: string) {
+        const cipher = crypto.createCipheriv("aes-128-ecb", key, "");
+        let crypted = cipher.update(str, "utf8", "base64");
+        crypted += cipher.final("base64");
+        return crypted;
+    },
+    aesDecode(str: string, key: string) {
+        const decipher = crypto.createDecipheriv("aes-128-ecb", key, "");
+        let dec = decipher.update(str, "base64", "utf8");
+        dec += decipher.final("utf8");
+        return dec;
+    },
+    async fileXzipEncode(pathname: string): Promise<string> {
+        if (!fs.existsSync(pathname)) {
+            throw new Error(`Input file not found: ${pathname}`);
+        }
+
+        // Generate new filepath with .xzip extension
+        const basePath = pathname.substring(0, pathname.lastIndexOf("."));
+        const outputPath = basePath + ".xzip";
+
+        // Get file info
+        const fileStats = fs.statSync(pathname);
+        const fileSize = fileStats.size;
+        const fileExt = pathname.split(".").pop() || "";
+
+        // Generate random 16-character key
+        const encryptionKey = StrUtil.randomString(16);
+
+        // Create metadata
+        const filemeta = {
+            version: 1,
+            format: fileExt,
+            size: fileSize,
+            key: encryptionKey,
+        };
+
+        // Convert metadata to JSON and then base64 encode
+        const metaJson = JSON.stringify(filemeta);
+        const metaB64 = Buffer.from(metaJson, "utf-8").toString("base64");
+        const metaLength = metaB64.length;
+
+        // Prepare encryption key
+        const keyBytes = Buffer.from(encryptionKey, "utf-8");
+        const keyLength = keyBytes.length;
+
+        // Stream processing: read, encrypt and write in chunks
+        const inputStream = fs.createReadStream(pathname);
+        const outputStream = fs.createWriteStream(outputPath);
+
+        // Write metadata length (4 bytes, little-endian)
+        const metaLengthBuffer = Buffer.allocUnsafe(4);
+        metaLengthBuffer.writeUInt32LE(metaLength, 0);
+        outputStream.write(metaLengthBuffer);
+
+        // Write base64 encoded metadata
+        outputStream.write(Buffer.from(metaB64, "utf-8"));
+
+        // Stream encrypt the file content
+        let bytesProcessed = 0;
+        return new Promise((resolve, reject) => {
+            inputStream.on("data", (chunk: Buffer) => {
+                // XOR encrypt the chunk
+                const encryptedChunk = Buffer.alloc(chunk.length);
+                for (let i = 0; i < chunk.length; i++) {
+                    encryptedChunk[i] = chunk[i] ^ keyBytes[bytesProcessed % keyLength];
+                    bytesProcessed++;
+                }
+
+                // Write encrypted chunk
+                outputStream.write(encryptedChunk);
+            });
+
+            inputStream.on("end", () => {
+                outputStream.end();
+                resolve(outputPath);
+            });
+
+            inputStream.on("error", error => {
+                outputStream.destroy();
+                reject(error);
+            });
+
+            outputStream.on("error", error => {
+                inputStream.destroy();
+                reject(error);
+            });
+        });
+    },
+    async fileXzipDecode(pathname: string): Promise<string> {
+        if (!fs.existsSync(pathname)) {
+            throw new Error(`Input file not found: ${pathname}`);
+        }
+
+        if (!pathname.endsWith(".xzip")) {
+            return pathname; // Not an xzip file, return as is
+        }
+
+        let outputPath = pathname.replace(/\.xzip$/, "");
+
+        return new Promise((resolve, reject) => {
+            const inputStream = fs.createReadStream(pathname);
+            let metadataRead = false;
+            let filemeta: any = null;
+            let keyBytes: Buffer;
+            let bytesProcessed = 0;
+            let outputStream: fs.WriteStream;
+            let remainingMetaBytes = 0;
+            let metaBuffer = Buffer.alloc(0);
+
+            inputStream.on("data", (chunk: Buffer) => {
+                let chunkOffset = 0;
+
+                if (!metadataRead) {
+                    if (remainingMetaBytes === 0) {
+                        // Read metadata length (first 4 bytes)
+                        if (chunk.length < 4) {
+                            reject(new Error("Invalid xzip file: insufficient data for metadata length"));
+                            return;
+                        }
+                        const metaLength = chunk.readUInt32LE(0);
+                        remainingMetaBytes = metaLength;
+                        chunkOffset = 4;
+                    }
+
+                    // Read metadata
+                    const availableMetaBytes = Math.min(remainingMetaBytes, chunk.length - chunkOffset);
+                    const metaChunk = chunk.subarray(chunkOffset, chunkOffset + availableMetaBytes);
+                    metaBuffer = Buffer.concat([metaBuffer, metaChunk] as readonly Uint8Array[]);
+                    remainingMetaBytes -= availableMetaBytes;
+                    chunkOffset += availableMetaBytes;
+
+                    if (remainingMetaBytes === 0) {
+                        // Parse metadata
+                        try {
+                            const metaB64 = metaBuffer.toString("utf-8");
+                            const metaJson = Buffer.from(metaB64, "base64").toString("utf-8");
+                            filemeta = JSON.parse(metaJson);
+                            keyBytes = Buffer.from(filemeta.key, "utf-8");
+
+                            // Create output file with correct extension
+                            const finalOutputPath = outputPath + (filemeta.format ? "." + filemeta.format : "");
+                            outputStream = fs.createWriteStream(finalOutputPath);
+
+                            metadataRead = true;
+
+                            // Set the final output path for resolution
+                            outputPath = finalOutputPath;
+                        } catch (error) {
+                            reject(new Error("Invalid xzip file: corrupted metadata"));
+                            return;
+                        }
+                    }
+                }
+
+                if (metadataRead && chunkOffset < chunk.length) {
+                    // Decrypt remaining chunk data
+                    const encryptedChunk = chunk.subarray(chunkOffset);
+                    const decryptedChunk = Buffer.alloc(encryptedChunk.length);
+                    const keyLength = keyBytes.length;
+
+                    for (let i = 0; i < encryptedChunk.length; i++) {
+                        decryptedChunk[i] = encryptedChunk[i] ^ keyBytes[bytesProcessed % keyLength];
+                        bytesProcessed++;
+                    }
+
+                    outputStream.write(decryptedChunk);
+                }
+            });
+
+            inputStream.on("end", () => {
+                if (outputStream) {
+                    outputStream.end();
+                    resolve(outputPath);
+                } else {
+                    reject(new Error("Invalid xzip file: incomplete metadata"));
+                }
+            });
+
+            inputStream.on("error", error => {
+                if (outputStream) {
+                    outputStream.destroy();
+                }
+                reject(error);
+            });
+
+            if (outputStream) {
+                outputStream.on("error", error => {
+                    inputStream.destroy();
+                    reject(error);
+                });
+            }
+        });
+    },
+};
+
+export const IconvUtil = {
+    convert(str: string, to?: string, from?: string) {
+        if (!from) {
+            from = chardet.detect(Buffer.from(str));
+        }
+        to = to || "utf8";
+        const buffer = iconvLite.encode(str, from);
+        return iconvLite.decode(buffer, to);
+    },
+    bufferToUtf8(buffer: Buffer) {
+        const encoding = chardet.detect(buffer);
+        // if ('ISO-2022-CN' === encoding) {
+        //     const iconvInstance = new Iconv('ISO-2022-CN', 'UTF-8//TRANSLIT//IGNORE');
+        //     return iconvInstance.convert(buffer).toString()
+        // }
+        return iconvLite.decode(buffer, encoding).toString();
+    },
+    detect(buffer: Uint8Array) {
+        // detect str encoding
+        return chardet.detect(buffer);
+    },
+};
+
+export const StrUtil = {
+    randomString(len: number = 32) {
+        const chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        let result = "";
+        for (let i = len; i > 0; --i) {
+            result += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return result;
+    },
+    uuid() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    },
+    hashCode(str: string, length: number = 8) {
+        let hash = 0;
+        if (str.length === 0) return hash + "";
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        let result = Math.abs(hash).toString(16);
+        if (result.length < length) {
+            result = "0".repeat(length - result.length) + result;
+        }
+        return result;
+    },
+    hashCodeWithDuplicateCheck(str: string, check: string[], length: number = 8) {
+        let code = this.hashCode(str, length);
+        while (check.includes(code)) {
+            code = this.uuid().substring(0, length);
+        }
+        return code;
+    },
+    bigIntegerId() {
+        return [Date.now(), (Math.floor(Math.random() * 1000000) + "").padStart(6, "0")].join("");
+    },
+    ucFirst(str: string) {
+        if (!str) return "";
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+};
+
+export const TimeUtil = {
+    timestampInMs() {
+        return Date.now();
+    },
+    timestamp() {
+        return Math.floor(Date.now() / 1000);
+    },
+    format(time: number, format: string = "YYYY-MM-DD HH:mm:ss") {
+        return dayjs(time).format(format);
+    },
+    formatDate(time: number) {
+        return dayjs(time).format("YYYY-MM-DD");
+    },
+    dateString() {
+        return dayjs().format("YYYYMMDD");
+    },
+    datetimeString() {
+        return dayjs().format("YYYYMMDD_HHmmss_SSS");
+    },
+    timestampDayStart(msTimestamp?: number) {
+        let date = msTimestamp ? new Date(msTimestamp) : new Date();
+        date.setHours(0, 0, 0, 0);
+        return Math.floor(date.getTime() / 1000);
+    },
+    replacePattern(text: string) {
+        // @ts-ignore
+        return text.replaceAll("{year}", dayjs().format("YYYY"))
+            .replaceAll("{month}", dayjs().format("MM"))
+            .replaceAll("{day}", dayjs().format("DD"))
+            .replaceAll("{hour}", dayjs().format("HH"))
+            .replaceAll("{minute}", dayjs().format("mm"))
+            .replaceAll("{second}", dayjs().format("ss"));
+    },
+};
+
+export const FileUtil = {
+    MIME_TYPES: {
+        html: "text/html",
+        htm: "text/html",
+        js: "application/javascript",
+        css: "text/css",
+        json: "application/json",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        webp: "image/webp",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ttf: "font/ttf",
+        otf: "font/otf",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        wav: "audio/wav",
+        wasm: "application/wasm",
+        eot: "application/vnd.ms-fontobject",
+    },
+    getMimeByExt(ext: string, defaultMime: string = ""): string {
+        ext = ext.toLowerCase();
+        if (ext.startsWith(".")) {
+            ext = ext.substring(1);
+        }
+        return FileUtil.MIME_TYPES[ext] || defaultMime;
+    },
+    getMimeByPath(p: string, defaultMime: string = ""): string {
+        const extension = p.split(".").pop().toLowerCase();
+        return FileUtil.getMimeByExt(extension, defaultMime);
+    },
+    streamToBase64(stream: NodeJS.ReadableStream): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            stream.on("data", chunk => {
+                chunks.push(chunk);
+            });
+            stream.on("end", () => {
+                const buffer = Buffer.concat(chunks);
+                resolve(buffer.toString("base64"));
+            });
+            stream.on("error", error => {
+                reject(error);
+            });
+        });
+    },
+    bufferToBase64(buffer: Buffer) {
+        let binary = "";
+        let bytes = new Uint8Array(buffer);
+        let len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return EncodeUtil.base64Encode(binary);
+    },
+    base64ToBuffer(base64: string): Buffer {
+        if (base64.startsWith("data:")) {
+            base64 = base64.split("base64,")[1];
+        }
+        return Buffer.from(base64, "base64");
+    },
+    formatSize(size: number) {
+        if (size < 1024) {
+            return size + "B";
+        } else if (size < 1024 * 1024) {
+            return (size / 1024).toFixed(2) + "KB";
+        } else if (size < 1024 * 1024 * 1024) {
+            return (size / 1024 / 1024).toFixed(2) + "MB";
+        } else {
+            return (size / 1024 / 1024 / 1024).toFixed(2) + "GB";
+        }
+    },
+    async md5(filePath: string) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash("md5");
+            const stream = fs.createReadStream(filePath);
+            stream.on("data", data => {
+                hash.update(data);
+            });
+            stream.on("end", () => {
+                resolve(hash.digest("hex"));
+            });
+            stream.on("error", error => {
+                reject(error);
+            });
+        });
+    },
+};
+
+export const JsonUtil = {
+    stringifyOrdered(obj: any) {
+        return JSON.stringify(obj, Object.keys(obj).sort(), 4);
+    },
+    stringifyValueOrdered(obj: any) {
+        const sortedData = Object.fromEntries(
+            Object.entries(obj).sort(([, a], [, b]) => {
+                // @ts-ignore
+                return ((a as any) - b) as any;
+            })
+        );
+        return JSON.stringify(sortedData, null, 4);
+    },
+};
+
+export const ImportUtil = {
+    async loadCommonJs(cjsPath: string, forceReload: boolean = true) {
+        let tempPath = cjsPath;
+        if (forceReload) {
+            const md5 = await FileUtil.md5(cjsPath);
+            tempPath = path.join(
+                await FileIndex.tempDir('commonJs'),
+                `${md5}.cjs`,
+            )
+            if (!fs.existsSync(tempPath)) {
+                fs.copyFileSync(cjsPath, tempPath);
+            }
+        }
+        const backend = await import(/* @vite-ignore */ `file://${tempPath}`);
+        // console.log('loadCommonJs', `${cjsPath}?t=${md5}`)
+        return backend.default;
+    },
+};
+
+export const MemoryCacheUtil = {
+    pool: {} as {
+        [key: string]: {
+            value: any;
+            expire: number;
+        };
+    },
+    _gc() {
+        const now = TimeUtil.timestamp();
+        for (const key in this.pool) {
+            if (this.pool[key].expire < now) {
+                delete this.pool[key];
+            }
+        }
+    },
+    async remember(key: string, callback: () => Promise<any>, ttl: number = 60) {
+        if (this.pool[key] && this.pool[key].expire > TimeUtil.timestamp()) {
+            return this.pool[key].value;
+        }
+        const value = await callback();
+        this.pool[key] = {
+            value,
+            expire: TimeUtil.timestamp() + ttl,
+        };
+        this._gc();
+        return value;
+    },
+    get(key: string) {
+        if (this.pool[key] && this.pool[key].expire > TimeUtil.timestamp()) {
+            return this.pool[key].value;
+        }
+        this._gc();
+        return null;
+    },
+    set(key: string, value: any, ttl: number = 86400) {
+        this.pool[key] = {
+            value,
+            expire: TimeUtil.timestamp() + ttl,
+        };
+        this._gc();
+    },
+    forget(key: string) {
+        delete this.pool[key];
+    },
+};
+
+export const MemoryMapCacheUtil = {
+    pool: {} as {
+        [group: string]: {
+            [key: string]: {
+                value: any;
+                expire: number;
+            };
+        };
+    },
+    _gc() {
+        const now = TimeUtil.timestamp();
+        for (const group in this.pool) {
+            for (const key in this.pool[group]) {
+                if (this.pool[group][key].expire < now) {
+                    delete this.pool[group][key];
+                }
+            }
+        }
+    },
+    get(group: string, key: string) {
+        if (this.pool[group] && this.pool[group][key] && this.pool[group][key].expire > TimeUtil.timestamp()) {
+            return this.pool[group][key].value;
+        }
+        this._gc();
+        return null;
+    },
+    set(group: string, key: string, value: any, ttl: number = 86400) {
+        if (!this.pool[group]) {
+            this.pool[group] = {};
+        }
+        this.pool[group][key] = {
+            value,
+            expire: TimeUtil.timestamp() + ttl,
+        };
+        this._gc();
+    },
+    forget(group: string, key: string) {
+        if (this.pool[group]) {
+            delete this.pool[group][key];
+        }
+    },
+};
+
+export const ShellUtil = {
+    quotaPath(p: string) {
+        return `"${p}"`;
+    },
+    parseCommandArgs(command: string) {
+        let args = [];
+        let arg = "";
+        let quote = "";
+        let escape = false;
+        for (let i = 0; i < command.length; i++) {
+            const c = command[i];
+            if (escape) {
+                arg += c;
+                escape = false;
+                continue;
+            }
+            if ("\\" === c) {
+                escape = true;
+                arg += c;
+                continue;
+            }
+            if ("" === quote && (" " === c || "\t" === c)) {
+                if (arg) {
+                    args.push(arg);
+                    arg = "";
+                }
+                continue;
+            }
+            if ("" === quote && ('"' === c || "'" === c)) {
+                quote = c;
+                arg += c;
+                continue;
+            }
+            if ('"' === quote && '"' === c) {
+                quote = "";
+                arg += c;
+                continue;
+            }
+            if ("'" === quote && "'" === c) {
+                quote = "";
+                arg += c;
+                continue;
+            }
+            arg += c;
+        }
+        if (arg) {
+            args.push(arg);
+        }
+        return args;
+    },
+};
+
+export const VersionUtil = {
+    /**
+     * 检测版本是否匹配
+     * @param v string
+     * @param match string 如 * 或 >=1.0.0 或 >1.0.0 或 <1.0.0 或 <=1.0.0 或 1.0.0
+     */
+    match(v: string, match: string) {
+        if (match === "*") {
+            return true;
+        }
+        if (match.startsWith(">=")) {
+            if (this.ge(v, match.substring(2))) {
+                return true;
+            }
+        } else if (match.startsWith("<=")) {
+            if (this.le(v, match.substring(2))) {
+                return true;
+            }
+        } else if (match.startsWith(">")) {
+            if (this.gt(v, match.substring(1))) {
+                return true;
+            }
+        } else if (match.startsWith("<")) {
+            if (this.lt(v, match.substring(1))) {
+                return true;
+            }
+        } else {
+            return this.eq(v, match);
+        }
+        return false;
+    },
+    compare(v1: string, v2: string) {
+        const v1Arr = v1.split(".");
+        const v2Arr = v2.split(".");
+        for (let i = 0; i < v1Arr.length; i++) {
+            const v1Num = parseInt(v1Arr[i]);
+            const v2Num = parseInt(v2Arr[i]);
+            if (v1Num > v2Num) {
+                return 1;
+            } else if (v1Num < v2Num) {
+                return -1;
+            }
+        }
+        return 0;
+    },
+    gt(v1: string, v2: string) {
+        return VersionUtil.compare(v1, v2) > 0;
+    },
+    ge(v1: string, v2: string) {
+        return VersionUtil.compare(v1, v2) >= 0;
+    },
+    lt(v1: string, v2: string) {
+        return VersionUtil.compare(v1, v2) < 0;
+    },
+    le: (v1: string, v2: string) => {
+        return VersionUtil.compare(v1, v2) <= 0;
+    },
+    eq: (v1: string, v2: string) => {
+        return VersionUtil.compare(v1, v2) === 0;
+    },
+};
+
+export const UIUtil = {
+    sizeToPx(size: string, sizeFull: number) {
+        if (/^\d+$/.test(size)) {
+            // 纯数字
+            return parseInt(size);
+        } else if (size.endsWith("%")) {
+            // 百分比
+            let result = Math.floor((sizeFull * parseInt(size)) / 100);
+            result = Math.min(result, sizeFull);
+            return result;
+        } else {
+            throw "UnsupportSizeString";
+        }
+    },
+};
+
+export const ReUtil = {
+    match(regex: string, text: string) {
+        if ("" === regex || null === regex) {
+            return false;
+        }
+        if (regex.startsWith("/")) {
+            const index = regex.lastIndexOf("/");
+            const source = regex.slice(1, index);
+            const flags = regex.slice(index + 1);
+            return new RegExp(source, flags).test(text);
+        }
+        return new RegExp(regex).test(text);
+    },
+};
+
+const converter = new Showdown.Converter({
+    tables: true,
+});
+export const MarkdownUtil = {
+    toHtml(markdown: string): string {
+        return converter.makeHtml(markdown);
+    },
+};
+
+type HotkeyModifierType = "Control" | "Option" | "Command" | "Ctrl" | "Alt" | "Win" | "Meta" | "Shift";
+type HotkeyType = { key: string; modifiers: HotkeyModifierType[] };
+
+export const HotKeyUtil = {
+    orderModifiers(modifiers: HotkeyModifierType[]) {
+        const order = ["Control", "Ctrl", "Command", "Meta", "Win", "Option", "Alt", "Shift"];
+        return modifiers.sort((a, b) => {
+            return order.indexOf(a) - order.indexOf(b);
+        });
+    },
+    unifyObject(hotkey: HotkeyType) {
+        return {
+            key: hotkey.key.toUpperCase(),
+            modifiers: this.orderModifiers(hotkey.modifiers.map(modifier => StrUtil.ucFirst(modifier))),
+        };
+    },
+    unifyString(hotkey: string): HotkeyType {
+        const parts = hotkey.split("+");
+        const key = parts.pop() || "";
+        const modifiers: any[] = [];
+        parts.forEach(part => {
+            modifiers.push(StrUtil.ucFirst(part.trim()));
+        });
+        return this.unifyObject({key, modifiers});
+    },
+    unify(hotkeys: string | string[] | HotkeyType | HotkeyType[]): HotkeyType[] {
+        if (typeof hotkeys === "string") {
+            return [this.unifyString(hotkeys)];
+        } else if (Array.isArray(hotkeys)) {
+            return hotkeys.map(hotkey => {
+                if (typeof hotkey === "string") {
+                    return this.unifyString(hotkey);
+                } else {
+                    return this.unifyObject(hotkey);
+                }
+            });
+        } else {
+            return [this.unifyObject(hotkeys)];
+        }
+    },
+    getFromEvent(event: any): HotkeyType | null {
+        const valid = [
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+            "I",
+            "J",
+            "K",
+            "L",
+            "M",
+            "N",
+            "O",
+            "P",
+            "Q",
+            "R",
+            "S",
+            "T",
+            "U",
+            "V",
+            "W",
+            "X",
+            "Y",
+            "Z",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "0",
+            "Space",
+        ];
+        const key = (event.key || "").toUpperCase();
+        if (!event || !event.key || !valid.includes(key)) {
+            return null;
+        }
+        const modifiers: HotkeyModifierType[] = [];
+        if (isWin) {
+            if (event.ctrlKey || event.control) {
+                modifiers.push("Ctrl");
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push("Alt");
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push("Win");
+            }
+        } else if (isMac) {
+            if (event.ctrlKey || event.control) {
+                modifiers.push("Control");
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push("Option");
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push("Command");
+            }
+        } else {
+            if (event.ctrlKey || event.control) {
+                modifiers.push("Ctrl");
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push("Alt");
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push("Meta");
+            }
+        }
+        if (event.shiftKey || event.shift) {
+            modifiers.push("Shift");
+        }
+        return this.unifyObject({key, modifiers});
+    },
+    match(hotkeysForMatch: HotkeyType[], hotkey: HotkeyType): boolean {
+        if (!hotkeysForMatch || !hotkey) {
+            return false;
+        }
+        const hotKeyStr = hotkey.modifiers.join("+") + "+" + hotkey.key;
+        for (const key of hotkeysForMatch) {
+            const keyStr = key.modifiers.join("+") + "+" + key.key;
+            if (keyStr === hotKeyStr) {
+                return true;
+            }
+        }
+        return false;
+    },
+};