@flun/html-template 4.0.10

package/static/themeImg.css

@@ -0,0 +1,10 @@
+/* 主题图标样式 */
+#theme {
+    /* 绝对定位 */
+    position: fixed;
+    left: 20px;
+    top: 10px;
+    height: 40px;
+    z-index: 1002;
+    cursor: pointer;
+}

package/static/themeImg.js

@@ -0,0 +1,19 @@
+function initThemeImg() {
+    const themeIcon = document.createElement('img'), api = '/api/themeImg';
+    themeIcon.id = 'theme', themeIcon.alt = '切换主题';
+
+    // 设置图标回调(根据主题切换图片路径)
+    ThemeModule.setIconUpdateCallback(function (actualTheme) {
+        if (themeIcon) themeIcon.src = actualTheme === 'light' ? '/static/img/dark.png' : '/static/img/light.png';
+    });
+
+    // 获取储存样式(位置)并应用
+    getStyle(themeIcon, api), document.body.append(themeIcon);
+
+    // 处理点击和拖动
+    mouseOrTouch(themeIcon, () => ThemeModule.toggleTheme(), api);
+}
+
+// 页面加载完成后创建主题图标
+if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', initThemeImg);
+else initThemeImg();

package/static/themeModule.js

@@ -0,0 +1,222 @@
+// ===================== 主题模块 (优化版) =====================
+/**
+ * 主题管理模块，负责处理主题切换功能
+ *
+ * 主要优化：
+ * 1. 移除了重复的主题计算和设置逻辑
+ * 2. 使用永久系统主题监听器替代频繁销毁/重建
+ * 3. 简化初始化流程，同时保持功能完整
+ *
+ * 主要功能：
+ * 1. 支持三种主题模式：system（跟随系统）、light（明亮模式）、dark（暗黑模式）
+ * 2. 自动保存用户偏好到本地存储
+ * 3. 自动监听系统主题变化（当处于系统模式时）
+ * 4. 提供图标更新回调机制，只在浅色和深色模式间切换
+ *
+ * 使用说明：
+ * 1. 模块加载后自动初始化
+ * 2. 使用 setIconUpdateCallback 设置图标更新回调
+ * 3. 使用 toggleTheme 或 setPreference 切换主题
+ *
+ * @namespace
+ */
+const ThemeModule = (function () {
+	let currentPreference = 'system', iconUpdateCallback = null; 			// 私有变量,封装模块内部状态(主题偏好和图标更新回调函数)
+	const systemMedia = window.matchMedia('(prefers-color-scheme: dark)'); // 系统主题监听器
+
+	/**
+	 * 加载用户保存的主题偏好
+	 * @private
+	 */
+	function loadPreference() {
+		const savedPreference = localStorage.getItem('themePreference'); // 从本地存储获取保存的偏好设置
+		// 验证保存的偏好是否有效
+		if (savedPreference && ['system', 'light', 'dark'].includes(savedPreference)) currentPreference = savedPreference;
+	}
+
+	/**
+	 * 计算实际应用的主题
+	 * @private
+	 * @returns {'light' | 'dark'} 实际应用的主题
+	 */
+	function getActualTheme() {
+		if (currentPreference === 'system') return systemMedia.matches ? 'dark' : 'light'; // 当处于系统模式时，返回当前系统主题
+		return currentPreference; 														   // 否则返回用户指定的主题
+	}
+
+	/**
+	 * 应用主题到文档根元素
+	 * @private
+	 */
+	function applyTheme() {
+		const targetTheme = getActualTheme(); 							  // 获取实际应用的主题
+		document.documentElement.setAttribute('data-theme', targetTheme); // 设置文档根元素的data-theme属性
+	}
+
+	/**
+	 * 安全更新主题切换图标
+	 * @private
+	 */
+	function safeUpdateIcon() {
+		// 检查图标更新回调是否已设置
+		if (iconUpdateCallback && typeof iconUpdateCallback === 'function') {
+			try {
+				const actualTheme = getActualTheme(); // 获取当前实际应用的主题
+				iconUpdateCallback(actualTheme); 	  // 调用回调函数并传递当前实际主题
+			} catch (e) {
+				console.warn('主题图标更新失败', e);
+			}
+		}
+	}
+
+	/**
+	 * 处理系统主题变化事件
+	 * @private
+	 */
+	function handleSystemThemeChange() {
+		if (currentPreference === 'system') applyTheme(), safeUpdateIcon(); // 仅当处于系统模式时响应变化(更新主题和图标)
+	}
+
+	systemMedia.addEventListener('change', handleSystemThemeChange);        // 初始化系统主题监听器
+	// 公共API
+	return {
+		/**
+		 * 初始化主题模块
+		 * @method
+		 */
+		init: function () {
+			// 加载保存的偏好并应用主题
+			loadPreference(), applyTheme();
+			const updateOnReady = () => safeUpdateIcon();
+			if (document.readyState === 'complete') updateOnReady();			// DOM加载完成后更新图标
+			else document.addEventListener('DOMContentLoaded', updateOnReady); // 否则监听DOMContentLoaded事件
+		},
+
+		/**
+		 * 设置图标更新回调
+		 *
+		 * 使用说明：
+		 * 此方法用于设置主题切换时的图标更新回调
+		 * 回调函数将接收当前实际应用的主题值（'light' 或 'dark'）
+		 *
+		 * @param {Function} callback - 图标更新回调函数
+		 * @method
+		 */
+		setIconUpdateCallback: function (callback) {
+			if (typeof callback === 'function') iconUpdateCallback = callback, safeUpdateIcon(); // 设置后立即更新一次图标状态
+		},
+
+		/**
+		 * 设置主题偏好
+		 *
+		 * 使用说明：
+		 * 此方法直接设置主题偏好，适用于需要精确控制主题的场景
+		 *
+		 * 示例：
+		 * ThemeModule.setPreference('dark'); // 设置为暗黑模式
+		 * ThemeModule.setPreference('system'); // 设置为跟随系统
+		 *
+		 * @param {'system' | 'light' | 'dark'} preference - 主题偏好
+		 * @method
+		 */
+		setPreference: function (preference) {
+			if (['system', 'light', 'dark'].indexOf(preference) === -1) return;// 验证输入有效性
+			currentPreference = preference;									   // 更新当前偏好
+			localStorage.setItem('themePreference', preference);			   // 保存到本地存储
+			applyTheme(), safeUpdateIcon();									   // 应用新主题并更新图标
+		},
+
+		/**
+		 * 切换主题（在浅色和深色模式间切换）
+		 *
+		 * 使用说明：
+		 * 此方法用于在浅色和深色模式间切换，忽略系统模式
+		 * 如果当前是系统模式，会先切换到当前实际主题
+		 *
+		 * 示例：
+		 * document.getElementById('theme-toggle').addEventListener('click', () => {
+		 *     ThemeModule.toggleTheme();
+		 * });
+		 *
+		 * @method
+		 */
+		toggleTheme: function () {
+			// 获取当前实际主题,切换到相反的主题（忽略系统模式）
+			const currentTheme = this.getActualTheme(), newTheme = currentTheme === 'light' ? 'dark' : 'light';
+			this.setPreference(newTheme); // 设置新偏好
+		},
+
+		/**
+		 * 获取当前偏好设置
+		 *
+		 * 使用说明：
+		 * 此方法用于获取当前的主题偏好设置
+		 *
+		 * 示例：
+		 * const currentPref = ThemeModule.getPreference();
+		 * console.log('当前主题偏好:', currentPref);
+		 *
+		 * @returns {string} 当前主题偏好
+		 * @method
+		 */
+		getPreference: function () {
+			return currentPreference;
+		},
+
+		/**
+		 * 获取实际应用的主题
+		 *
+		 * 使用说明：
+		 * 此方法用于获取实际应用的主题（考虑系统偏好）
+		 *
+		 * 示例：
+		 * const actualTheme = ThemeModule.getActualTheme();
+		 * console.log('实际应用的主题:', actualTheme);
+		 *
+		 * @returns {string} 实际应用的主题 ('light' 或 'dark')
+		 * @method
+		 */
+		getActualTheme: function () {
+			return getActualTheme();
+		}
+	};
+})();
+
+ThemeModule.init(); // 初始化主题模块
+// ===================== 使用示例 =====================
+/**
+ * 基本使用：
+ * 1. 在页面加载后自动初始化(直接引入模块即可)
+
+//  切换主题：
+	document.getElementById('themeToggle').addEventListener('click', () => ThemeModule.toggleTheme());
+
+// 直接设置主题（'system'、'light' 或 'dark'）：
+	ThemeModule.setPreference('dark');
+
+// 包含图标的使用：
+	// 1. 设置图标回调（只需一次）
+		ThemeModule.setIconUpdateCallback(function (actualTheme) {
+			const iconElement = document.getElementById('theme-icon');
+			if (iconElement) {
+				const iconMap = {
+					light: 'fa-sun', // 明亮模式图标
+					dark: 'fa-moon'  // 暗黑模式图标
+				};
+				iconElement.className = `fas ${iconMap[actualTheme]}`;
+			}
+		});
+
+	// 2. 按钮点击切换主题和图标
+		document.getElementById('themeToggle').addEventListener('click', () => {
+			ThemeModule.toggleTheme(); // 同时切换主题和图标
+		});
+
+	// 添加图标动画效果（CSS示例）
+	.theme-toggle i {
+		transition: transform 0.3s ease;
+	}
+	.theme-toggle:hover i {
+		transform: rotate(20deg);
+	}
+*/

package/static/topImg.css

@@ -0,0 +1,19 @@
+/* ======= 返回顶部样式 ======= */
+:root {
+    --safe-area-bottom: env(safe-area-inset-bottom, 0px);
+}
+
+.scroll-to-top {
+    position: fixed;
+    right: 20px;
+    bottom: calc(8px + var(--safe-area-bottom));
+    height: 50px;
+    z-index: 1000;
+    opacity: 0;
+    transition: opacity 0.3s;
+    cursor: pointer;
+}
+
+.scroll-to-top.show {
+    opacity: 1;
+}

package/static/topImg.js

@@ -0,0 +1,21 @@
+function initTopImg() {
+    const topIcon = document.createElement('img'), api = '/api/topImg';
+    topIcon.className = 'scroll-to-top', topIcon.alt = '返回顶部', topIcon.src = '/static/img/top.png';
+    // 统一处理按钮显示/隐藏
+    function updateTopImg() {
+        topIcon.classList.toggle('show', window.pageYOffset > 300);
+    };
+
+    // 获取储存样式(位置)并应用
+    getStyle(topIcon, api), document.body.append(topIcon);
+
+    // 初始化时立即检查一次,然后添加一个事件监听器以检查更新
+    updateTopImg(), window.addEventListener('scroll', updateTopImg);
+
+    // 处理点击和拖动
+    mouseOrTouch(topIcon, () => window.scrollTo({ top: 0, behavior: 'smooth' }), api, true);
+}
+
+// 初始化
+if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', initTopImg);
+else initTopImg();

package/static/utils/browser13.js

@@ -0,0 +1,270 @@
+/* 基于[@simplewebauthn/browser@13.3.0] 开发 */
+!function (e, t) {
+    "object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd
+        ? define(["exports"], t) : t((e = "undefined" != typeof globalThis ? globalThis : e || self).flunWebAuthnBrowser = {})
+}(this, e => {
+    "use strict";
+
+    const defaultPropDescriptor = { enumerable: true, configurable: true, writable: true, value: void 0 },
+        falsePromise = Promise.resolve(false),
+        // 将 ArrayBuffer 转换为 Base64URL 字符串
+        bufferToBase64URLString = (e) => {
+            const t = new Uint8Array(e);
+            let r = "";
+            for (const e of t) r += String.fromCharCode(e);
+            return btoa(r).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
+        },
+        // 将 Base64URL 字符串转换为 ArrayBuffer
+        base64URLStringToBuffer = (e) => {
+            const t = e.replace(/-/g, "+").replace(/_/g, "/"), r = (4 - t.length % 4) % 4, n = t.padEnd(t.length + r, "="),
+                o = atob(n), i = new ArrayBuffer(o.length), a = new Uint8Array(i);
+            for (let e = 0; e < o.length; e++) a[e] = o.charCodeAt(e);
+            return i
+        },
+        o = { stubThis: e => e },
+        // 检查浏览器是否支持 WebAuthn
+        browserSupportsWebAuthn = () =>
+            o.stubThis(void 0 !== globalThis?.PublicKeyCredential && "function" == typeof globalThis.PublicKeyCredential),
+        // 转换允许凭证中的 ID 字段
+        convertAllowCredential = e => {
+            const { id: t } = e;
+            return { ...e, id: base64URLStringToBuffer(t), transports: e.transports }
+        },
+        // 验证域名有效性
+        isValidDomain = e =>
+            "localhost" === e || /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(e),
+
+        // WebAuthn 中止服务（用于取消进行中的认证/注册）
+        WebAuthnAbortService = new class {
+            constructor() {
+                Object.defineProperty(this, "controller", defaultPropDescriptor)
+            }
+            createNewAbortSignal() {
+                if (this.controller) {
+                    const e = new Error("正在取消已有的 WebAuthn API 调用,然后进行新的调用");
+                    e.name = "AbortError", this.controller.abort(e)
+                }
+                const e = new AbortController;
+                return this.controller = e, e.signal
+            }
+            cancelCeremony() {
+                if (this.controller) {
+                    const e = new Error("正在取消 WebAuthn API 调用");
+                    e.name = "AbortError", this.controller.abort(e), this.controller = void 0
+                }
+            }
+        },
+
+        authenticatorAttachmentValues = ["cross-platform", "platform"],
+        normalizeAuthenticatorAttachment = (e) => {
+            if (e && !(authenticatorAttachmentValues.indexOf(e) < 0)) return e
+        },
+        warnExtensionMishandling = (e, t) => {
+            console.warn(`拦截此 WebAuthn API 调用的浏览器扩展错误地实现了 ${e};请向扩展开发者报告此问题;\n`, t)
+        },
+        p = { stubThis: e => e },
+        // 检查浏览器是否支持 WebAuthn 自动填充
+        browserSupportsWebAuthnAutofill = () => {
+            if (!browserSupportsWebAuthn()) return p.stubThis(falsePromise);
+            const e = globalThis.PublicKeyCredential;
+            return void 0 === e?.isConditionalMediationAvailable ? p.stubThis(falsePromise)
+                : p.stubThis(e.isConditionalMediationAvailable())
+        };
+
+    // 自定义 WebAuthn 错误类
+    class WebAuthnError extends Error {
+        constructor({ message: e, code: t, cause: r, name: n }) {
+            super(e, { cause: r });
+            Object.defineProperty(this, "code", defaultPropDescriptor), this.name = n ?? r.name, this.code = t
+        }
+    };
+
+    // 导出内部工具（供测试/扩展使用）
+    e.WebAuthnAbortService = WebAuthnAbortService;
+    e.WebAuthnError = WebAuthnError;
+    e._browserSupportsWebAuthnAutofillInternals = p;
+    e._browserSupportsWebAuthnInternals = o;
+    e.base64URLStringToBuffer = base64URLStringToBuffer;
+    e.browserSupportsWebAuthn = browserSupportsWebAuthn;
+    e.browserSupportsWebAuthnAutofill = browserSupportsWebAuthnAutofill;
+    e.bufferToBase64URLString = bufferToBase64URLString;
+    e.platformAuthenticatorIsAvailable = () => {
+        return browserSupportsWebAuthn() ? PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() : falsePromise;
+    };
+
+    // 开始认证（登录）
+    e.startAuthentication = async e => {
+        if (!e.optionsJSON && e.challenge) {
+            console.warn(`startAuthentication() 调用方式不正确;将尝试继续使用提供的选项,但建议按照正确的调用结构重构;`);
+            e = { optionsJSON: e }
+        }
+        const { optionsJSON: o, useBrowserAutofill: c = !1, verifyBrowserAutofillInput: d = !0 } = e;
+        if (!browserSupportsWebAuthn()) throw new Error("当前浏览器不支持 WebAuthn");
+        let p, R;
+        if (0 !== o.allowCredentials?.length) p = o.allowCredentials?.map(convertAllowCredential);
+        const f = { ...o, challenge: base64URLStringToBuffer(o.challenge), allowCredentials: p }, b = {};
+        if (c) {
+            if (!await browserSupportsWebAuthnAutofill()) throw new Error("当前浏览器不支持 WebAuthn 自动填充");
+            if (document.querySelectorAll("input[autocomplete$='webauthn']").length < 1 && d)
+                throw new Error('未检测到任何 `autocomplete` 属性值以 "webauthn" 结尾的 <input> 元素');
+            b.mediation = "conditional", f.allowCredentials = []
+        }
+        b.publicKey = f, b.signal = WebAuthnAbortService.createNewAbortSignal();
+        try {
+            R = await navigator.credentials.get(b)
+        } catch (error) {
+            throw (({ error: e, options: t }) => {
+                const { publicKey: r } = t;
+                if (!r) throw new Error("options 缺少必需的 publicKey 属性");
+                if ("AbortError" === e.name) {
+                    if (t.signal instanceof AbortSignal) return new WebAuthnError({
+                        message: "认证流程收到了中止信号", code: "ERROR_CEREMONY_ABORTED", cause: e
+                    })
+                } else {
+                    if ("NotAllowedError" === e.name) return new WebAuthnError({
+                        message: e.message, code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY", cause: e
+                    });
+                    if ("SecurityError" === e.name) {
+                        const t = globalThis.location.hostname;
+                        if (!isValidDomain(t)) return new WebAuthnError({
+                            message: `${globalThis.location.hostname} 是无效域名`, code: "ERROR_INVALID_DOMAIN", cause: e
+                        });
+                        if (r.rpId !== t) return new WebAuthnError({
+                            message: `RP ID "${r.rpId}" 对于当前域名无效`, code: "ERROR_INVALID_RP_ID", cause: e
+                        })
+                    } else if ("UnknownError" === e.name) return new WebAuthnError({
+                        message: "验证器无法处理指定的选项或创建新的断言签名", code: "ERROR_AUTHENTICATOR_GENERAL_ERROR", cause: e
+                    })
+                }
+                return e
+            })({ error, options: b })
+        }
+        if (!R) throw new Error("认证未完成");
+        const { id: g, rawId: w, response: A, type: E } = R;
+        let m;
+        if (A.userHandle) m = bufferToBase64URLString(A.userHandle);
+        return {
+            id: g,
+            rawId: bufferToBase64URLString(w),
+            response: {
+                authenticatorData: bufferToBase64URLString(A.authenticatorData),
+                clientDataJSON: bufferToBase64URLString(A.clientDataJSON),
+                signature: bufferToBase64URLString(A.signature),
+                userHandle: m
+            },
+            type: E,
+            clientExtensionResults: R.getClientExtensionResults(),
+            authenticatorAttachment: normalizeAuthenticatorAttachment(R.authenticatorAttachment)
+        }
+    };
+
+    // 开始注册（创建凭证）
+    e.startRegistration = async e => {
+        if (!e.optionsJSON && e.challenge) {
+            console.warn("startRegistration() 调用方式不正确;将尝试继续使用提供的选项,但建议按照正确的调用结构重构;");
+            e = { optionsJSON: e }
+        }
+        const { optionsJSON: o, useAutoRegister: c = !1 } = e;
+        if (!browserSupportsWebAuthn()) throw new Error("当前浏览器不支持 WebAuthn");
+        const h = {
+            ...o, challenge: base64URLStringToBuffer(o.challenge),
+            user: {
+                ...o.user, id: base64URLStringToBuffer(o.user.id)
+            },
+            excludeCredentials: o.excludeCredentials?.map(convertAllowCredential)
+        }, p = {};
+        let f;
+        if (c) p.mediation = "conditional";
+        p.publicKey = h, p.signal = WebAuthnAbortService.createNewAbortSignal();
+        try {
+            f = await navigator.credentials.create(p)
+        } catch (error) {
+            throw (({ error: e, options: t }) => {
+                const { publicKey: r } = t;
+                if (!r) throw new Error("options 缺少必需的 publicKey 属性");
+                if ("AbortError" === e.name) {
+                    if (t.signal instanceof AbortSignal) return new WebAuthnError({
+                        message: "注册流程收到了中止信号", code: "ERROR_CEREMONY_ABORTED", cause: e
+                    })
+                } else if ("ConstraintError" === e.name) {
+                    if (!0 === r.authenticatorSelection?.requireResidentKey) return new WebAuthnError({
+                        message: "要求使用可发现凭证,但可用的验证器不支持",
+                        code: "ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT", cause: e
+                    });
+                    if ("conditional" === t.mediation && "required" === r.authenticatorSelection?.userVerification)
+                        return new WebAuthnError({
+                            message: "自动注册时要求用户验证,但无法执行",
+                            code: "ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE", cause: e
+                        });
+                    if ("required" === r.authenticatorSelection?.userVerification) return new WebAuthnError({
+                        message: "要求用户验证,但可用的验证器不支持",
+                        code: "ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT", cause: e
+                    })
+                } else {
+                    if ("InvalidStateError" === e.name) return new WebAuthnError({
+                        message: "该验证器已被注册过", code: "ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED", cause: e
+                    });
+                    if ("NotAllowedError" === e.name) return new WebAuthnError({
+                        message: e.message, code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY", cause: e
+                    });
+                    if ("NotSupportedError" === e.name) {
+                        if (0 === r.pubKeyCredParams.filter((e => "public-key" === e.type)).length) return new WebAuthnError({
+                            message: 'pubKeyCredParams 中没有 type 为 "public-key" 的条目',
+                            code: "ERROR_MALFORMED_PUBKEYCREDPARAMS", cause: e
+                        });
+                        return new WebAuthnError({
+                            message: "没有可用的验证器支持指定的任何 pubKeyCredParams 算法",
+                            code: "ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG", cause: e
+                        })
+                    }
+                    if ("SecurityError" === e.name) {
+                        const t = globalThis.location.hostname;
+                        if (!isValidDomain(t)) return new WebAuthnError({
+                            message: `${globalThis.location.hostname} 是无效域名`, code: "ERROR_INVALID_DOMAIN", cause: e
+                        });
+                        if (r.rp.id !== t) return new WebAuthnError({
+                            message: `RP ID "${r.rp.id}" 对于当前域名无效`, code: "ERROR_INVALID_RP_ID", cause: e
+                        })
+                    } else if ("TypeError" === e.name) {
+                        if (r.user.id.byteLength < 1 || r.user.id.byteLength > 64) return new WebAuthnError({
+                            message: "用户 ID 长度不在1~64字节之间", code: "ERROR_INVALID_USER_ID_LENGTH", cause: e
+                        })
+                    } else if ("UnknownError" === e.name) return new WebAuthnError({
+                        message: "验证器无法处理指定的选项或创建新的凭证", code: "ERROR_AUTHENTICATOR_GENERAL_ERROR", cause: e
+                    })
+                }
+                return e
+            })({ error, options: p })
+        }
+        if (!f) throw new Error("注册未完成");
+        const { id: b, rawId: R, response: g, type: w } = f;
+        let A, E, m, y;
+        if ("function" == typeof g.getTransports) A = g.getTransports();
+        if ("function" == typeof g.getPublicKeyAlgorithm) {
+            try { E = g.getPublicKeyAlgorithm() }
+            catch (e) { warnExtensionMishandling("getPublicKeyAlgorithm()", e) }
+        }
+        if ("function" == typeof g.getPublicKey) {
+            try {
+                const e = g.getPublicKey();
+                null !== e && (m = bufferToBase64URLString(e))
+            } catch (e) { warnExtensionMishandling("getPublicKey()", e) }
+        }
+        if ("function" == typeof g.getAuthenticatorData) {
+            try { y = bufferToBase64URLString(g.getAuthenticatorData()) }
+            catch (e) { warnExtensionMishandling("getAuthenticatorData()", e) }
+        }
+        return {
+            id: b,
+            rawId: bufferToBase64URLString(R),
+            response: {
+                attestationObject: bufferToBase64URLString(g.attestationObject),
+                clientDataJSON: bufferToBase64URLString(g.clientDataJSON),
+                transports: A, publicKeyAlgorithm: E, publicKey: m, authenticatorData: y
+            },
+            type: w,
+            clientExtensionResults: f.getClientExtensionResults(),
+            authenticatorAttachment: normalizeAuthenticatorAttachment(f.authenticatorAttachment)
+        }
+    }
+});