befly 3.51.0 → 3.53.0

package/apis/auth/login.js

@@ -1,6 +1,5 @@
-import { UAParser } from "ua-parser-js";
-
 import adminTable from "#befly/tables/admin.json";
+import { parseUserAgent } from "#befly/utils/userAgent.js";
 import { toSessionTtlSeconds } from "#befly/utils/util.js";
 
 export default {
@@ -27,7 +26,7 @@ export default {
     required: ["account", "password", "loginType"],
     handler: async (befly, ctx) => {
         const userAgent = ctx.req.headers.get("user-agent") || "";
-        const uaResult = UAParser(userAgent);
+        const uaData = parseUserAgent(userAgent);
 
         const logData = {
             adminId: 0,
@@ -35,15 +34,15 @@ export default {
             nickname: "",
             ip: ctx.ip || "",
             userAgent: userAgent.substring(0, 500),
-            browserName: uaResult.browser.name || "",
-            browserVersion: uaResult.browser.version || "",
-            osName: uaResult.os.name || "",
-            osVersion: uaResult.os.version || "",
-            deviceType: uaResult.device.type || "desktop",
-            deviceVendor: uaResult.device.vendor || "",
-            deviceModel: uaResult.device.model || "",
-            engineName: uaResult.engine.name || "",
-            cpuArchitecture: uaResult.cpu.architecture || "",
+            browserName: uaData.browserName,
+            browserVersion: uaData.browserVersion,
+            osName: uaData.osName,
+            osVersion: uaData.osVersion,
+            deviceType: uaData.deviceType,
+            deviceVendor: uaData.deviceVendor,
+            deviceModel: uaData.deviceModel,
+            engineName: uaData.engineName,
+            cpuArchitecture: uaData.cpuArchitecture,
             loginTime: Date.now(),
             loginResult: 0,
             failReason: ""

package/apis/email/send.js

@@ -11,13 +11,7 @@ export default {
         subject: emailLogTable.subject,
         content: emailLogTable.content,
         cc: emailLogTable.ccEmail,
-        bcc: emailLogTable.bccEmail,
-        isHtml: {
-            name: "是否HTML",
-            min: null,
-            max: null,
-            input: "string"
-        }
+        bcc: emailLogTable.bccEmail
     },
     required: ["to", "subject", "content"],
     handler: async (befly, ctx) => {
@@ -36,8 +30,7 @@ export default {
         const result = await befly.email.sendMail({
             to: ctx.body.to,
             subject: ctx.body.subject,
-            html: ctx.body.isHtml ? ctx.body.content : undefined,
-            text: ctx.body.isHtml ? undefined : ctx.body.content,
+            text: ctx.body.content,
             cc: ctx.body.cc,
             bcc: ctx.body.bcc
         });

package/apis/tongJi/errorReport.js

@@ -1,7 +1,6 @@
-import { UAParser } from "ua-parser-js";
-
 import errorReportTable from "#befly/tables/errorReport.json";
 import { getDateYmdNumber, getTimeBucketStart } from "#befly/utils/datetime.js";
+import { parseUserAgent } from "#befly/utils/userAgent.js";
 
 import { expireTongJiRedisKeys, getErrorStatsDayBucketCountKey, getErrorStatsDayBucketsKey, getErrorStatsDayTypeCountKey, getErrorStatsDayTypesKey, getErrorStatsPeriodCountKey, getTongJiMonthStartDate, getTongJiWeekStartDate } from "./_tongJi.js";
 
@@ -17,20 +16,7 @@ function getErrorReportUaData(ctx) {
         userAgent = ctx.headers.get("user-agent") || "";
     }
 
-    const uaResult = UAParser(userAgent);
-
-    return {
-        userAgent: userAgent,
-        browserName: uaResult.browser.name || "",
-        browserVersion: uaResult.browser.version || "",
-        osName: uaResult.os.name || "",
-        osVersion: uaResult.os.version || "",
-        deviceType: uaResult.device.type || "desktop",
-        deviceVendor: uaResult.device.vendor || "",
-        deviceModel: uaResult.device.model || "",
-        engineName: uaResult.engine.name || "",
-        cpuArchitecture: uaResult.cpu.architecture || ""
-    };
+    return parseUserAgent(userAgent);
 }
 
 async function updateErrorStatsRedis(befly, now, bucketDate, bucketTime, errorType) {

package/lib/smtpText.js

@@ -0,0 +1,283 @@
+import { Buffer } from "node:buffer";
+
+function encodeBase64(value) {
+    return Buffer.from(String(value || ""), "utf8").toString("base64");
+}
+
+function sanitizeHeaderValue(value) {
+    return String(value || "")
+        .replace(/[\r\n]+/g, " ")
+        .trim();
+}
+
+function encodeHeaderValue(value) {
+    const text = sanitizeHeaderValue(value);
+    if (/^[\x20-\x7E]*$/.test(text)) {
+        return text;
+    }
+    return `=?UTF-8?B?${encodeBase64(text)}?=`;
+}
+
+function normalizeSecureValue(value) {
+    return value === true || value === 1;
+}
+
+function parseAddressList(value) {
+    return String(value || "")
+        .split(/[;,]/)
+        .map(function (item) {
+            const trimmed = item.trim();
+            const matched = /<([^<>]+)>/.exec(trimmed);
+            return matched ? matched[1].trim() : trimmed;
+        })
+        .filter(function (item) {
+            return item.length > 0;
+        });
+}
+
+function buildAddressHeader(label, email) {
+    const cleanEmail = sanitizeHeaderValue(email);
+    if (!label) {
+        return cleanEmail;
+    }
+    return `${encodeHeaderValue(label)} <${cleanEmail}>`;
+}
+
+function dotStuffText(value) {
+    return String(value || "")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .split("\n")
+        .map(function (line) {
+            return line.startsWith(".") ? `.${line}` : line;
+        })
+        .join("\r\n");
+}
+
+function createMessageId(config) {
+    return `<${Date.now()}.${Math.random().toString(36).slice(2)}@${String(config.host || "localhost").replace(/[^a-zA-Z0-9.-]/g, "")}>`;
+}
+
+export function createSmtpTextMessage(config, options) {
+    const toList = parseAddressList(options.to);
+    const ccList = parseAddressList(options.cc);
+    const bccList = parseAddressList(options.bcc);
+    const messageId = createMessageId(config);
+    const headers = [
+        `From: ${buildAddressHeader(config.label, config.user)}`,
+        `To: ${toList.join(", ")}`,
+        ccList.length > 0 ? `Cc: ${ccList.join(", ")}` : "",
+        `Subject: ${encodeHeaderValue(options.subject)}`,
+        `Message-ID: ${messageId}`,
+        "MIME-Version: 1.0",
+        "Content-Type: text/plain; charset=utf-8",
+        "Content-Transfer-Encoding: 8bit"
+    ].filter(function (item) {
+        return item.length > 0;
+    });
+
+    return {
+        messageId: messageId,
+        recipients: toList.concat(ccList, bccList),
+        message: `${headers.join("\r\n")}\r\n\r\n${dotStuffText(options.text)}`
+    };
+}
+
+function createResponseReader() {
+    const decoder = new TextDecoder();
+    const waiters = [];
+    let buffer = "";
+    let closedError = null;
+
+    function readCompleteResponse() {
+        const lines = buffer.split(/\r?\n/);
+        const completeLines = lines.slice(0, -1);
+        if (completeLines.length === 0) {
+            return null;
+        }
+
+        const responseLines = [];
+        let consumedCount = 0;
+        let code = 0;
+        for (const line of completeLines) {
+            consumedCount = consumedCount + 1;
+            responseLines.push(line);
+            const matched = /^(\d{3})([ -])/.exec(line);
+            if (!matched) {
+                continue;
+            }
+            code = Number(matched[1]);
+            if (matched[2] === " ") {
+                buffer = lines.slice(consumedCount).join("\n");
+                return {
+                    code: code,
+                    lines: responseLines,
+                    text: responseLines.join("\n")
+                };
+            }
+        }
+
+        return null;
+    }
+
+    function flushWaiters() {
+        while (waiters.length > 0) {
+            if (closedError) {
+                waiters.shift().reject(closedError);
+                continue;
+            }
+
+            const response = readCompleteResponse();
+            if (!response) {
+                return;
+            }
+            waiters.shift().resolve(response);
+        }
+    }
+
+    return {
+        append: function (data) {
+            buffer += decoder.decode(data, { stream: true });
+            flushWaiters();
+        },
+        close: function (error) {
+            closedError =
+                error ||
+                new Error("SMTP 连接已关闭", {
+                    cause: null,
+                    code: "runtime",
+                    subsystem: "smtp",
+                    operation: "readResponse"
+                });
+            flushWaiters();
+        },
+        read: function () {
+            return new Promise(function (resolve, reject) {
+                waiters.push({
+                    resolve: resolve,
+                    reject: reject
+                });
+                flushWaiters();
+            });
+        }
+    };
+}
+
+async function readResponseWithTimeout(reader, timeout) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            reader.read(),
+            new Promise(function (_resolve, reject) {
+                timer = setTimeout(function () {
+                    reject(
+                        new Error("SMTP 响应超时", {
+                            cause: null,
+                            code: "runtime",
+                            subsystem: "smtp",
+                            operation: "readResponse"
+                        })
+                    );
+                }, timeout);
+            })
+        ]);
+    } finally {
+        clearTimeout(timer);
+    }
+}
+
+async function expectResponse(reader, expectedCodes, commandName, timeout) {
+    const response = await readResponseWithTimeout(reader, timeout);
+    if (!expectedCodes.includes(response.code)) {
+        throw new Error(`SMTP ${commandName} 响应异常: ${response.text}`, {
+            cause: null,
+            code: "runtime",
+            subsystem: "smtp",
+            operation: commandName,
+            response: response.text
+        });
+    }
+    return response;
+}
+
+function writeCommand(socket, command) {
+    socket.write(`${command}\r\n`);
+}
+
+export async function sendSmtpTextMail(config, options) {
+    const mail = createSmtpTextMessage(config, options);
+    if (mail.recipients.length === 0) {
+        throw new Error("邮件收件人不能为空", {
+            cause: null,
+            code: "validation",
+            subsystem: "smtp",
+            operation: "sendSmtpTextMail"
+        });
+    }
+
+    const reader = createResponseReader();
+    const socket = await Bun.connect({
+        hostname: config.host,
+        port: config.port || 25,
+        tls: normalizeSecureValue(config.secure),
+        socket: {
+            data: function (_socket, data) {
+                reader.append(data);
+            },
+            close: function (_socket, error) {
+                reader.close(error || null);
+            },
+            error: function (_socket, error) {
+                reader.close(error);
+            },
+            connectError: function (_socket, error) {
+                reader.close(error);
+            },
+            end: function () {
+                reader.close(null);
+            }
+        }
+    });
+
+    try {
+        const timeout = 10000;
+        await expectResponse(reader, [220], "connect", timeout);
+
+        writeCommand(socket, "EHLO localhost");
+        await expectResponse(reader, [250], "ehlo", timeout);
+
+        writeCommand(socket, "AUTH LOGIN");
+        await expectResponse(reader, [334], "authUser", timeout);
+
+        writeCommand(socket, encodeBase64(config.user));
+        await expectResponse(reader, [334], "authPassword", timeout);
+
+        writeCommand(socket, encodeBase64(config.pass));
+        await expectResponse(reader, [235], "auth", timeout);
+
+        writeCommand(socket, `MAIL FROM:<${config.user}>`);
+        await expectResponse(reader, [250], "mailFrom", timeout);
+
+        for (const recipient of mail.recipients) {
+            writeCommand(socket, `RCPT TO:<${recipient}>`);
+            await expectResponse(reader, [250, 251], "rcptTo", timeout);
+        }
+
+        writeCommand(socket, "DATA");
+        await expectResponse(reader, [354], "data", timeout);
+
+        socket.write(`${mail.message}\r\n.\r\n`);
+        const response = await expectResponse(reader, [250], "message", timeout);
+
+        writeCommand(socket, "QUIT");
+        socket.end();
+
+        return {
+            messageId: mail.messageId,
+            response: response.text
+        };
+    } catch (error) {
+        socket.end();
+        throw error;
+    }
+}

package/lib/xmlParse.js

@@ -1,21 +1,170 @@
-import { XMLParser } from "fast-xml-parser";
+import { isString } from "#befly/utils/is.js";
 
-import { isPlainObject, isString } from "#befly/utils/is.js";
+function decodeXmlText(value) {
+    return String(value)
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"');
+}
 
-const xmlParser = new XMLParser();
+function normalizeXmlValue(value) {
+    const text = decodeXmlText(value.trim());
+    if (text === "") {
+        return "";
+    }
+    const numberValue = Number(text);
+    if (Number.isFinite(numberValue) && String(numberValue) === text) {
+        return numberValue;
+    }
+    return text;
+}
 
-function normalizeXmlBody(parsed) {
-    if (!isPlainObject(parsed)) {
-        return parsed;
+function assignNodeValue(target, key, value) {
+    if (Object.hasOwn(target, key)) {
+        if (Array.isArray(target[key])) {
+            target[key].push(value);
+            return;
+        }
+        target[key] = [target[key], value];
+        return;
     }
 
-    const rootKeys = Object.keys(parsed).filter((key) => !key.startsWith("?"));
-    if (rootKeys.length !== 1) {
-        return parsed;
+    target[key] = value;
+}
+
+function skipIgnoredMarkup(rawXml, startIndex) {
+    let index = startIndex;
+
+    while (index < rawXml.length) {
+        while (/\s/.test(rawXml[index])) {
+            index += 1;
+        }
+
+        if (rawXml.startsWith("<?", index)) {
+            const declarationEnd = rawXml.indexOf("?>", index);
+            if (declarationEnd < 0) {
+                throw new Error("XML 声明未闭合", {
+                    cause: null,
+                    code: "validation",
+                    subsystem: "xml",
+                    operation: "skipIgnoredMarkup"
+                });
+            }
+            index = declarationEnd + 2;
+            continue;
+        }
+
+        if (rawXml.startsWith("<!--", index)) {
+            const commentEnd = rawXml.indexOf("-->", index);
+            if (commentEnd < 0) {
+                throw new Error("XML 注释未闭合", {
+                    cause: null,
+                    code: "validation",
+                    subsystem: "xml",
+                    operation: "skipIgnoredMarkup"
+                });
+            }
+            index = commentEnd + 3;
+            continue;
+        }
+
+        return index;
     }
 
-    const rootKey = rootKeys[0];
-    return isPlainObject(parsed[rootKey]) ? parsed[rootKey] : parsed;
+    return index;
+}
+
+function parseNode(rawXml, startIndex) {
+    const openEnd = rawXml.indexOf(">", startIndex);
+    if (openEnd < 0) {
+        throw new Error("XML 开始标签不完整", {
+            cause: null,
+            code: "validation",
+            subsystem: "xml",
+            operation: "parseNode"
+        });
+    }
+
+    const openContent = rawXml.slice(startIndex + 1, openEnd).trim();
+    const isSelfClosing = openContent.endsWith("/");
+    const tagName = (isSelfClosing ? openContent.slice(0, -1).trim() : openContent).split(/\s+/)[0];
+    if (!tagName || tagName.startsWith("/")) {
+        throw new Error("XML 标签格式不正确", {
+            cause: null,
+            code: "validation",
+            subsystem: "xml",
+            operation: "parseNode"
+        });
+    }
+    if (isSelfClosing) {
+        return {
+            key: tagName,
+            value: "",
+            index: openEnd + 1
+        };
+    }
+
+    let index = openEnd + 1;
+    let text = "";
+    const children = {};
+    let hasChild = false;
+
+    while (index < rawXml.length) {
+        index = skipIgnoredMarkup(rawXml, index);
+
+        if (rawXml.startsWith("<![CDATA[", index)) {
+            const cdataEnd = rawXml.indexOf("]]>", index);
+            if (cdataEnd < 0) {
+                throw new Error("XML CDATA 未闭合", {
+                    cause: null,
+                    code: "validation",
+                    subsystem: "xml",
+                    operation: "parseNode"
+                });
+            }
+            text += rawXml.slice(index + 9, cdataEnd);
+            index = cdataEnd + 3;
+            continue;
+        }
+
+        if (rawXml.startsWith(`</${tagName}>`, index)) {
+            index += tagName.length + 3;
+            return {
+                key: tagName,
+                value: hasChild ? children : normalizeXmlValue(text),
+                index: index
+            };
+        }
+
+        if (rawXml[index] === "<") {
+            const child = parseNode(rawXml, index);
+            hasChild = true;
+            assignNodeValue(children, child.key, child.value);
+            index = child.index;
+            continue;
+        }
+
+        const nextTagIndex = rawXml.indexOf("<", index);
+        if (nextTagIndex < 0) {
+            throw new Error("XML 结束标签缺失", {
+                cause: null,
+                code: "validation",
+                subsystem: "xml",
+                operation: "parseNode"
+            });
+        }
+        text += rawXml.slice(index, nextTagIndex);
+        index = nextTagIndex;
+    }
+
+    throw new Error("XML 标签未闭合", {
+        cause: null,
+        code: "validation",
+        subsystem: "xml",
+        operation: "parseNode"
+    });
 }
 
 export function xmlParse(value) {
@@ -28,5 +177,17 @@ export function xmlParse(value) {
         });
     }
 
-    return normalizeXmlBody(xmlParser.parse(value));
+    const normalized = value.trim();
+    const startIndex = skipIgnoredMarkup(normalized, 0);
+    if (normalized[startIndex] !== "<") {
+        throw new Error("XML 根节点缺失", {
+            cause: null,
+            code: "validation",
+            subsystem: "xml",
+            operation: "xmlParse"
+        });
+    }
+
+    const node = parseNode(normalized, startIndex);
+    return node.key === "xml" && Object.prototype.toString.call(node.value) === "[object Object]" ? node.value : { [node.key]: node.value };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.51.0",
+    "version": "3.53.0",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
@@ -55,11 +55,8 @@
         "test": "bun test"
     },
     "dependencies": {
-        "fast-xml-parser": "^5.8.0",
-        "nodemailer": "^8.0.10",
         "pathe": "^2.0.3",
         "picomatch": "^4.0.4",
-        "ua-parser-js": "^2.0.10",
         "zod": "^4.4.3"
     },
     "engines": {

package/plugins/email.js

@@ -1,38 +1,15 @@
-/**
- * 邮件插件
- * 提供邮件发送功能，支持 SMTP 配置
- */
-
-import nodemailer from "nodemailer";
-
 import { Logger } from "#befly/lib/logger.js";
+import { sendSmtpTextMail } from "#befly/lib/smtpText.js";
 import { hasEmailConfig } from "#befly/utils/email.js";
 
 export default {
     order: 7,
     handler: async function (befly) {
         const config = befly?.config?.email || {};
-        let transporter = null;
-
-        if (hasEmailConfig(config)) {
-            try {
-                transporter = nodemailer.createTransport({
-                    host: config.host,
-                    port: config.port || 25,
-                    secure: config.secure ?? config.ssl,
-                    auth: {
-                        user: config.user,
-                        pass: config.pass
-                    },
-                    connectionTimeout: config.timeout || 10000
-                });
-            } catch (error) {
-                Logger.warn("邮件服务初始化失败", { err: error });
-            }
-        }
+        const enabled = hasEmailConfig(config);
 
         const sendMail = async function (options) {
-            if (!transporter) {
+            if (!enabled) {
                 Logger.warn("邮件未配置，已禁用发送");
                 return {
                     success: false,
@@ -41,15 +18,12 @@ export default {
             }
 
             try {
-                const info = await transporter.sendMail({
-                    text: options.text,
-                    html: options.html,
-                    from: options.from || (config.label ? `${config.label} <${config.user}>` : config.user),
+                const info = await sendSmtpTextMail(config, {
                     to: options.to,
                     cc: options.cc,
                     bcc: options.bcc,
                     subject: options.subject,
-                    attachments: options.attachments
+                    text: options.text || ""
                 });
                 return {
                     success: true,

package/scripts/syncDb/transform.js

@@ -1,6 +1,6 @@
 import { DECIMAL_KIND_TYPES, ENUM_KIND_TYPES, FLOAT_KIND_TYPES, INT_KIND_TYPES, JSON_KIND_TYPES, STRING_KIND_TYPES, TEXT_KIND_TYPES } from "#befly/configs/constConfig.js";
 import { isNonEmptyString, isNumber } from "#befly/utils/is.js";
-import { camelCaseKeepUnderscore } from "#befly/utils/util.js";
+import { camelCase, snakeCase } from "#befly/utils/util.js";
 
 function resolveSyncDbEnumInput(columnType) {
     const matched = /^enum\((.*)\)$/.exec(columnType);
@@ -90,7 +90,9 @@ function resolveSyncDbMaxByColumn(columnMeta) {
 }
 
 export function toSyncDbFieldDef(columnMeta) {
-    const fieldName = camelCaseKeepUnderscore(columnMeta.columnName);
+    const camelFieldName = camelCase(columnMeta.columnName);
+    const columnName = String(columnMeta.columnName || "");
+    const fieldName = snakeCase(camelFieldName) === columnName ? camelFieldName : columnName;
     const fieldDisplayName = isNonEmptyString(columnMeta.columnComment) ? String(columnMeta.columnComment).trim() : fieldName;
     const fieldInput = resolveSyncDbInputByColumn(columnMeta);
     const fieldMax = resolveSyncDbMaxByColumn(columnMeta);

package/utils/userAgent.js

@@ -0,0 +1,172 @@
+const WINDOWS_VERSION_MAP = {
+    "10.0": "10",
+    6.3: "8.1",
+    6.2: "8",
+    6.1: "7"
+};
+
+function getMatchedVersion(userAgent, regexp) {
+    const matched = regexp.exec(userAgent);
+    return matched ? matched[1].replace(/_/g, ".") : "";
+}
+
+function getBrowserData(userAgent) {
+    const browserRules = [
+        ["WeChat", /MicroMessenger\/([\d.]+)/],
+        ["Edge", /Edg(?:e|A|iOS)?\/([\d.]+)/],
+        ["Opera", /OPR\/([\d.]+)/],
+        ["Firefox", /FxiOS\/([\d.]+)|Firefox\/([\d.]+)/],
+        ["Chrome", /CriOS\/([\d.]+)|Chrome\/([\d.]+)/],
+        ["Safari", /Version\/([\d.]+).*Safari/],
+        ["IE", /MSIE\s([\d.]+)|Trident\/.*rv:([\d.]+)/]
+    ];
+
+    for (const [name, regexp] of browserRules) {
+        const matched = regexp.exec(userAgent);
+        if (matched) {
+            return {
+                browserName: name === "Safari" && /iPhone|iPad|iPod/i.test(userAgent) ? "Mobile Safari" : name,
+                browserVersion: matched[1] || matched[2] || ""
+            };
+        }
+    }
+
+    return {
+        browserName: "",
+        browserVersion: ""
+    };
+}
+
+function getOsData(userAgent) {
+    const androidVersion = getMatchedVersion(userAgent, /Android\s([\d.]+)/);
+    if (androidVersion) {
+        return {
+            osName: "Android",
+            osVersion: androidVersion
+        };
+    }
+
+    const iosVersion = getMatchedVersion(userAgent, /(?:iPhone|iPad|iPod).*OS\s([\d_]+)/);
+    if (iosVersion) {
+        return {
+            osName: "iOS",
+            osVersion: iosVersion
+        };
+    }
+
+    const windowsVersion = getMatchedVersion(userAgent, /Windows NT\s([\d.]+)/);
+    if (windowsVersion) {
+        return {
+            osName: "Windows",
+            osVersion: WINDOWS_VERSION_MAP[windowsVersion] || windowsVersion
+        };
+    }
+
+    const macVersion = getMatchedVersion(userAgent, /Mac OS X\s([\d_]+)/);
+    if (macVersion) {
+        return {
+            osName: "macOS",
+            osVersion: macVersion
+        };
+    }
+
+    if (/Linux/i.test(userAgent)) {
+        return {
+            osName: "Linux",
+            osVersion: ""
+        };
+    }
+
+    return {
+        osName: "",
+        osVersion: ""
+    };
+}
+
+function getDeviceType(userAgent) {
+    if (/iPad|Tablet|PlayBook|Silk/i.test(userAgent) || (/Android/i.test(userAgent) && !/Mobile/i.test(userAgent))) {
+        return "tablet";
+    }
+    if (/Mobi|iPhone|iPod|Android|Windows Phone/i.test(userAgent)) {
+        return "mobile";
+    }
+    return "desktop";
+}
+
+function getAndroidDeviceModel(userAgent) {
+    const matched = /Android[\d.\s]*;\s*([^;)]+?)(?:\s+Build\/|;|\))/i.exec(userAgent);
+    return matched ? matched[1].trim() : "";
+}
+
+function getDeviceData(userAgent) {
+    const deviceType = getDeviceType(userAgent);
+    if (/iPhone/i.test(userAgent)) {
+        return {
+            deviceType: deviceType,
+            deviceVendor: "Apple",
+            deviceModel: "iPhone"
+        };
+    }
+    if (/iPad/i.test(userAgent)) {
+        return {
+            deviceType: deviceType,
+            deviceVendor: "Apple",
+            deviceModel: "iPad"
+        };
+    }
+
+    return {
+        deviceType: deviceType,
+        deviceVendor: "",
+        deviceModel: getAndroidDeviceModel(userAgent)
+    };
+}
+
+function getEngineName(userAgent) {
+    if (/Chrome|CriOS|Edg|OPR/i.test(userAgent)) {
+        return "Blink";
+    }
+    if (/Firefox|FxiOS/i.test(userAgent)) {
+        return "Gecko";
+    }
+    if (/AppleWebKit|Safari/i.test(userAgent)) {
+        return "WebKit";
+    }
+    if (/Trident|MSIE/i.test(userAgent)) {
+        return "Trident";
+    }
+    return "";
+}
+
+function getCpuArchitecture(userAgent) {
+    if (/x86_64|Win64|x64|amd64/i.test(userAgent)) {
+        return "amd64";
+    }
+    if (/arm64|aarch64/i.test(userAgent)) {
+        return "arm64";
+    }
+    if (/arm/i.test(userAgent)) {
+        return "arm";
+    }
+    return "";
+}
+
+export function parseUserAgent(userAgent) {
+    const text = String(userAgent || "");
+    const browserData = getBrowserData(text);
+    const osData = getOsData(text);
+    const deviceData = getDeviceData(text);
+
+    return {
+        userAgent: text,
+        browserName: browserData.browserName,
+        browserVersion: browserData.browserVersion,
+        osName: osData.osName,
+        osVersion: osData.osVersion,
+        deviceType: deviceData.deviceType,
+        deviceVendor: deviceData.deviceVendor,
+        deviceModel: deviceData.deviceModel,
+        engineName: getEngineName(text),
+        cpuArchitecture: getCpuArchitecture(text)
+    };
+}