@flun/webauthn-browser 2.1.9 → 2.1.10

package/CHANGELOG.md

@@ -1,4 +1,10 @@
 # 变更日志
+
+## [2.1.10] - 2026-10-25 15:29
+### 优化
+- 项目标点已改为以英文标点为主;
+- 行宽改为以 123 为主,部分超宽表格改为了列表;
+
 ## [2.1.9] - 2026-09-29 20:04
 ### 优化
 - 优化了内部细节;

package/LICENSE

@@ -1,19 +1,35 @@
-SC 开源许可声明
-版权信息
-衍生开发 Copyright (c) 2026, flun <open@flun.top>
-
-本项目（软件包）基于 Matthew Miller 作者的原代码进行开发、修改和扩展。
-
-使用条款
-本软件以“原样”提供，任何人都可以自由地：
-
-使用：用于任何目的，包括商业用途。
-
-修改：根据需要改编代码。
-
-分发：免费或收费地分享原版或修改后的软件。
-
-唯一的条件是：不能从事非法及其它不正当行为,否则由您自行承担全部责任。
-
-免责声明
-作者对软件的质量不作任何保证。因使用本软件而产生的任何问题（如数据丢失、系统故障等），作者不承担任何责任。
+ISC 许可证 (ISC License)
+
+Copyright (c) 2026, flun <open@flun.top>
+衍生开发 本项目基于 Matthew Miller 作者的原代码进行开发、修改和扩展;
+
+特此免费授予任何获得本软件及相关文档文件("软件")副本的人,不受限制地处理本软件的权利,
+包括但不限于使用、复制、修改、合并、发布、分发、再许可和/或销售本软件副本的权利,
+并允许向其提供本软件的人这样做,但须满足以下条件:
+
+上述版权声明和本许可声明应包含在本软件的所有副本或重要部分中;
+
+本软件按"原样"提供,不作任何形式的明示或暗示的保证,
+包括但不限于适销性、特定用途的适用性和不侵权的保证;
+在任何情况下,作者或版权持有人均不对因本软件或本软件的使用或其它交易而产生的
+任何索赔、损害或其它责任负责,无论是合同之诉、侵权之诉还是其它行为之诉;
+
+---
+
+英文原文 (English Version)
+
+ISC License
+
+Copyright (c) 2026, flun <open@flun.top>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -3,7 +3,10 @@
 ![WebAuthn](https://img.shields.io/badge/WebAuthn-Browser_Simplified-blueviolet?style=for-the-badge&logo=WebAuthn)
 [![npm (scoped)](https://img.shields.io/npm/v/@flun/webauthn-browser?style=for-the-badge&logo=npm)](https://www.npmjs.com/package/@flun/webauthn-browser)
 
-**@flun/webauthn-browser** 是一个专为浏览器环境设计的 WebAuthn（含 Passkeys）前端工具库,基于 [@simplewebauthn/browser](https://simplewebauthn.dev/) 核心逻辑重构并增强,它封装了 `navigator.credentials` API 的复杂细节,提供简洁的 Promise 风格接口,并内置了丰富的错误处理与 Base64URL 编解码工具,并且新增在Windows下优先调用底层Windows hello 注册/认证(避免环境干扰与安全);
+**@flun/webauthn-browser** 是一个专为浏览器环境设计的 WebAuthn(含 Passkeys)前端工具库,
+基于 [@simplewebauthn/browser](https://simplewebauthn.dev/) 核心逻辑重构并增强,它封装了 `navigator.credentials` API 
+的复杂细节,提供简洁的 Promise 风格接口,并内置了丰富的错误处理与 Base64URL 编解码工具,
+并且新增在Windows下优先调用底层Windows hello 注册/认证(避免环境干扰与安全);
 
 本包以 **ESM** 编写,同时提供 **UMD** 打包产物,可通过 npm 模块方式或 `<script>` 全局方式引入,兼容现代浏览器及部分旧版环境;
 
@@ -15,7 +18,7 @@
 - [安装](#安装)
   - [NPM 模块方式](#npm-模块方式)
   - [UMD 全局方式](#umd-全局方式)
-    - [ES2021（推荐用于现代浏览器）](#es2021推荐用于现代浏览器)
+    - [ES2021(推荐用于现代浏览器)](#es2021推荐用于现代浏览器)
 - [主要功能](#主要功能)
 - [Windows下优先调用底层Windows hello 注册/认证(避免环境干扰);](#windows下优先调用底层windows-hello-注册认证避免环境干扰)
 - [快速开始](#快速开始)
@@ -45,7 +48,8 @@
 
 ### 允许安装脚本执行
 
-本包在安装时可能触发某些依赖包的自动脚本（如 `postinstall` 等）;如果你的 npm 全局配置或项目配置禁止了脚本执行（例如设置了 `ignore-scripts=true`）,可能会导致安装不完整或运行时异常;
+本包在安装时可能触发某些依赖包的自动脚本(如 `postinstall` 等);如果你的 npm 全局配置或项目配置禁止了脚本执行(例如设置了 
+`ignore-scripts=true`),可能会导致安装不完整或运行时异常;
 
 推荐在项目根目录的 `package.json` 中添加 `allowScripts` 字段,显式放行本包及其依赖的脚本:
 
@@ -53,12 +57,13 @@
 {
   "allowScripts": {
     "@flun/webauthn-browser": true
-    // 如果依赖的其它包（如 bcrypt、electron-winstaller 等）也有脚本,请按需添加,格式相同
+    // 如果依赖的其它包(如 bcrypt、electron-winstaller 等)也有脚本,请按需添加,格式相同
   }
 }
 ```
 
-> 如果你信任所有安装包,也可以直接在项目 `.npmrc` 中设置 `allow-scripts = false`（表示关闭脚本拦截,所有脚本均允许执行）,或删除`ignore-scripts` 字段;
+> 如果你信任所有安装包,也可以直接在项目 `.npmrc` 中设置 `allow-scripts = false`(表示关闭脚本拦截,所有脚本均允许执行),
+  或删除`ignore-scripts` 字段;
 
 ---
 
@@ -66,13 +71,13 @@
 
 ### NPM 模块方式
 
-适用于使用打包工具（Webpack、Vite、Rollup 等）或 Node.js ≥ 22.12.0 的环境;
+适用于使用打包工具(Webpack、Vite、Rollup 等)或 Node.js ≥ 22.12.0 的环境;
 
 ```sh
 npm i @flun/webauthn-browser
 ```
 
-然后在代码中按需导入：
+然后在代码中按需导入:
 
 ```js
 // ES Module
@@ -86,12 +91,12 @@ const { startRegistration, startAuthentication } = require('@flun/webauthn-brows
 
 本包通过 **unpkg** 提供 UMD 版本,引入后所有方法将挂载在全局对象 **`flunWebAuthnBrowser`** 上;
 
-#### ES2021（推荐用于现代浏览器）
+#### ES2021(推荐用于现代浏览器)
 
 ```html
 <script src="https://unpkg.com/@flun/webauthn-browser/dist/index.js"></script>
 ```
-*** 注意 ES5（不再支持）***
+*** 注意 ES5(不再支持)***
 
 ---
 ## 主要功能
@@ -102,8 +107,8 @@ const { startRegistration, startAuthentication } = require('@flun/webauthn-brows
 - ✅ **内置错误标准化**
   将浏览器原生错误转换为包含 `code` 和 `message` 的 `WebAuthnError` 对象,便于业务层处理;
 
-- ✅ **条件媒介支持（Conditional UI / 自动填充）**
-  支持 `useBrowserAutofill` 实现无感登录体验（需页面存在合适的 `<input>` 元素）;
+- ✅ **条件媒介支持(Conditional UI / 自动填充)**
+  支持 `useBrowserAutofill` 实现无感登录体验(需页面存在合适的 `<input>` 元素);
 
 - ✅ **完整的环境检测**
   提供 `browserSupportsWebAuthn()`、`platformAuthenticatorIsAvailable()` 等方法,精确判断设备能力;
@@ -194,7 +199,7 @@ async function login(username) {
       console.log('注册结果:', result);
     }
 
-    // ---------- 登录（认证）示例 ----------
+    // ---------- 登录(认证)示例 ----------
     async function handleLogin(username) {
       const optionsRes = await fetch('/api/login/begin', {
         method: 'POST',
@@ -219,8 +224,8 @@ async function login(username) {
       }
     }
 
-    // ---------- 带自动填充（Conditional UI）的登录示例 ----------
-    // 注意：使用自动填充时,页面必须包含类似如下的 input 元素：
+    // ---------- 带自动填充(Conditional UI)的登录示例 ----------
+    // 注意:使用自动填充时,页面必须包含类似如下的 input 元素:
     // <input type="text" name="username" autocomplete="username webauthn" />
     async function handleAutofillLogin() {
       if (!(await flunWebAuthnBrowser.browserSupportsWebAuthnAutofill())) {
@@ -285,11 +290,11 @@ async function login(username) {
 | 字段名            | 类型      | 默认值  | 描述                                                           |
 | ----------------- | --------- | ------- | -------------------------------------------------------------- |
 | `optionsJSON`     | `object`  | 必填    | 由服务端调用 `generateRegistrationOptions()` 生成的 JSON 对象  |
-| `useAutoRegister` | `boolean` | `false` | 是否启用条件媒介自动注册（实验性,需浏览器支持 Conditional UI） |
+| `useAutoRegister` | `boolean` | `false` | 是否启用条件媒介自动注册(实验性,需浏览器支持 Conditional UI) |
 
 **返回值** `Promise<RegistrationResponseJSON>`
 
-返回一个经过标准化处理的 JSON 对象,可直接发送给后端 `verifyRegistrationResponse()` 验证;响应格式如下：
+返回一个经过标准化处理的 JSON 对象,可直接发送给后端 `verifyRegistrationResponse()` 验证;响应格式如下:
 
 ```ts
 interface RegistrationResponseJSON {
@@ -318,15 +323,22 @@ const response = await startRegistration({ optionsJSON });
 
 #### startAuthentication(options)
 
-发起 WebAuthn 认证（登录）流程;
+发起 WebAuthn 认证(登录)流程;
 
 **参数**
 
-| 字段名                       | 类型      | 默认值  | 描述                                                                           |
-| ---------------------------- | --------- | ------- | ------------------------------------------------------------------------------ |
-| `optionsJSON`                | `object`  | 必填    | 由服务端调用 `generateAuthenticationOptions()` 生成的 JSON 对象                |
-| `useBrowserAutofill`         | `boolean` | `false` | 是否启用条件媒介（自动填充）,实现无感登录                                      |
-| `verifyBrowserAutofillInput` | `boolean` | `true`  | 启用自动填充时是否检查页面是否存在 `autocomplete="... webauthn"` 的 input 元素 |
+- `optionsJSON`
+  - 类型:`object`
+  - 默认值:必填
+  - 描述:由服务端调用 `generateAuthenticationOptions()` 生成的 JSON 对象
+- `useBrowserAutofill`
+  - 类型:`boolean`
+  - 默认值:`false`
+  - 描述:是否启用条件媒介(自动填充),实现无感登录
+- `verifyBrowserAutofillInput`
+  - 类型:`boolean`
+  - 默认值:`true`
+  - 描述:启用自动填充时是否检查页面是否存在 `autocomplete="... webauthn"` 的 input 元素
 
 **返回值** `Promise<AuthenticationResponseJSON>`
 
@@ -352,7 +364,7 @@ interface AuthenticationResponseJSON {
 // 普通登录
 const response = await startAuthentication({ optionsJSON });
 
-// 自动填充登录（需页面存在 <input autocomplete="webauthn">）
+// 自动填充登录(需页面存在 <input autocomplete="webauthn">)
 const response = await startAuthentication({
   optionsJSON,
   useBrowserAutofill: true
@@ -375,7 +387,7 @@ if (flunWebAuthnBrowser.browserSupportsWebAuthn()) {
 
 #### platformAuthenticatorIsAvailable()
 
-检查平台认证器（如 Touch ID、Face ID、Windows Hello）是否可用;
+检查平台认证器(如 Touch ID、Face ID、Windows Hello)是否可用;
 
 **返回值** `Promise<boolean>`
 
@@ -385,7 +397,7 @@ const available = await flunWebAuthnBrowser.platformAuthenticatorIsAvailable();
 
 #### browserSupportsWebAuthnAutofill()
 
-检查当前浏览器是否支持 WebAuthn 条件媒介（自动填充）;
+检查当前浏览器是否支持 WebAuthn 条件媒介(自动填充);
 
 **返回值** `Promise<boolean>`
 
@@ -422,19 +434,19 @@ const { bufferToBase64URLString, base64URLStringToBuffer } = flunWebAuthnBrowser
 
 | 属性    | 类型     | 描述                         |
 | ------- | -------- | ---------------------------- |
-| `name`  | `string` | 错误名称（通常为原始错误名） |
-| `code`  | `string` | 标准化的错误码（见下方表格） |
+| `name`  | `string` | 错误名称(通常为原始错误名) |
+| `code`  | `string` | 标准化的错误码(见下方表格) |
 | `cause` | `Error`  | 浏览器抛出的原始错误对象     |
 
 **常见错误码**
 
 | 错误码                                                        | 描述                                             |
 | ------------------------------------------------------------- | ------------------------------------------------ |
-| `ERROR_CEREMONY_ABORTED`                                      | 认证/注册流程被中止（如调用 `cancelCeremony()`） |
+| `ERROR_CEREMONY_ABORTED`                                      | 认证/注册流程被中止(如调用 `cancelCeremony()`) |
 | `ERROR_INVALID_DOMAIN`                                        | 当前域名无效                                     |
 | `ERROR_INVALID_RP_ID`                                         | RP ID 与当前域名不匹配                           |
 | `ERROR_AUTHENTICATOR_GENERAL_ERROR`                           | 认证器通用错误                                   |
-| `ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED`                   | 认证器已被注册（注册时）                         |
+| `ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED`                   | 认证器已被注册(注册时)                         |
 | `ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT` | 需要可发现凭证但认证器不支持                     |
 | `ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY`                        | 透传错误,需查看 `cause` 属性                     |
 
@@ -482,7 +494,7 @@ try {
         console.log('用户取消了操作');
         break;
       case 'ERROR_INVALID_RP_ID':
-        alert('配置错误：RP ID 无效');
+        alert('配置错误:RP ID 无效');
         break;
       default:
         console.error('认证失败', err.message);
@@ -499,7 +511,8 @@ try {
 
 ### 配合 @flun/webauthn-server
 
-以下是一个完整的最小化集成示例,前端使用本库,后端使用 [`@flun/webauthn-server`](https://www.npmjs.com/package/@flun/webauthn-server);
+以下是一个完整的最小化集成示例,前端使用本库,
+后端使用 [`@flun/webauthn-server`](https://www.npmjs.com/package/@flun/webauthn-server);
 
 **前端代码**
 
@@ -531,7 +544,7 @@ async function login(username) {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ username })
   }), options = await optionsRes.json(),
-   // 2. 启动浏览器认证流程（可开启自动填充）
+   // 2. 启动浏览器认证流程(可开启自动填充)
    response = await startAuthentication({ optionsJSON: options }),
    // 3. 发送响应验证
    verifyRes = await fetch('/api/login/complete', {
@@ -543,7 +556,7 @@ async function login(username) {
 }
 ```
 
-**后端代码片段**（基于 Express + `@flun/webauthn-server`）
+**后端代码片段**(基于 Express + `@flun/webauthn-server`)
 
 ```js
 import {

package/helpers/base64urlAndBuffer.js

@@ -10,7 +10,7 @@ const base64URLStringToBuffer = base64URLString => {
     // 从 Base64URL 转换为标准 Base64
     const base64 = base64URLString.replace(/-/g, '+').replace(/_/g, '/'),
         /**
-         * 用 '=' 填充，直到长度是 4 的倍数
+         * 用 '=' 填充,直到长度是 4 的倍数
          * (4 - (85 % 4 = 1) = 3) % 4 = 3 个填充
          * (4 - (86 % 4 = 2) = 2) % 4 = 2 个填充
          * (4 - (87 % 4 = 3) = 1) % 4 = 1 个填充
@@ -29,7 +29,7 @@ const base64URLStringToBuffer = base64URLString => {
  * 与 `base64URLStringToBuffer` 搭配使用
  * - 查看定义:@see {@link bufferToBase64URLString}
  * @param {BufferSource} buffer - 要转换的 ArrayBuffer 或 ArrayBufferView
- * @returns {string} Base64URL 编码的字符串（不含填充符）
+ * @returns {string} Base64URL 编码的字符串(不含填充符)
  */
 const bufferToBase64URLString = buffer => {
     const bytes = new Uint8Array(buffer);

package/helpers/common.js

@@ -11,10 +11,10 @@ const isWindows = (() => {
 
 /**
  * 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串
- * 支持多种 ID 表示形式（字符串、Uint8Array、Buffer 序列化对象等）
+ * 支持多种 ID 表示形式(字符串、Uint8Array、Buffer 序列化对象等)
  * > 查看定义:@see {@link extractBase64Id}
  * @param {Object} obj - 包含 `id` 属性的对象
- * @returns {string|undefined} base64url 编码的 ID 字符串，或 undefined
+ * @returns {string|undefined} base64url 编码的 ID 字符串,或 undefined
  */
 const extractBase64Id = obj => {
     if (!obj) return undefined;
@@ -33,8 +33,8 @@ const extractBase64Id = obj => {
  * - 若传入 { challenge, ... } 则包装为 { optionsJSON: input }
  * - 否则返回 null
  * > 查看定义:@see {@link normalizeOptions}
- * @param {Object} [input] - 用户传入的 options，应包含 optionsJSON 或 challenge 属性
- * @returns {Object|null} 规范化后的对象（至少包含 optionsJSON 属性）或 null
+ * @param {Object} [input] - 用户传入的 options,应包含 optionsJSON 或 challenge 属性
+ * @returns {Object|null} 规范化后的对象(至少包含 optionsJSON 属性)或 null
  */
 const normalizeOptions = input => {
     if (!input) return null;

package/helpers/identifyAuthenticationError.js

@@ -8,7 +8,7 @@ import { WebAuthnError } from './webAuthnError.js';
  * @param {Object} params - 参数对象
  * @param {Error|DOMException} params.error - 原始错误对象
  * @param {CredentialRequestOptions} params.options - navigator.credentials.get() 传入的选项
- * @returns {Error|WebAuthnError} 解析后的错误对象（WebAuthnError 或原始错误）
+ * @returns {Error|WebAuthnError} 解析后的错误对象(WebAuthnError 或原始错误)
  */
 const identifyAuthenticationError = ({ error, options }) => {
     const { publicKey } = options;
@@ -21,7 +21,7 @@ const identifyAuthenticationError = ({ error, options }) => {
     }
     else if (error.name === 'NotAllowedError')
         /**
-         * 直接传递错误，平台对该错误的定义超出了规范范围，我们不想覆盖可能更有用的错误消息；
+         * 直接传递错误,平台对该错误的定义超出了规范范围,我们不想覆盖可能更有用的错误消息;
          */
         return new WebAuthnError({ message: error.message, code: 'ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY', cause: error });
     else if (error.name === 'SecurityError') {
@@ -34,14 +34,15 @@ const identifyAuthenticationError = ({ error, options }) => {
         else if (publicKey.rpId !== effectiveDomain)
             // https://www.w3.org/TR/webauthn-2/#sctn-discover-from-external-source (第 6 步)
             return new WebAuthnError({
-                message: `信赖方 ID“${publicKey.rpId}”对此域名无效`, code: 'ERROR_INVALID_RP_ID', cause: error
+                message: `信赖方 ID"${publicKey.rpId}"对此域名无效`, code: 'ERROR_INVALID_RP_ID', cause: error
             });
     }
     else if (error.name === 'UnknownError')
         // https://www.w3.org/TR/webauthn-2/#sctn-op-get-assertion (第 1 步)
         // https://www.w3.org/TR/webauthn-2/#sctn-op-get-assertion (第 12 步)
         return new WebAuthnError({
-            message: '身份验证器无法处理指定的选项或创建新的断言签名', code: 'ERROR_AUTHENTICATOR_GENERAL_ERROR', cause: error
+            message: '身份验证器无法处理指定的选项或创建新的断言签名',
+            code: 'ERROR_AUTHENTICATOR_GENERAL_ERROR', cause: error
         });
 
     return error;

package/helpers/identifyRegistrationError.js

@@ -8,7 +8,7 @@ import { WebAuthnError } from './webAuthnError.js';
  * @param {Object} params - 参数对象
  * @param {Error} params.error - 原始错误对象
  * @param {CredentialCreationOptions} params.options - 传递给 `navigator.credentials.create()` 的选项
- * @returns {WebAuthnError|Error} 如果错误能被识别则返回包含更详细信息的 WebAuthnError，否则返回原始错误
+ * @returns {WebAuthnError|Error} 如果错误能被识别则返回包含更详细信息的 WebAuthnError,否则返回原始错误
  */
 const identifyRegistrationError = ({ error, options }) => {
     const { publicKey } = options;
@@ -25,20 +25,21 @@ const identifyRegistrationError = ({ error, options }) => {
         if (publicKey.authenticatorSelection?.requireResidentKey === true)
             // https://www.w3.org/TR/webauthn-2/#sctn-op-make-cred (第 4 步)
             return new WebAuthnError({
-                message: '需要可发现凭证，但没有可用的身份验证器支持该功能',
+                message: '需要可发现凭证,但没有可用的身份验证器支持该功能',
                 code: 'ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT', cause: error,
             });
-        // `mediation` 在 CredentialCreationOptions 中尚不存在，但截至 2024 年 9 月已有可能
+        // `mediation` 在 CredentialCreationOptions 中尚不存在,但截至 2024 年 9 月已有可能
         else if (options.mediation === 'conditional' && publicKey.authenticatorSelection?.userVerification === 'required')
             // https://w3c.github.io/webauthn/#sctn-createCredential (第 22.4 步)
             return new WebAuthnError({
-                message: '自动注册期间要求用户验证，但无法执行', code: 'ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE', cause: error
+                message: '自动注册期间要求用户验证,但无法执行',
+                code: 'ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE', cause: error
             });
 
         else if (publicKey.authenticatorSelection?.userVerification === 'required')
             // https://www.w3.org/TR/webauthn-2/#sctn-op-make-cred (第 5 步)
             return new WebAuthnError({
-                message: '需要用户验证，但没有可用的身份验证器支持该功能',
+                message: '需要用户验证,但没有可用的身份验证器支持该功能',
                 code: 'ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT', cause: error
             });
     }
@@ -50,7 +51,7 @@ const identifyRegistrationError = ({ error, options }) => {
         });
     else if (error.name === 'NotAllowedError')
         /**
-         * 直接传递错误；平台对该错误的定义超出了规范范围，保留原始错误消息；
+         * 直接传递错误;平台对该错误的定义超出了规范范围,保留原始错误消息;
          */
         return new WebAuthnError({ message: error.message, code: 'ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY', cause: error });
     else if (error.name === 'NotSupportedError') {
@@ -58,7 +59,8 @@ const identifyRegistrationError = ({ error, options }) => {
         if (validPubKeyCredParams.length === 0)
             // https://www.w3.org/TR/webauthn-2/#sctn-createCredential (第 10 步)
             return new WebAuthnError({
-                message: 'pubKeyCredParams 中没有类型为 "public-key" 的条目', code: 'ERROR_MALFORMED_PUBKEYCREDPARAMS', cause: error
+                message: 'pubKeyCredParams 中没有类型为 "public-key" 的条目',
+                code: 'ERROR_MALFORMED_PUBKEYCREDPARAMS', cause: error
             });
         // https://www.w3.org/TR/webauthn-2/#sctn-op-make-cred (第 2 步)
         return new WebAuthnError({
@@ -76,7 +78,7 @@ const identifyRegistrationError = ({ error, options }) => {
         else if (publicKey.rp.id !== effectiveDomain)
             // https://www.w3.org/TR/webauthn-2/#sctn-createCredential (第 8 步)
             return new WebAuthnError({
-                message: `信赖方 ID“${publicKey.rp.id}”对此域名无效`, code: 'ERROR_INVALID_RP_ID', cause: error
+                message: `信赖方 ID"${publicKey.rp.id}"对此域名无效`, code: 'ERROR_INVALID_RP_ID', cause: error
             });
     }
     else if (error.name === 'TypeError') {
@@ -90,7 +92,8 @@ const identifyRegistrationError = ({ error, options }) => {
         // https://www.w3.org/TR/webauthn-2/#sctn-op-make-cred (第 1 步)
         // https://www.w3.org/TR/webauthn-2/#sctn-op-make-cred (第 8 步)
         return new WebAuthnError({
-            message: '身份验证器无法处理指定的选项，或无法创建新的凭证', code: 'ERROR_AUTHENTICATOR_GENERAL_ERROR', cause: error
+            message: '身份验证器无法处理指定的选项,或无法创建新的凭证',
+            code: 'ERROR_AUTHENTICATOR_GENERAL_ERROR', cause: error
         });
 
     return error;

package/helpers/index.d.ts

@@ -1,6 +1,8 @@
 import { base64URLStringToBuffer, bufferToBase64URLString } from './base64urlAndBuffer.js';
 import { _browserSupportsWebAuthnInternals, browserSupportsWebAuthn } from './browserSupportsWebAuthn.js';
-import { _browserSupportsWebAuthnAutofillInternals, browserSupportsWebAuthnAutofill } from './browserSupportsWebAuthnAutofill.js';
+import {
+    _browserSupportsWebAuthnAutofillInternals, browserSupportsWebAuthnAutofill
+} from './browserSupportsWebAuthnAutofill.js';
 import { isWindows, extractBase64Id, normalizeOptions } from './common.js';
 import { identifyAuthenticationError } from './identifyAuthenticationError.js';
 import { identifyRegistrationError } from './identifyRegistrationError.js';
@@ -28,7 +30,7 @@ declare module './base64urlAndBuffer.js' {
 /**
  * ```js
  * // 文件导出内容
- * const _browserSupportsWebAuthnInternals={}; // 测试期间对返回值进行桩（stub）处理
+ * const _browserSupportsWebAuthnInternals={}; // 测试期间对返回值进行桩(stub)处理
  * browserSupportsWebAuthn();                  // 判断当前浏览器是否支持 WebAuthn
  * ```
  * >查看定义:@see {@link _browserSupportsWebAuthnInternals}、{@link browserSupportsWebAuthn}
@@ -140,7 +142,8 @@ declare module './toPublicKeyCredentialDescriptor.js' {
 /**
  * ```js
  * // 文件导出内容
- * const WebAuthnAbortService = new BaseWebAuthnAbortService(); // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
+ * const WebAuthnAbortService = new BaseWebAuthnAbortService();
+ * // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
  * ```
  * >查看定义:@see {@link WebAuthnAbortService}
  */
@@ -169,16 +172,17 @@ declare module './webAuthnError.js' {
 
 // ================================ 导出入口 ================================
 /**
- * 模块导出内容：
+ * 模块导出内容:
  * ```js
  * // 类型
  * type WebAuthnErrorCode;
  *
  * // 常量
- * const _browserSupportsWebAuthnInternals={};         // 测试期间对返回值进行桩（stub）处理
+ * const _browserSupportsWebAuthnInternals={};         // 测试期间对返回值进行桩(stub)处理
  * const _browserSupportsWebAuthnAutofillInternals={}; // 测试期间模拟返回值;
  * const isWindows=();                                 // 当前操作系统是否为 Windows
- * const WebAuthnAbortService = new BaseWebAuthnAbortService(); // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
+ * const WebAuthnAbortService = new BaseWebAuthnAbortService();
+ * // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
  *
  * // 函数
  * base64URLStringToBuffer();                          // 将 Base64URL 编码的字符串转换为 Array Buffer;
@@ -186,14 +190,16 @@ declare module './webAuthnError.js' {
  * browserSupportsWebAuthn();                          // 判断当前浏览器是否支持 WebAuthn
  * browserSupportsWebAuthnAutofill();                  // 判断浏览器是否支持条件式UI;
  * isWindows();                                        // 检测当前操作系统是否为 Windows
- * extractBase64Id();                                  // 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串 支持多种 ID 表示形式
+ * extractBase64Id();
+ * // 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串 支持多种 ID 表示形式
  * normalizeOptions();                                 // 规范化传入的 options 对象,兼容旧调用方式
  * identifyAuthenticationError();                      // 尝试推断调用 `navigator.credentials.get()` 后引发错误的原因;
  * identifyRegistrationError();                        // 尝试推断调用 `navigator.credentials.create()` 后引发错误的原因;
  * isValidDomain();                                    // 判断主机名是否符合验证规范;
  * platformAuthenticatorIsAvailable();                 // 判断浏览器是否能够与内置身份验证器通信;
  * toAuthenticatorAttachment();                        // 尝试将 `string` 值强制转换为已知的 `AuthenticatorAttachment` 类型
- * toPublicKeyCredentialDescriptor();                  // 将描述符中的Base64URL字符串`id`转换为ArrayBuffer,以适配 WebAuthn API;
+ * toPublicKeyCredentialDescriptor();
+ * // 将描述符中的Base64URL字符串`id`转换为ArrayBuffer,以适配 WebAuthn API;
  *
  * // 类
  * class WebAuthnError{};                              // 自定义错误,用于更细致地说明规范中八种错误被抛出的原因;

package/helpers/isValidDomain.js

@@ -1,18 +1,19 @@
 /**
  * 一个简单的测试,用于判断主机名是否为格式正确的域名
  * - 查看定义:@see {@link isValidDomain}
- * - “有效域名”的定义参见：https://url.spec.whatwg.org/#valid-domain
+ * - "有效域名"的定义参见:https://url.spec.whatwg.org/#valid-domain
  *
- * - 正则表达式最初来源于此处,后经改编以增加 punycode 支持：
+ * - 正则表达式最初来源于此处,后经改编以增加 punycode 支持:
  * https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch08s15.html
  *
  * @param {string} hostname - 待验证的主机名
- * @returns {boolean} 如果主机名是 localhost 或符合有效域名格式则返回 true，否则 false
+ * @returns {boolean} 如果主机名是 localhost 或符合有效域名格式则返回 true,否则 false
  */
 const isValidDomain = hostname => {
+    const domainRe = /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i;
     return (
         // 将 localhost 视为有效,因为它在安全上下文方面是没问题的,支持 punycode (ACE) 或 ASCII 标签和域名
-        hostname === 'localhost' || /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(hostname));
+        hostname === 'localhost' || domainRe.test(hostname));
 }
 
 export { isValidDomain };

package/helpers/platformAuthenticatorIsAvailable.js

@@ -1,7 +1,7 @@
 import { browserSupportsWebAuthn } from './browserSupportsWebAuthn.js';
 
 /**
- * 判断浏览器是否能够与内置身份验证器（如 Touch ID、Android 指纹扫描器或 Windows Hello）通信;
+ * 判断浏览器是否能够与内置身份验证器(如 Touch ID、Android 指纹扫描器或 Windows Hello)通信;
  * 该方法无法告知平台身份验证器的具体名称;
  * - 查看定义:@see {@link platformAuthenticatorIsAvailable}
  * @returns {Promise<boolean>} 如果平台身份验证器可用,则解析为 true,否则为 false;

package/helpers/toPublicKeyCredentialDescriptor.js

@@ -4,8 +4,8 @@ import { base64URLStringToBuffer } from './base64urlAndBuffer.js';
  * 将描述符中的 Base64URL 字符串 `id` 转换为 ArrayBuffer,以适配 WebAuthn API;
  * - 查看定义:@see {@link toPublicKeyCredentialDescriptor}
  * @param {Object} descriptor - 包含 `id` (Base64URL 字符串) 的凭证描述符;
- * @param {string} descriptor.id - 凭证 ID（Base64URL 编码）
- * @param {string[]} [descriptor.transports] - 可选的传输方式列表（如 ['usb', 'nfc']）
+ * @param {string} descriptor.id - 凭证 ID(Base64URL 编码)
+ * @param {string[]} [descriptor.transports] - 可选的传输方式列表(如 ['usb', 'nfc'])
  * @returns {PublicKeyCredentialDescriptor} 转换后的描述符,可直接用于 WebAuthn;
  */
 const toPublicKeyCredentialDescriptor = descriptor => {

package/helpers/webAuthnError.js

@@ -1,6 +1,6 @@
 /**
  * 自定义错误,用于在调用 `navigator.credentials.create()` 或 `navigator.credentials.get()` 后,
- * 更细致地说明规范中描述的八种错误之一被抛出的原因：
+ * 更细致地说明规范中描述的八种错误之一被抛出的原因:
  *
  * - `AbortError`
  * - `ConstraintError`
@@ -18,7 +18,7 @@ class WebAuthnError extends Error {
     /**
      * @param {Object} params - 错误配置参数
      * @param {string} params.message - 错误消息
-     * @param {string} params.code - 错误码（规范中定义的错误名称之一）
+     * @param {string} params.code - 错误码(规范中定义的错误名称之一)
      * @param {Error} [params.cause] - 导致此错误的原始错误对象
      * @param {string} [params.name] - 自定义错误名称,默认使用 cause 的 name
      */

package/index.d.ts

@@ -6,16 +6,17 @@ import {
 import { startAuthentication, startRegistration } from './methods/index.js';
 
 /**
- * 模块导出内容：
+ * 模块导出内容:
  * ```js
  * // 登录和注册处理函数
- * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器“登录”
- * startRegistration();   // 通过 WebAuthn 证明开始认证器“注册”
+ * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器"登录"
+ * startRegistration();   // 通过 WebAuthn 证明开始认证器"注册"
  *
  * // 工具
- * const _browserSupportsWebAuthnInternals={};         // 测试期间对返回值进行桩（stub）处理
+ * const _browserSupportsWebAuthnInternals={};         // 测试期间对返回值进行桩(stub)处理
  * const _browserSupportsWebAuthnAutofillInternals={}; // 测试期间模拟返回值;
- * const WebAuthnAbortService = new BaseWebAuthnAbortService(); // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
+ * const WebAuthnAbortService = new BaseWebAuthnAbortService();
+ * // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
  *
  * base64URLStringToBuffer();                          // 将 Base64URL 编码的字符串转换为 Array Buffer;
  * bufferToBase64URLString();                          // 将给定的数组缓冲区转换为 Base64URL 编码的字符串;
@@ -27,7 +28,8 @@ import { startAuthentication, startRegistration } from './methods/index.js';
  * ```
  * >查看定义:@see
  *- 登录和注册处理: {@link startAuthentication}、{@link startRegistration}
- *- 工具: {@link _browserSupportsWebAuthnInternals}、{@link _browserSupportsWebAuthnAutofillInternals}、{@link WebAuthnAbortService}、
+ *- 工具: {@link _browserSupportsWebAuthnInternals}、{@link _browserSupportsWebAuthnAutofillInternals}、
+ * {@link WebAuthnAbortService}、
  * {@link base64URLStringToBuffer}、{@link bufferToBase64URLString}、 {@link browserSupportsWebAuthn}、
  * {@link browserSupportsWebAuthnAutofill}、{@link platformAuthenticatorIsAvailable}
  * >{@link WebAuthnError}

package/methods/index.d.ts

@@ -5,7 +5,7 @@ import { startRegistration } from './startRegistration.js';
 /**
  * ```js
  * // 文件导出内容
- * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器“登录”
+ * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器"登录"
  * ```
  * >查看定义:@see {@link startAuthentication}
  */
@@ -17,7 +17,7 @@ declare module './startAuthentication.js' {
 /**
  * ```js
  * // 文件导出内容
- * startRegistration(); // 通过 WebAuthn 证明开始认证器“注册”
+ * startRegistration(); // 通过 WebAuthn 证明开始认证器"注册"
  * ```
  * >查看定义:@see {@link startRegistration}
  */
@@ -27,10 +27,10 @@ declare module './startRegistration.js' {
 
 // ================================ 导出入口 ================================
 /**
- * 模块导出内容：
+ * 模块导出内容:
  * ```js
- * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器“登录”
- * startRegistration();   // 通过 WebAuthn 证明开始认证器“注册”
+ * startAuthentication(); // 通过 WebAuthn 断言开始身份验证器"登录"
+ * startRegistration();   // 通过 WebAuthn 证明开始认证器"注册"
  * ```
  * >查看定义:@see {@link startAuthentication}、{@link startRegistration}
  */

package/methods/startAuthentication.js

@@ -5,13 +5,15 @@ import {
 } from '../helpers/index.js';
 
 /**
- * 通过 WebAuthn 断言开始身份验证器“登录”
+ * 通过 WebAuthn 断言开始身份验证器"登录"
  * > 查看定义:@see {@link startAuthentication}
  * @param {Object} options - 配置选项
  * @param {Object} options.optionsJSON - 来自 **@flun/webauthn-server** 的 `generateAuthenticationOptions()` 的输出
  * @param {boolean} [options.useBrowserAutofill=false] - 初始化条件式 UI,以支持通过浏览器自动填充提示进行登录
- * @param {boolean} [options.verifyBrowserAutofillInput=true] - 当 `useBrowserAutofill` 为 `true` 时,确保存在合适的 `<input>` 元素
- * @param {string} [options.accountId] - （可选）手动指定账号 ID,用于 Windows 原生认证时作为凭证标识,若未提供则从 `optionsJSON.allowCredentials` 中提取
+ * @param {boolean} [options.verifyBrowserAutofillInput=true] - 当 `useBrowserAutofill` 为 `true` 时,
+ *   确保存在合适的 `<input>` 元素
+ * @param {string} [options.accountId] - (可选)手动指定账号 ID,用于 Windows 原生认证时作为凭证标识,
+ *   若未提供则从 `optionsJSON.allowCredentials` 中提取
  * @returns {Promise<{
  *   id: string,
  *   rawId: string,
@@ -61,7 +63,7 @@ const startAuthentication = async (options) => {
 
         const eligibleInputs = document.querySelectorAll("input[autocomplete$='webauthn']");
         if (eligibleInputs.length < 1 && verifyBrowserAutofillInput)
-            throw Error('未检测到任何 `autocomplete` 属性中包含 "webauthn"（作为唯一值或最后一个值）的 <input> 元素');
+            throw Error('未检测到任何 `autocomplete` 属性中包含 "webauthn"(作为唯一值或最后一个值)的 <input> 元素');
 
         getOptions.mediation = 'conditional', publicKey.allowCredentials = [];
     }

package/methods/startRegistration.js

@@ -1,5 +1,6 @@
 import {
-    bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, isWindows, extractBase64Id, normalizeOptions,
+    bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, isWindows, extractBase64Id,
+    normalizeOptions,
     identifyRegistrationError, toAuthenticatorAttachment, toPublicKeyCredentialDescriptor, WebAuthnAbortService
 } from '../helpers/index.js';
 
@@ -15,7 +16,7 @@ const warnOnBrokenImplementation = (methodName, cause) => {
 };
 
 /**
- * 通过 WebAuthn 证明开始认证器“注册”
+ * 通过 WebAuthn 证明开始认证器"注册"
  * - 查看定义:@see {@link startRegistration}
  *
  * @param {Object} options - 配置选项
@@ -74,9 +75,9 @@ const startRegistration = async (options) => {
     }, createOptions = {};
 
     /**
-     * 尝试使用条件创建（conditional create）为用户注册一个通行密钥,
+     * 尝试使用条件创建(conditional create)为用户注册一个通行密钥,
      * 使用用户刚刚用于认证的密码管理器;浏览器不会向用户显示任何突出的 UI;
-     * 注意：`mediation` 在 CredentialCreationOptions 中尚不存在,但自 2024 年 9 月起已可用
+     * 注意:`mediation` 在 CredentialCreationOptions 中尚不存在,但自 2024 年 9 月起已可用
      */
     if (useAutoRegister) createOptions.mediation = 'conditional';
     createOptions.publicKey = publicKey, createOptions.signal = WebAuthnAbortService.createNewAbortSignal();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flun/webauthn-browser",
-  "version": "2.1.9",
+  "version": "2.1.10",
   "description": "WebAuthn 前端库,提供简单易用的接口来处理 WebAuthn 认证流程,支持 Passkeys 和 FIDO2 标准;",
   "keywords": [
     "typescript",
@@ -36,7 +36,7 @@
     "type": "git",
     "url": "git+https://github.com/OpenFlun/webauthn-browser.git"
   },
-  "homepage": "https://www.npmjs.com/package/@flun/webauthn-browser#readme",
+  "homepage": "https://github.com/OpenFlun/webauthn-browser#readme",
   "bugs": {
     "url": "https://github.com/OpenFlun/webauthn-browser/issues"
   },
@@ -47,6 +47,6 @@
     "npm": ">=10.0.0"
   },
   "devDependencies": {
-    "@types/node": "^26.6.3"
+    "@types/node": "^26.6.5"
   }
 }

package/types/dom.d.ts

@@ -1,15 +1,15 @@
 /**
- * 请勿修改这些文件！
+ * 请勿修改这些文件!
  *
- * 这些文件是从 **types** 包复制而来的;要更新此文件,请修改相应包中的文件，
- * 然后从 monorepo 根目录运行命令： deno task codegen:types
+ * 这些文件是从 **types** 包复制而来的;要更新此文件,请修改相应包中的文件,
+ * 然后从 monorepo 根目录运行命令: deno task codegen:types
  */
 /**
  * 由 typescript@5.6.3 生成
- * 要重新生成,请从包根目录运行命令： deno task extract-dom-types
+ * 要重新生成,请从包根目录运行命令: deno task extract-dom-types
  */
 /**
- * 仅在安全上下文（secure contexts）中可用。
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAssertionResponse)
  */
@@ -22,7 +22,7 @@ export interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
     readonly userHandle: ArrayBuffer | null;
 }
 /**
- * 仅在安全上下文（secure contexts）中可用。
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse)
  */
@@ -50,13 +50,13 @@ export interface AuthenticatorSelectionCriteria {
     userVerification?: UserVerificationRequirement;
 }
 /**
- * 当前上下文中可用的基本加密功能。它允许访问密码学强随机数生成器和加密原语。
+ * 当前上下文中可用的基本加密功能;它允许访问密码学强随机数生成器和加密原语;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto)
  */
 export interface Crypto {
     /**
-     * 仅在安全上下文（secure contexts）中可用。
+     * 仅在安全上下文(secure contexts)中可用;
      *
      * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/subtle)
      */
@@ -64,14 +64,14 @@ export interface Crypto {
     /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
     getRandomValues<T extends ArrayBufferView | null>(array: T): T;
     /**
-     * 仅在安全上下文（secure contexts）中可用。
+     * 仅在安全上下文(secure contexts)中可用;
      *
      * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
      */
     randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
 }
 /**
- * 仅在安全上下文（secure contexts）中可用。
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential)
  */
@@ -111,7 +111,7 @@ export interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity
     displayName: string, id: BufferSource;
 }
 /**
- * 仅在安全上下文（secure contexts）中可用。
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorResponse)
  */
@@ -123,8 +123,8 @@ export interface CredentialPropertiesOutput {
     rk?: boolean;
 }
 /**
- * 此 Web Crypto API 接口提供了一系列低级加密函数;可通过窗口上下文中的 Crypto.subtle 属性访问（通过 Window.crypto）;
- * 仅在安全上下文（secure contexts）中可用。
+ * 此 Web Crypto API 接口提供了一系列低级加密函数;可通过窗口上下文中的 Crypto.subtle 属性访问(通过 Window.crypto);
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto)
  */
@@ -180,7 +180,7 @@ export interface SubtleCrypto {
         RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
 }
 /**
- * 仅在安全上下文（secure contexts）中可用。
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Credential)
  */
@@ -209,8 +209,8 @@ export interface AesGcmParams extends Algorithm {
     additionalData?: BufferSource, iv: BufferSource, tagLength?: number;
 }
 /**
- * Web Crypto API 的 CryptoKey 字典表示一个加密密钥。
- * 仅在安全上下文（secure contexts）中可用。
+ * Web Crypto API 的 CryptoKey 字典表示一个加密密钥;
+ * 仅在安全上下文(secure contexts)中可用;
  *
  * [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey)
  */

package/types/index.d.ts

@@ -1,29 +1,32 @@
 /**
- * 请勿修改这些文件！
+ * 请勿修改这些文件!
  *
- * 这些文件是从 **types** 包复制而来的;要更新此文件,请修改相应包中的文件，
- * 然后从 monorepo 根目录运行命令： deno task codegen:types
+ * 这些文件是从 **types** 包复制而来的;要更新此文件,请修改相应包中的文件,
+ * 然后从 monorepo 根目录运行命令: deno task codegen:types
  */
 import type {
     AttestationConveyancePreference, AuthenticationExtensionsClientInputs, AuthenticationExtensionsClientOutputs,
-    AuthenticatorAssertionResponse, AuthenticatorAttachment, AuthenticatorAttestationResponse, AuthenticatorSelectionCriteria,
+    AuthenticatorAssertionResponse, AuthenticatorAttachment, AuthenticatorAttestationResponse,
+    AuthenticatorSelectionCriteria,
     COSEAlgorithmIdentifier, PublicKeyCredential, PublicKeyCredentialCreationOptions, PublicKeyCredentialDescriptor,
     PublicKeyCredentialParameters, PublicKeyCredentialRequestOptions, PublicKeyCredentialRpEntity, PublicKeyCredentialType,
     UserVerificationRequirement
 } from './dom.js';
 export type {
     AttestationConveyancePreference, AuthenticationExtensionsClientInputs, AuthenticationExtensionsClientOutputs,
-    AuthenticatorAssertionResponse, AuthenticatorAttachment, AuthenticatorAttestationResponse, AuthenticatorSelectionCriteria,
+    AuthenticatorAssertionResponse, AuthenticatorAttachment, AuthenticatorAttestationResponse,
+    AuthenticatorSelectionCriteria,
     AuthenticatorTransport, COSEAlgorithmIdentifier, Crypto, PublicKeyCredential, PublicKeyCredentialCreationOptions,
-    PublicKeyCredentialDescriptor, PublicKeyCredentialParameters, PublicKeyCredentialRequestOptions, PublicKeyCredentialRpEntity,
+    PublicKeyCredentialDescriptor, PublicKeyCredentialParameters, PublicKeyCredentialRequestOptions,
+    PublicKeyCredentialRpEntity,
     PublicKeyCredentialType, PublicKeyCredentialUserEntity, ResidentKeyRequirement, UserVerificationRequirement,
 } from './dom.js';
 
 /**
- * 适用于 JSON 传输到浏览器的 PublicKeyCredentialCreationOptions 变体，
- * （最终）将传递给浏览器中的 navigator.credentials.create(...);
+ * 适用于 JSON 传输到浏览器的 PublicKeyCredentialCreationOptions 变体,
+ * (最终)将传递给浏览器中的 navigator.credentials.create(...);
  *
- * 当 WebAuthn L3 类型最终进入语言标准时,应被官方的 TypeScript DOM 类型取代：
+ * 当 WebAuthn L3 类型最终进入语言标准时,应被官方的 TypeScript DOM 类型取代:
  *
  * https://w3c.github.io/webauthn/#dictdef-publickeycredentialcreationoptionsjson
  */
@@ -42,8 +45,8 @@ export interface PublicKeyCredentialCreationOptionsJSON {
 }
 
 /**
- * 适用于 JSON 传输到浏览器的 PublicKeyCredentialRequestOptions 变体，
- * （最终）将传递给浏览器中的 navigator.credentials.get(...)。
+ * 适用于 JSON 传输到浏览器的 PublicKeyCredentialRequestOptions 变体,
+ * (最终)将传递给浏览器中的 navigator.credentials.get(...);
  */
 export interface PublicKeyCredentialRequestOptionsJSON {
     challenge: Base64URLString;
@@ -78,7 +81,7 @@ export interface RegistrationCredential extends PublicKeyCredentialFuture {
 }
 
 /**
- * 略微修改的 RegistrationCredential,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer，
+ * 略微修改的 RegistrationCredential,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer,
  * 以便它们可以作为 JSON 发送到服务器;
  *
  * https://w3c.github.io/webauthn/#dictdef-registrationresponsejson
@@ -100,8 +103,8 @@ export interface AuthenticationCredential extends PublicKeyCredentialFuture {
 }
 
 /**
- * 略微修改的 AuthenticationCredential,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer，
- * 以便它们可以作为 JSON 发送到服务器。
+ * 略微修改的 AuthenticationCredential,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer,
+ * 以便它们可以作为 JSON 发送到服务器;
  *
  * https://w3c.github.io/webauthn/#dictdef-authenticationresponsejson
  */
@@ -115,8 +118,8 @@ export interface AuthenticationResponseJSON {
 }
 
 /**
- * 略微修改的 AuthenticatorAttestationResponse,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer，
- * 以便它们可以作为 JSON 发送到服务器。
+ * 略微修改的 AuthenticatorAttestationResponse,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer,
+ * 以便它们可以作为 JSON 发送到服务器;
  *
  * https://w3c.github.io/webauthn/#dictdef-authenticatorattestationresponsejson
  */
@@ -130,8 +133,8 @@ export interface AuthenticatorAttestationResponseJSON {
 }
 
 /**
- * 略微修改的 AuthenticatorAssertionResponse,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer，
- * 以便它们可以作为 JSON 发送到服务器。
+ * 略微修改的 AuthenticatorAssertionResponse,用于简化处理浏览器中经过 Base64URL 编码的 ArrayBuffer,
+ * 以便它们可以作为 JSON 发送到服务器;
  *
  * https://w3c.github.io/webauthn/#dictdef-authenticatorassertionresponsejson
  */
@@ -156,7 +159,7 @@ export type WebAuthnCredential = {
 export type Base64URLString = string;
 
 /**
- * TypeScript DOM 库中的 AuthenticatorAttestationResponse 已过时（最高到 v3.9.7）。
+ * TypeScript DOM 库中的 AuthenticatorAttestationResponse 已过时(最高到 v3.9.7);
  * 此处维护一个增强版本,以便随着 WebAuthn 规范的演进实现额外的属性;
  *
  * 参见 https://www.w3.org/TR/webauthn-2/#iface-authenticatorattestationresponse
@@ -169,13 +172,13 @@ export interface AuthenticatorAttestationResponseFuture extends AuthenticatorAtt
 
 /**
  * TypeScript 的 `AuthenticatorTransport` 的超集,包含对最新传输方式的支持;
- * 当 TypeScript 更新到知晓这些传输方式后（大约在 4.6.3 之后）,应最终被 TypeScript 的类型取代;
+ * 当 TypeScript 更新到知晓这些传输方式后(大约在 4.6.3 之后),应最终被 TypeScript 的类型取代;
  */
 export type AuthenticatorTransportFuture = 'ble' | 'cable' | 'hybrid' | 'internal' | 'nfc' | 'smart-card' | 'usb';
 
 /**
  * TypeScript 的 `PublicKeyCredentialDescriptor` 的超集,知晓最新的传输方式;
- * 当 TypeScript 更新到知晓这些传输方式后（大约在 4.6.3 之后）,应最终被 TypeScript 的类型取代;
+ * 当 TypeScript 更新到知晓这些传输方式后(大约在 4.6.3 之后),应最终被 TypeScript 的类型取代;
  */
 export interface PublicKeyCredentialDescriptorFuture extends Omit<PublicKeyCredentialDescriptor, 'transports'> {
     transports?: AuthenticatorTransportFuture[];
@@ -196,15 +199,15 @@ export interface PublicKeyCredentialFuture extends PublicKeyCredential {
 }
 
 /**
- * 由认证器数据中的第 3 位（“备份资格”）定义的两种凭证类型：
+ * 由认证器数据中的第 3 位("备份资格")定义的两种凭证类型:
  * - `"singleDevice"` 凭证永远不会被备份
  * - `"multiDevice"` 凭证可以被备份
  */
 export type CredentialDeviceType = 'singleDevice' | 'multiDevice';
 
 /**
- * 依赖方可以在注册时传递给浏览器的认证器类别,能够理解这些值的浏览器可以优化其模态体验，
- * 将用户引导至特定的注册流程：
+ * 依赖方可以在注册时传递给浏览器的认证器类别,能够理解这些值的浏览器可以优化其模态体验,
+ * 将用户引导至特定的注册流程:
  *
  * - `hybrid`: 移动设备上的平台认证器
  * - `security-key`: 可通过 USB 或 NFC 连接在多个设备上使用的便携式 FIDO2 认证器
@@ -228,10 +231,11 @@ export type AttestationFormat = 'fido-u2f' | 'packed' | 'android-safetynet' | 'a
  *
  * **背景**
  *
- * `Uint8Array` 在TypeScript 5.7中成为泛型类型,要求从Deno 2.2开始将简单定义为 `Uint8Array` 的类型重构为 `Uint8Array<ArrayBuffer>`;
- * 然而，在 Deno 2.1.x 及更早版本中 `Uint8Array` 不是泛型，因此此类型有助于弥合这一差距。
+ * `Uint8Array` 在TypeScript 5.7中成为泛型类型,要求从Deno 2.2开始将简单定义为 `Uint8Array` 的类型
+ * 重构为 `Uint8Array<ArrayBuffer>`;
+ * 然而,在 Deno 2.1.x 及更早版本中 `Uint8Array` 不是泛型,因此此类型有助于弥合这一差距;
  *
- * 灵感来自 Deno 的标准库：
+ * 灵感来自 Deno 的标准库:
  *
  * https://github.com/denoland/std/blob/b5a5fe4f96b91c1fe8dba5cc0270092dd11d3287/bytes/_types.ts#L11
  */