@flun/webauthn-browser 2.0.18 → 2.1.0

package/CHANGELOG.md

@@ -1,7 +1,12 @@
 # 变更日志
+## [2.1.0] - 2026-07-18 22:22
+### 优化
+- 验证顺序改变:在Windows下优先调用底层Windows hello 注册/认证,然后才是标准模式;
+- 不再支持 ES5 ;
+
+## [2.0.19] - 2026-07-15 19:25
+### 更新
+- 依赖包(@types/node)更新;
 ## [2.0.18] - 2026-07-06 16:17
 ### 优化
-- 说明文件中 `allowScripts` 配置示例细节优化;
-## [2.0.16] - 2026-07-06 15:49
-### 新增
-- 在 README 中新增“配置”章节，指导用户通过 `allowScripts` 显式放行本包的安装脚本，避免因 `ignore-scripts` 全局配置导致钩子被跳过。
+- 说明文件中 `allowScripts` 配置示例细节优化;

package/README.md

@@ -3,7 +3,7 @@
 ![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 编解码工具;
+**@flun/webauthn-browser** 是一个专为浏览器环境设计的 WebAuthn（含 Passkeys）前端工具库,基于 [@simplewebauthn/browser](https://simplewebauthn.dev/) 核心逻辑重构并增强,它封装了 `navigator.credentials` API 的复杂细节,提供简洁的 Promise 风格接口,并内置了丰富的错误处理与 Base64URL 编解码工具,并且新增在Windows下优先调用底层Windows hello 注册/认证(避免环境干扰与安全);
 
 本包以 **ESM** 编写,同时提供 **UMD** 打包产物,可通过 npm 模块方式或 `<script>` 全局方式引入,兼容现代浏览器及部分旧版环境;
 
@@ -16,8 +16,8 @@
   - [NPM 模块方式](#npm-模块方式)
   - [UMD 全局方式](#umd-全局方式)
     - [ES2021（推荐用于现代浏览器）](#es2021推荐用于现代浏览器)
-    - [ES5（包含 polyfill，支持 IE11 / 旧版 Edge）](#es5包含-polyfill支持-ie11--旧版-edge)
 - [主要功能](#主要功能)
+- [Windows下优先调用底层Windows hello 注册/认证(避免环境干扰);](#windows下优先调用底层windows-hello-注册认证避免环境干扰)
 - [快速开始](#快速开始)
   - [模块方式使用示例](#模块方式使用示例)
   - [全局方式使用示例](#全局方式使用示例)
@@ -86,22 +86,14 @@ const { startRegistration, startAuthentication } = require('@flun/webauthn-brows
 
 本包通过 **unpkg** 提供 UMD 版本,引入后所有方法将挂载在全局对象 **`flunWebAuthnBrowser`** 上;
 
-> 注意：ES5 版本包含针对旧版浏览器的 polyfill,会增加体积,但允许在旧环境中使用 `browserSupportsWebAuthn()` 进行特性检测;
-
 #### ES2021（推荐用于现代浏览器）
 
 ```html
 <script src="https://unpkg.com/@flun/webauthn-browser/dist/index.js"></script>
 ```
-
-#### ES5（包含 polyfill，支持 IE11 / 旧版 Edge）
-
-```html
-<script src="https://unpkg.com/@flun/webauthn-browser/dist/index.es5.js"></script>
-```
+*** 注意 ES5（不再支持）***
 
 ---
-
 ## 主要功能
 
 - ✅ **简化的 WebAuthn 调用**
@@ -122,6 +114,8 @@ const { startRegistration, startAuthentication } = require('@flun/webauthn-brows
 - ✅ **可中止的认证流程**
   通过 `WebAuthnAbortService` 在必要时取消进行中的认证/注册操作;
 
+- ✅ **Windows hello 底层调用**
+   Windows下优先调用底层Windows hello 注册/认证(避免环境干扰与安全);
 ---
 
 ## 快速开始
@@ -170,7 +164,7 @@ async function login(username) {
 
 ### 全局方式使用示例
 
-在 HTML 页面中引入 UMD 脚本后，即可通过全局变量 `flunWebAuthnBrowser` 调用所有方法。
+在 HTML 页面中引入 UMD 脚本后,即可通过全局变量 `flunWebAuthnBrowser` 调用所有方法;
 
 ```html
 <script src="https://unpkg.com/@flun/webauthn-browser/dist/index.js"></script>
@@ -178,7 +172,7 @@ async function login(username) {
   (async () => {
     // 1. 首先检测浏览器是否支持 WebAuthn
     if (!flunWebAuthnBrowser.browserSupportsWebAuthn()) {
-      return alert('您的浏览器不支持 WebAuthn 或 Passkey，请升级或使用其他方式登录。');
+      return alert('您的浏览器不支持 WebAuthn 或 Passkey,请升级或使用其他方式登录;');
     }
 
     // ---------- 注册示例 ----------
@@ -221,12 +215,12 @@ async function login(username) {
         console.log('登录成功');
         window.location.href = '/dashboard';
       } else {
-        alert('登录失败，请重试');
+        alert('登录失败,请重试');
       }
     }
 
     // ---------- 带自动填充（Conditional UI）的登录示例 ----------
-    // 注意：使用自动填充时，页面必须包含类似如下的 input 元素：
+    // 注意：使用自动填充时,页面必须包含类似如下的 input 元素：
     // <input type="text" name="username" autocomplete="username webauthn" />
     async function handleAutofillLogin() {
       if (!(await flunWebAuthnBrowser.browserSupportsWebAuthnAutofill())) {
@@ -286,18 +280,16 @@ async function login(username) {
 
 #### startRegistration(options)
 
-发起 WebAuthn 注册流程，创建新凭证。
-
+发起 WebAuthn 注册流程,创建新凭证;
 **参数**
-
-| 字段名            | 类型      | 默认值  | 描述                                                            |
-| ----------------- | --------- | ------- | --------------------------------------------------------------- |
-| `optionsJSON`     | `object`  | 必填    | 由服务端调用 `generateRegistrationOptions()` 生成的 JSON 对象   |
-| `useAutoRegister` | `boolean` | `false` | 是否启用条件媒介自动注册（实验性，需浏览器支持 Conditional UI） |
+| 字段名            | 类型      | 默认值  | 描述                                                           |
+| ----------------- | --------- | ------- | -------------------------------------------------------------- |
+| `optionsJSON`     | `object`  | 必填    | 由服务端调用 `generateRegistrationOptions()` 生成的 JSON 对象  |
+| `useAutoRegister` | `boolean` | `false` | 是否启用条件媒介自动注册（实验性,需浏览器支持 Conditional UI） |
 
 **返回值** `Promise<RegistrationResponseJSON>`
 
-返回一个经过标准化处理的 JSON 对象，可直接发送给后端 `verifyRegistrationResponse()` 验证。响应格式如下：
+返回一个经过标准化处理的 JSON 对象,可直接发送给后端 `verifyRegistrationResponse()` 验证;响应格式如下：
 
 ```ts
 interface RegistrationResponseJSON {
@@ -326,14 +318,14 @@ const response = await startRegistration({ optionsJSON });
 
 #### startAuthentication(options)
 
-发起 WebAuthn 认证（登录）流程。
+发起 WebAuthn 认证（登录）流程;
 
 **参数**
 
 | 字段名                       | 类型      | 默认值  | 描述                                                                           |
 | ---------------------------- | --------- | ------- | ------------------------------------------------------------------------------ |
 | `optionsJSON`                | `object`  | 必填    | 由服务端调用 `generateAuthenticationOptions()` 生成的 JSON 对象                |
-| `useBrowserAutofill`         | `boolean` | `false` | 是否启用条件媒介（自动填充），实现无感登录                                     |
+| `useBrowserAutofill`         | `boolean` | `false` | 是否启用条件媒介（自动填充）,实现无感登录                                      |
 | `verifyBrowserAutofillInput` | `boolean` | `true`  | 启用自动填充时是否检查页面是否存在 `autocomplete="... webauthn"` 的 input 元素 |
 
 **返回值** `Promise<AuthenticationResponseJSON>`
@@ -371,7 +363,7 @@ const response = await startAuthentication({
 
 #### browserSupportsWebAuthn()
 
-检查当前浏览器是否支持 WebAuthn API。
+检查当前浏览器是否支持 WebAuthn API;
 
 **返回值** `boolean`
 
@@ -383,7 +375,7 @@ if (flunWebAuthnBrowser.browserSupportsWebAuthn()) {
 
 #### platformAuthenticatorIsAvailable()
 
-检查平台认证器（如 Touch ID、Face ID、Windows Hello）是否可用。
+检查平台认证器（如 Touch ID、Face ID、Windows Hello）是否可用;
 
 **返回值** `Promise<boolean>`
 
@@ -393,7 +385,7 @@ const available = await flunWebAuthnBrowser.platformAuthenticatorIsAvailable();
 
 #### browserSupportsWebAuthnAutofill()
 
-检查当前浏览器是否支持 WebAuthn 条件媒介（自动填充）。
+检查当前浏览器是否支持 WebAuthn 条件媒介（自动填充）;
 
 **返回值** `Promise<boolean>`
 
@@ -424,7 +416,7 @@ const { bufferToBase64URLString, base64URLStringToBuffer } = flunWebAuthnBrowser
 
 #### WebAuthnError
 
-自定义错误类，继承自 `Error`。当认证/注册过程中发生可识别的错误时抛出。
+自定义错误类,继承自 `Error`;当认证/注册过程中发生可识别的错误时抛出;
 
 **属性**
 
@@ -444,18 +436,18 @@ const { bufferToBase64URLString, base64URLStringToBuffer } = flunWebAuthnBrowser
 | `ERROR_AUTHENTICATOR_GENERAL_ERROR`                           | 认证器通用错误                                   |
 | `ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED`                   | 认证器已被注册（注册时）                         |
 | `ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT` | 需要可发现凭证但认证器不支持                     |
-| `ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY`                        | 透传错误，需查看 `cause` 属性                    |
+| `ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY`                        | 透传错误,需查看 `cause` 属性                     |
 
 #### WebAuthnAbortService
 
-用于手动取消正在进行的 WebAuthn 操作。
+用于手动取消正在进行的 WebAuthn 操作;
 
 **方法**
 
-| 方法                     | 描述                                       |
-| ------------------------ | ------------------------------------------ |
-| `createNewAbortSignal()` | 创建新的 AbortSignal，并自动中止之前的操作 |
-| `cancelCeremony()`       | 主动取消当前正在进行的认证/注册流程        |
+| 方法                     | 描述                                      |
+| ------------------------ | ----------------------------------------- |
+| `createNewAbortSignal()` | 创建新的 AbortSignal,并自动中止之前的操作 |
+| `cancelCeremony()`       | 主动取消当前正在进行的认证/注册流程       |
 
 ```js
 // 取消当前所有 WebAuthn 操作
@@ -464,7 +456,7 @@ flunWebAuthnBrowser.WebAuthnAbortService.cancelCeremony();
 
 ### 内部调试工具
 
-以下属性暴露了部分内部实现细节，**仅用于高级调试或扩展，不推荐在生产中直接使用**。
+以下属性暴露了部分内部实现细节,**仅用于高级调试或扩展,不推荐在生产中直接使用**;
 
 | 属性                                        | 描述                   |
 | ------------------------------------------- | ---------------------- |
@@ -475,7 +467,7 @@ flunWebAuthnBrowser.WebAuthnAbortService.cancelCeremony();
 
 ## 错误处理
 
-推荐使用 `try...catch` 捕获 `WebAuthnError` 并根据 `code` 进行差异化处理。
+推荐使用 `try...catch` 捕获 `WebAuthnError` 并根据 `code` 进行差异化处理;
 
 ```js
 import { startAuthentication, WebAuthnError } from '@flun/webauthn-browser';
@@ -507,7 +499,7 @@ 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);
 
 **前端代码**
 

package/dist/index.js

@@ -1,20 +1,17 @@
-/* 基于[@simplewebauthn/browser@13.3.0] 开发 */
+/* 基于 @simplewebauthn/browser 修改,前端自动检测操作系统,Windows 下启用原生模拟 */
 !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);
@@ -22,19 +19,14 @@
             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)
@@ -54,7 +46,6 @@
                 }
             }
         },
-
         authenticatorAttachmentValues = ["cross-platform", "platform"],
         normalizeAuthenticatorAttachment = (e) => {
             if (e && !(authenticatorAttachmentValues.indexOf(e) < 0)) return e
@@ -63,15 +54,35 @@
             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())
-        };
+        },
+        // 提取 base64url ID
+        extractBase64Id = obj => {
+            if (!obj) return undefined;
+            const id = obj.id;
+            if (typeof id === 'string') return id;
+            if (id && typeof id === 'object' && id.type === 'Buffer' && Array.isArray(id.data))
+                return bufferToBase64URLString(Uint8Array.from(id.data));
+            if (id instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(id)))
+                return bufferToBase64URLString(id);
+            return undefined;
+        },
+        normalizeOptions = input => {
+            if (!input) return null;
+            if (input.optionsJSON) return input;
+            if (input.challenge) return { optionsJSON: input };
+            return null;
+        },
+        // 前端自动检测操作系统是否为 Windows
+        isWindows = (() => {
+            const ua = navigator.userAgent || '';
+            return /Windows/i.test(ua) || /Win32/i.test(ua) || /Win64/i.test(ua);
+        })();
 
-    // 自定义 WebAuthn 错误类
     class WebAuthnError extends Error {
         constructor({ message: e, code: t, cause: r, name: n }) {
             super(e, { cause: r });
@@ -79,100 +90,52 @@
         }
     };
 
-    // 导出内部工具（供测试/扩展使用）
+    // 导出
+    // 1. 内部工具（高级用户使用）
     e.WebAuthnAbortService = WebAuthnAbortService;
     e._browserSupportsWebAuthnAutofillInternals = p;
     e._browserSupportsWebAuthnInternals = o;
+    // 2. 编解码工具
     e.base64URLStringToBuffer = base64URLStringToBuffer;
     e.bufferToBase64URLString = bufferToBase64URLString;
+    // 3. 环境/功能检测工具
     e.browserSupportsWebAuthn = browserSupportsWebAuthn;
     e.browserSupportsWebAuthnAutofill = browserSupportsWebAuthnAutofill;
     e.platformAuthenticatorIsAvailable = () => {
         return browserSupportsWebAuthn() ? PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() : falsePromise;
     };
+    // 4. 错误类
     e.WebAuthnError = WebAuthnError;
+    // 5. 核心方法（注册和认证）
+    e.startRegistration = async e => {
+        const normalized = normalizeOptions(e);
+        if (!normalized) throw new Error('startRegistration 需要传入包含 optionsJSON 或 challenge 的对象');
 
-    // 开始认证（登录）
-    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 })
+        e = normalized;
+        if (isWindows) {
+            const optionsJSON = e.optionsJSON || e, userId = extractBase64Id(optionsJSON?.user) || crypto.randomUUID();
+            return {
+                id: userId,
+                rawId: bufferToBase64URLString(base64URLStringToBuffer(userId)),
+                response: {
+                    attestationObject: '', clientDataJSON: '', transports: [],
+                    publicKeyAlgorithm: -7, publicKey: '', authenticatorData: ''
+                },
+                type: 'public-key',
+                clientExtensionResults: {},
+                authenticatorAttachment: 'platform',
+                native: true
+            };
         }
-        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;
+        // 标准 WebAuthn
         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 = {};
+        const { optionsJSON: o, useAutoRegister: c = !1 } = e,
+            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();
@@ -266,5 +229,85 @@
             clientExtensionResults: f.getClientExtensionResults(),
             authenticatorAttachment: normalizeAuthenticatorAttachment(f.authenticatorAttachment)
         }
-    }
+    };
+    e.startAuthentication = async e => {
+        const normalized = normalizeOptions(e);
+        if (!normalized) throw new Error('startAuthentication 需要传入包含 optionsJSON 或 challenge 的对象');
+        e = normalized;
+
+        // Windows 下自动启用原生认证模块
+        if (isWindows) {
+            const accountId = e.accountId || extractBase64Id(e.optionsJSON?.allowCredentials?.[0]);
+            if (!accountId) throw new Error('未找到硬件凭证 ID,请确认已注册设备或使用备用码登录');
+            return {
+                id: accountId,
+                rawId: bufferToBase64URLString(base64URLStringToBuffer(accountId)),
+                response: { authenticatorData: '', clientDataJSON: '', signature: '', userHandle: '' },
+                type: 'public-key',
+                clientExtensionResults: {},
+                authenticatorAttachment: 'platform',
+                native: true
+            };
+        }
+
+        // 标准 WebAuthn
+        if (!browserSupportsWebAuthn()) throw new Error("当前浏览器不支持 WebAuthn");
+        const { optionsJSON: o, useBrowserAutofill: c = !1, verifyBrowserAutofillInput: d = !0 } = e;
+        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)
+        }
+    };
 });

package/helpers/common.js

@@ -0,0 +1,45 @@
+import { bufferToBase64URLString } from './base64urlAndBuffer.js';
+/**
+ * 检测当前操作系统是否为 Windows,
+ * 用于在 Windows 平台下启用原生 Windows Hello 认证流程
+ * > 查看定义:@see {@link isWindows}
+ */
+const isWindows = (() => {
+    const ua = navigator.userAgent || '';
+    return /Windows/i.test(ua) || /Win32/i.test(ua) || /Win64/i.test(ua);
+})();
+
+/**
+ * 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串
+ * 支持多种 ID 表示形式（字符串、Uint8Array、Buffer 序列化对象等）
+ * > 查看定义:@see {@link extractBase64Id}
+ * @param {Object} obj - 包含 `id` 属性的对象
+ * @returns {string|undefined} base64url 编码的 ID 字符串，或 undefined
+ */
+const extractBase64Id = obj => {
+    if (!obj) return undefined;
+    const id = obj.id;
+    if (typeof id === 'string') return id;
+    if (id && typeof id === 'object' && id.type === 'Buffer' && Array.isArray(id.data))
+        return bufferToBase64URLString(Uint8Array.from(id.data));
+    if (id instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(id)))
+        return bufferToBase64URLString(id);
+    return undefined;
+};
+
+/**
+ * 规范化传入的 options 对象,兼容旧调用方式
+ * - 若传入 { optionsJSON } 则原样返回
+ * - 若传入 { challenge, ... } 则包装为 { optionsJSON: input }
+ * - 否则返回 null
+ * > 查看定义:@see {@link normalizeOptions}
+ * @param {Object} [input] - 用户传入的 options，应包含 optionsJSON 或 challenge 属性
+ * @returns {Object|null} 规范化后的对象（至少包含 optionsJSON 属性）或 null
+ */
+const normalizeOptions = input => {
+    if (!input) return null;
+    if (input.optionsJSON) return input;
+    if (input.challenge) return { optionsJSON: input };
+    return null;
+};
+export { isWindows, extractBase64Id, normalizeOptions };

package/helpers/index.d.ts

@@ -1,6 +1,7 @@
 import { base64URLStringToBuffer, bufferToBase64URLString } from './base64urlAndBuffer.js';
 import { _browserSupportsWebAuthnInternals, browserSupportsWebAuthn } from './browserSupportsWebAuthn.js';
 import { _browserSupportsWebAuthnAutofillInternals, browserSupportsWebAuthnAutofill } from './browserSupportsWebAuthnAutofill.js';
+import { isWindows, extractBase64Id, normalizeOptions } from './common.js';
 import { identifyAuthenticationError } from './identifyAuthenticationError.js';
 import { identifyRegistrationError } from './identifyRegistrationError.js';
 import { isValidDomain } from './isValidDomain.js';
@@ -49,6 +50,20 @@ declare module './browserSupportsWebAuthnAutofill.js' {
     export * from './browserSupportsWebAuthnAutofill.js';
 }
 
+// =================================== common.js ===================================
+/**
+ * ```js
+ * // 文件导出内容
+ * const isWindows=(); // 当前操作系统是否为 Windows
+ * extractBase64Id();  // 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串 支持多种 ID 表示形式
+ * normalizeOptions(); // 规范化传入的 options 对象,兼容旧调用方式
+ * ```
+ * >查看定义:@see {@link isWindows}、{@link extractBase64Id}、{@link normalizeOptions}
+ */
+declare module './common.js' {
+    export * from './common.js';
+}
+
 // ================================ identifyAuthenticationError.js ================================
 /**
  * ```js
@@ -162,6 +177,7 @@ declare module './webAuthnError.js' {
  * // 常量
  * const _browserSupportsWebAuthnInternals={};         // 测试期间对返回值进行桩（stub）处理
  * const _browserSupportsWebAuthnAutofillInternals={}; // 测试期间模拟返回值;
+ * const isWindows=();                                 // 当前操作系统是否为 Windows
  * const WebAuthnAbortService = new BaseWebAuthnAbortService(); // 服务单例,用于确保同一时间只有一个 WebAuthn 仪式处于活动状态;
  *
  * // 函数
@@ -169,6 +185,9 @@ declare module './webAuthnError.js' {
  * bufferToBase64URLString();                          // 将给定的数组缓冲区转换为 Base64URL 编码的字符串;
  * browserSupportsWebAuthn();                          // 判断当前浏览器是否支持 WebAuthn
  * browserSupportsWebAuthnAutofill();                  // 判断浏览器是否支持条件式UI;
+ * isWindows();                                        // 检测当前操作系统是否为 Windows
+ * extractBase64Id();                                  // 从包含凭证 ID 的对象中提取 base64url 格式的 ID 字符串 支持多种 ID 表示形式
+ * normalizeOptions();                                 // 规范化传入的 options 对象,兼容旧调用方式
  * identifyAuthenticationError();                      // 尝试推断调用 `navigator.credentials.get()` 后引发错误的原因;
  * identifyRegistrationError();                        // 尝试推断调用 `navigator.credentials.create()` 后引发错误的原因;
  * isValidDomain();                                    // 判断主机名是否符合验证规范;
@@ -181,17 +200,19 @@ declare module './webAuthnError.js' {
  * ```
  * >查看定义:@see
  * - 类型 {@link WebAuthnErrorCode}
- * - 常量 {@link _browserSupportsWebAuthnInternals}、{@link _browserSupportsWebAuthnAutofillInternals}、{@link WebAuthnAbortService}
+ * - 常量 {@link _browserSupportsWebAuthnInternals}、{@link _browserSupportsWebAuthnAutofillInternals}、
+ * {@link WebAuthnAbortService}、{@link isWindows}
  * - 函数 {@link base64URLStringToBuffer}、{@link bufferToBase64URLString}、 {@link browserSupportsWebAuthn}、
- * {@link browserSupportsWebAuthnAutofill}、{@link identifyAuthenticationError}、{@link identifyRegistrationError}、
- * {@link isValidDomain}、{@link platformAuthenticatorIsAvailable}、{@link toAuthenticatorAttachment}、
- * {@link toPublicKeyCredentialDescriptor}
+ * {@link browserSupportsWebAuthnAutofill}、{@link extractBase64Id}、{@link normalizeOptions}、
+ * {@link identifyAuthenticationError}、{@link identifyRegistrationError}、{@link isValidDomain}、
+ * {@link platformAuthenticatorIsAvailable}、{@link toAuthenticatorAttachment}、{@link toPublicKeyCredentialDescriptor}
  * - 类 {@link WebAuthnError}
  */
 declare module './index.js' {
     export * from './base64urlAndBuffer.js';
     export * from './browserSupportsWebAuthn.js';
     export * from './browserSupportsWebAuthnAutofill.js';
+    export * from './common.js';
     export * from './identifyAuthenticationError.js';
     export * from './identifyRegistrationError.js';
     export * from './isValidDomain.js';

package/helpers/index.js

@@ -1,6 +1,7 @@
 export * from './base64urlAndBuffer.js';
 export * from './browserSupportsWebAuthn.js';
 export * from './browserSupportsWebAuthnAutofill.js';
+export * from './common.js';
 export * from './identifyAuthenticationError.js';
 export * from './identifyRegistrationError.js';
 export * from './isValidDomain.js';

package/methods/startAuthentication.js

@@ -1,15 +1,17 @@
 import {
     bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, browserSupportsWebAuthnAutofill,
-    identifyAuthenticationError, toAuthenticatorAttachment, toPublicKeyCredentialDescriptor, WebAuthnAbortService
+    isWindows, extractBase64Id, normalizeOptions, identifyAuthenticationError, toAuthenticatorAttachment,
+    toPublicKeyCredentialDescriptor, WebAuthnAbortService
 } from '../helpers/index.js';
 
 /**
  * 通过 WebAuthn 断言开始身份验证器“登录”
- * - 查看定义:@see {@link startAuthentication}
+ * > 查看定义:@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` 中提取
  * @returns {Promise<{
  *   id: string,
  *   rawId: string,
@@ -21,48 +23,50 @@ import {
  *   },
  *   type: string,
  *   clientExtensionResults: AuthenticationExtensionsClientOutputs,
- *   authenticatorAttachment: string
+ *   authenticatorAttachment: string,
+ *   native?: boolean  // 当在 Windows 下启用原生流程时返回 true
  * }>}
  */
-const startAuthentication = async options => {
-    // 有意检查旧的调用结构,以警告不正确的 API 调用
-    if (!options.optionsJSON && options.challenge) {
-        console.warn("startAuthentication() 调用方式不正确；它将尝试使用提供的选项继续执行,但应重构此调用以使用预期的调用结构；");
-        options = { optionsJSON: options }; // 将作为位置参数传入的 options 重新赋值给预期变量
+const startAuthentication = async (options) => {
+    const normalized = normalizeOptions(options);
+    if (!normalized) throw new Error('startAuthentication 需要传入包含 optionsJSON 或 challenge 的对象');
+    options = normalized;
+
+    const { optionsJSON, useBrowserAutofill = false, verifyBrowserAutofillInput = true, accountId: userId } = options;
+    // 若当前系统为 Windows,则直接返回模拟凭证数据,应用层可据此识别并调用底层 Windows Hello 接口;
+    if (isWindows) {
+        // 优先使用显式传入的 accountId,否则从 allowCredentials 中提取第一个凭证的 ID
+        const accountId = userId || extractBase64Id(optionsJSON?.allowCredentials?.[0]);
+        if (!accountId) throw new Error('未找到硬件凭证 ID,请确认已注册设备或使用备用码登录');
+        return {
+            id: accountId,
+            rawId: bufferToBase64URLString(base64URLStringToBuffer(accountId)),
+            response: { authenticatorData: '', clientDataJSON: '', signature: '', userHandle: '' },
+            type: 'public-key',
+            clientExtensionResults: {},
+            authenticatorAttachment: 'platform',
+            native: true   // 标记为原生流程
+        };
     }
+    // 标准 WebAuthn 认证流程
     if (!browserSupportsWebAuthn()) throw new Error('此浏览器不支持 WebAuthn');
-
-    const { optionsJSON, useBrowserAutofill = false, verifyBrowserAutofillInput = true } = options;
-    // 需要避免传递空数组,以免阻止公钥的检索
     let allowCredentials;
     if (optionsJSON.allowCredentials?.length !== 0)
         allowCredentials = optionsJSON.allowCredentials?.map(toPublicKeyCredentialDescriptor);
 
-    // 在将凭证传递给 navigator 之前，需要将某些值转换为 Uint8Array
-    const publicKey = { ...optionsJSON, challenge: base64URLStringToBuffer(optionsJSON.challenge), allowCredentials }
-        , getOptions = {}; // 为 `.get()` 准备选项
-
-    /**
-     * 设置页面，通过浏览器的输入自动填充机制提示用户选择用于身份验证的凭证；
-     */
+    const publicKey = { ...optionsJSON, challenge: base64URLStringToBuffer(optionsJSON.challenge), allowCredentials },
+        getOptions = {};
     if (useBrowserAutofill) {
         if (!(await browserSupportsWebAuthnAutofill())) throw Error('浏览器不支持 WebAuthn 自动填充');
 
-        // 检查是否存在 `autocomplete` 属性中包含 "webauthn" 的 <input>
         const eligibleInputs = document.querySelectorAll("input[autocomplete$='webauthn']");
-
-        // WebAuthn 自动填充要求至少有一个有效的输入框
         if (eligibleInputs.length < 1 && verifyBrowserAutofillInput)
             throw Error('未检测到任何 `autocomplete` 属性中包含 "webauthn"（作为唯一值或最后一个值）的 <input> 元素');
 
-        // 截至 typescript@4.6.3，`CredentialMediationRequirement` 尚不识别 "conditional"
-        getOptions.mediation = 'conditional', publicKey.allowCredentials = []; // 条件式 UI 要求 allowCredentials 为空列表
+        getOptions.mediation = 'conditional', publicKey.allowCredentials = [];
     }
+    getOptions.publicKey = publicKey, getOptions.signal = WebAuthnAbortService.createNewAbortSignal();
 
-    getOptions.publicKey = publicKey; // 最终确定选项
-    getOptions.signal = WebAuthnAbortService.createNewAbortSignal(); // 设置取消此请求的能力,以防用户尝试另一个请求
-
-    // 等待用户完成断言
     let credential;
     try {
         credential = await navigator.credentials.get(getOptions);
@@ -75,7 +79,6 @@ const startAuthentication = async options => {
     let userHandle = undefined;
     if (response.userHandle) userHandle = bufferToBase64URLString(response.userHandle);
 
-    // 将值转换为 base64，以便更容易发送回服务器
     return {
         id,
         rawId: bufferToBase64URLString(rawId),
@@ -84,11 +87,8 @@ const startAuthentication = async options => {
             clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
             signature: bufferToBase64URLString(response.signature),
             userHandle,
-        },
-        type,
-        clientExtensionResults: credential.getClientExtensionResults(),
+        }, type, clientExtensionResults: credential.getClientExtensionResults(),
         authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment),
     };
-}
-
+};
 export { startAuthentication };

package/methods/startRegistration.js

@@ -1,14 +1,26 @@
 import {
-    bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, identifyRegistrationError,
-    toAuthenticatorAttachment, toPublicKeyCredentialDescriptor, WebAuthnAbortService
+    bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, isWindows, extractBase64Id, normalizeOptions,
+    identifyRegistrationError, toAuthenticatorAttachment, toPublicKeyCredentialDescriptor, WebAuthnAbortService
 } from '../helpers/index.js';
 
+/**
+ * 当检测到通行密钥提供方拦截 WebAuthn API 调用导致的问题时,发出可见警告
+ *
+ * @param {string} methodName - 被错误实现的 WebAuthn API 方法名称
+ * @param {unknown} cause - 捕获到的原始错误对象
+ * @returns {void}
+ */
+const warnOnBrokenImplementation = (methodName, cause) => {
+    console.warn(`拦截此 WebAuthn API 调用的浏览器扩展错误地实现了 ${methodName};请向该扩展的开发者报告此问题;\n`, cause);
+};
+
 /**
  * 通过 WebAuthn 证明开始认证器“注册”
  * - 查看定义:@see {@link startRegistration}
  *
  * @param {Object} options - 配置选项
- * @param {PublicKeyCredentialCreationOptionsJSON} options.optionsJSON - 来自 **@flun/webauthn-server** 的 `generateRegistrationOptions()` 的输出
+ * @param {PublicKeyCredentialCreationOptionsJSON} options.optionsJSON
+ * - 来自 **@flun/webauthn-server** 的 `generateRegistrationOptions()` 的输出
  * @param {boolean} [options.useAutoRegister] - 尝试静默使用用户刚刚登录的密码管理器创建一个通行密钥,默认为 `false`
  * @returns {Promise<{
  *   id: string,
@@ -23,37 +35,52 @@ import {
  *   },
  *   type: PublicKeyCredentialType,
  *   clientExtensionResults: AuthenticationExtensionsClientOutputs,
- *   authenticatorAttachment: AuthenticatorAttachment | null
+ *   authenticatorAttachment: AuthenticatorAttachment | null,
+ *   native?: boolean  // 当在 Windows 下启用原生流程时返回 true
  * }>}
  */
-const startRegistration = async options => {
-    // 有意检查旧的调用结构，以警告不正确的 API 调用
-    if (!options.optionsJSON && options.challenge) {
-        console.warn('startRegistration() 的调用方式不正确；将继续尝试使用提供的选项,但应重构此调用以使用预期的调用结构；');
-        options = { optionsJSON: options };  // 将作为位置参数传入的 options 重新赋值给预期的变量
+const startRegistration = async (options) => {
+    // 规范化传入的参数,兼容旧的调用方式
+    const normalized = normalizeOptions(options);
+    if (!normalized) throw new Error('startRegistration 需要传入包含 optionsJSON 或 challenge 的对象');
+    options = normalized;
+
+    const { optionsJSON, useAutoRegister = false } = options;
+    // 若当前系统为 Windows,则直接返回模拟凭证数据,应用层可据此识别并调用底层 Windows Hello 接口;
+    if (isWindows) {
+        // 尝试从 optionsJSON.user.id 提取用户 ID,若无法提取则生成随机 UUID
+        const userId = extractBase64Id(optionsJSON?.user) || crypto.randomUUID();
+        return {
+            id: userId,
+            rawId: bufferToBase64URLString(base64URLStringToBuffer(userId)),
+            response: {
+                attestationObject: '', clientDataJSON: '', transports: [],
+                publicKeyAlgorithm: -7, publicKey: '', authenticatorData: ''
+            },
+            type: 'public-key',
+            clientExtensionResults: {},
+            authenticatorAttachment: 'platform',
+            native: true   // 标记为原生流程
+        };
     }
 
+    // 标准 WebAuthn 注册流程
     if (!browserSupportsWebAuthn()) throw new Error('此浏览器不支持 WebAuthn');
-    const { optionsJSON, useAutoRegister = false } = options,
-        // 需要将部分值转换为 Uint8Array 后才能传递给 navigator 的 credentials
-        publicKey = {
-            ...optionsJSON,
-            challenge: base64URLStringToBuffer(optionsJSON.challenge),
-            user: { ...optionsJSON.user, id: base64URLStringToBuffer(optionsJSON.user.id) },
-            excludeCredentials: optionsJSON.excludeCredentials?.map(toPublicKeyCredentialDescriptor)
-        }, createOptions = {}; // 准备传递给 `.create()` 的选项
+    const publicKey = {
+        ...optionsJSON,
+        challenge: base64URLStringToBuffer(optionsJSON.challenge),
+        user: { ...optionsJSON.user, id: base64URLStringToBuffer(optionsJSON.user.id) },
+        excludeCredentials: optionsJSON.excludeCredentials?.map(toPublicKeyCredentialDescriptor)
+    }, createOptions = {};
 
     /**
-     * 尝试使用条件创建（conditional create）为用户注册一个通行密钥，
-     * 使用用户刚刚用于认证的密码管理器；浏览器不会向用户显示任何突出的 UI；
-     * 注意：`mediation` 在 CredentialCreationOptions 中尚不存在，但自 2024 年 9 月起已可用
+     * 尝试使用条件创建（conditional create）为用户注册一个通行密钥,
+     * 使用用户刚刚用于认证的密码管理器;浏览器不会向用户显示任何突出的 UI;
+     * 注意：`mediation` 在 CredentialCreationOptions 中尚不存在,但自 2024 年 9 月起已可用
      */
     if (useAutoRegister) createOptions.mediation = 'conditional';
+    createOptions.publicKey = publicKey, createOptions.signal = WebAuthnAbortService.createNewAbortSignal();
 
-    createOptions.publicKey = publicKey; // 最终确定选项
-    createOptions.signal = WebAuthnAbortService.createNewAbortSignal(); // 设置取消此请求的能力（如果用户尝试另一个请求）
-
-    // 等待用户完成证明
     let credential;
     try {
         credential = await navigator.credentials.create(createOptions);
@@ -62,13 +89,10 @@ const startRegistration = async options => {
     }
 
     if (!credential) throw new Error('注册未完成');
-
     const { id, rawId, response, type } = credential;
-    // 暂时继续安全地使用 `getTransports()`，即使 L3 类型声称它是必需的
     let transports = void 0;
     if (typeof response.getTransports === 'function') transports = response.getTransports();
 
-    // L3 声称这是必需的，但浏览器和 WebView 的支持仍不保证
     let responsePublicKeyAlgorithm = void 0;
     if (typeof response.getPublicKeyAlgorithm === 'function') {
         try {
@@ -84,7 +108,6 @@ const startRegistration = async options => {
         } catch (error) { warnOnBrokenImplementation('getPublicKey()', error); }
     }
 
-    // L3 声称这是必需的，但浏览器和 WebView 的支持仍不保证
     let responseAuthenticatorData;
     if (typeof response.getAuthenticatorData === 'function') {
         try {
@@ -107,17 +130,5 @@ const startRegistration = async options => {
         clientExtensionResults: credential.getClientExtensionResults(),
         authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment)
     };
-}
-
-/**
- * 当检测到通行密钥提供方拦截 WebAuthn API 调用导致的问题时,发出可见警告
- *
- * @param {string} methodName - 被错误实现的 WebAuthn API 方法名称
- * @param {unknown} cause - 捕获到的原始错误对象
- * @returns {void}
- */
-const warnOnBrokenImplementation = (methodName, cause) => {
-    console.warn(`拦截此 WebAuthn API 调用的浏览器扩展错误地实现了 ${methodName}；请向该扩展的开发者报告此问题；\n`, cause);
-}
-
+};
 export { startRegistration };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flun/webauthn-browser",
-  "version": "2.0.18",
+  "version": "2.1.0",
   "description": "WebAuthn 前端库,提供简单易用的接口来处理 WebAuthn 认证流程,支持 Passkeys 和 FIDO2 标准;",
   "keywords": [
     "typescript",
@@ -47,6 +47,6 @@
     "npm": ">=10.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.9.0"
+    "@types/node": "^26.1.1"
   }
 }

package/dist/index.es5.js

@@ -1 +0,0 @@
-function e(b) { return e = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (a) { return typeof a } : function (a) { return a && "function" == typeof Symbol && a.constructor === Symbol && a !== Symbol.prototype ? "symbol" : typeof a }, e(b) } !function (a, b) { if ("function" == typeof define && define.amd) define("flunWebAuthnBrowser", ["exports"], b); else if ("undefined" != typeof exports) b(exports); else { var c = { exports: {} }; b(c.exports), a.flunWebAuthnBrowser = c.exports } }("undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : this, (function (n) { function I() { J = function () { return k }; var l, k = {}, s = Object.prototype, p = s.hasOwnProperty, t = Object.defineProperty || function (a, b, c) { a[b] = c.value }, q = "function" == typeof Symbol ? Symbol : {}, v = q.iterator || "@@iterator", z = q.asyncIterator || "@@asyncIterator", B = q.toStringTag || "@@toStringTag"; function w(a, b, c) { return Object.defineProperty(a, b, { value: c, enumerable: !0, configurable: !0, writable: !0 }), a[b] } try { w({}, "") } catch (l) { w = function (a, b, c) { return a[b] = c } } function Z(a, b, c, d) { var f = b && b.prototype instanceof O ? b : O, g = Object.create(f.prototype), i = new P(d || []); return t(g, "_invoke", { value: bt(a, c, i) }), g } function Q(a, b, c) { try { return { type: "normal", arg: a.call(b, c) } } catch (a) { return { type: "throw", arg: a } } } k.wrap = Z; var ba = "suspendedStart", bu = "suspendedYield", bb = "executing", K = "completed", x = {}; function O() { } function L() { } function C() { } var R = {}; w(R, v, (function () { return this })); var S = Object.getPrototypeOf, M = S && S(S(T([]))); M && M !== s && p.call(M, v) && (R = M); var D = C.prototype = O.prototype = Object.create(R); function bc(c) { ["next", "throw", "return"].forEach((function (b) { w(c, b, (function (a) { return this._invoke(b, a) })) })) } function N(j, o) { function r(b, c, d, f) { var g = Q(j[b], j, c); if ("throw" !== g.type) { var i = g.arg, h = i.value; return h && "object" == e(h) && p.call(h, "__await") ? o.resolve(h.__await).then((function (a) { r("next", a, d, f) }), (function (a) { r("throw", a, d, f) })) : o.resolve(h).then((function (a) { i.value = a, d(i) }), (function (a) { return r("throw", a, d, f) })) } f(g.arg) } var y; t(this, "_invoke", { value: function (c, d) { function f() { return new o((function (a, b) { r(c, d, a, b) })) } return y = y ? y.then(f, f) : f() } }) } function bt(g, i, h) { var j = ba; return function (a, b) { if (j === bb) throw Error("Generator is already running"); if (j === K) { if ("throw" === a) throw b; return { value: l, done: !0 } } for (h.method = a, h.arg = b; ;) { var c = h.delegate; if (c) { var d = bd(c, h); if (d) { if (d === x) continue; return d } } if ("next" === h.method) h.sent = h._sent = h.arg; else if ("throw" === h.method) { if (j === ba) throw j = K, h.arg; h.dispatchException(h.arg) } else "return" === h.method && h.abrupt("return", h.arg); j = bb; var f = Q(g, i, h); if ("normal" === f.type) { if (j = h.done ? K : bu, f.arg === x) continue; return { value: f.arg, done: h.done } } "throw" === f.type && (j = K, h.method = "throw", h.arg = f.arg) } } } function bd(a, b) { var c = b.method, d = a.iterator[c]; if (d === l) return b.delegate = null, "throw" === c && a.iterator.return && (b.method = "return", b.arg = l, bd(a, b), "throw" === b.method) || "return" !== c && (b.method = "throw", b.arg = new TypeError("The iterator does not provide a '" + c + "' method")), x; var f = Q(d, a.iterator, b.arg); if ("throw" === f.type) return b.method = "throw", b.arg = f.arg, b.delegate = null, x; var g = f.arg; return g ? g.done ? (b[a.resultName] = g.value, b.next = a.nextLoc, "return" !== b.method && (b.method = "next", b.arg = l), b.delegate = null, x) : g : (b.method = "throw", b.arg = new TypeError("iterator result is not an object"), b.delegate = null, x) } function bv(a) { var b = { tryLoc: a[0] }; 1 in a && (b.catchLoc = a[1]), 2 in a && (b.finallyLoc = a[2], b.afterLoc = a[3]), this.tryEntries.push(b) } function U(a) { var b = a.completion || {}; b.type = "normal", delete b.arg, a.completion = b } function P(a) { this.tryEntries = [{ tryLoc: "root" }], a.forEach(bv, this), this.reset(!0) } function T(a) { if (a || "" === a) { var b = a[v]; if (b) return b.call(a); if ("function" == typeof a.next) return a; if (!isNaN(a.length)) { var c = -1, d = function e() { for (; ++c < a.length;)if (p.call(a, c)) return e.value = a[c], e.done = !1, e; return e.value = l, e.done = !0, e }; return d.next = d } } throw new TypeError(e(a) + " is not iterable") } return L.prototype = C, t(D, "constructor", { value: C, configurable: !0 }), t(C, "constructor", { value: L, configurable: !0 }), L.displayName = w(C, B, "GeneratorFunction"), k.isGeneratorFunction = function (a) { var b = "function" == typeof a && a.constructor; return !!b && (b === L || "GeneratorFunction" === (b.displayName || b.name)) }, k.mark = function (a) { return Object.setPrototypeOf ? Object.setPrototypeOf(a, C) : (a.__proto__ = C, w(a, B, "GeneratorFunction")), a.prototype = Object.create(D), a }, k.awrap = function (a) { return { __await: a } }, bc(N.prototype), w(N.prototype, z, (function () { return this })), k.AsyncIterator = N, k.async = function (b, c, d, f, g) { void 0 === g && (g = Promise); var i = new N(Z(b, c, d, f), g); return k.isGeneratorFunction(c) ? i : i.next().then((function (a) { return a.done ? a.value : i.next() })) }, bc(D), w(D, B, "Generator"), w(D, v, (function () { return this })), w(D, "toString", (function () { return "[object Generator]" })), k.keys = function (b) { var c = Object(b), d = []; for (var f in c) d.push(f); return d.reverse(), function b() { for (; d.length;) { var a = d.pop(); if (a in c) return b.value = a, b.done = !1, b } return b.done = !0, b } }, k.values = T, P.prototype = { constructor: P, reset: function (a) { if (this.prev = 0, this.next = 0, this.sent = this._sent = l, this.done = !1, this.delegate = null, this.method = "next", this.arg = l, this.tryEntries.forEach(U), !a) for (var b in this) "t" === b.charAt(0) && p.call(this, b) && !isNaN(+b.slice(1)) && (this[b] = l) }, stop: function () { this.done = !0; var a = this.tryEntries[0].completion; if ("throw" === a.type) throw a.arg; return this.rval }, dispatchException: function (c) { if (this.done) throw c; var d = this; function f(a, b) { return h.type = "throw", h.arg = c, d.next = a, b && (d.method = "next", d.arg = l), !!b } for (var g = this.tryEntries.length - 1; g >= 0; --g) { var i = this.tryEntries[g], h = i.completion; if ("root" === i.tryLoc) return f("end"); if (i.tryLoc <= this.prev) { var j = p.call(i, "catchLoc"), o = p.call(i, "finallyLoc"); if (j && o) { if (this.prev < i.catchLoc) return f(i.catchLoc, !0); if (this.prev < i.finallyLoc) return f(i.finallyLoc) } else if (j) { if (this.prev < i.catchLoc) return f(i.catchLoc, !0) } else { if (!o) throw Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return f(i.finallyLoc) } } } }, abrupt: function (a, b) { for (var c = this.tryEntries.length - 1; c >= 0; --c) { var d = this.tryEntries[c]; if (d.tryLoc <= this.prev && p.call(d, "finallyLoc") && this.prev < d.finallyLoc) { var f = d; break } } f && ("break" === a || "continue" === a) && f.tryLoc <= b && b <= f.finallyLoc && (f = null); var g = f ? f.completion : {}; return g.type = a, g.arg = b, f ? (this.method = "next", this.next = f.finallyLoc, x) : this.complete(g) }, complete: function (a, b) { if ("throw" === a.type) throw a.arg; return "break" === a.type || "continue" === a.type ? this.next = a.arg : "return" === a.type ? (this.rval = this.arg = a.arg, this.method = "return", this.next = "end") : "normal" === a.type && b && (this.next = b), x }, finish: function (a) { for (var b = this.tryEntries.length - 1; b >= 0; --b) { var c = this.tryEntries[b]; if (c.finallyLoc === a) return this.complete(c.completion, c.afterLoc), U(c), x } }, catch: function (e) { for (var l = this.tryEntries.length - 1; l >= 0; --l) { var J = this.tryEntries[l]; if (J.tryLoc === e) { var k = J.completion; if ("throw" === k.type) { var s = k.arg; U(J) } return s } } throw Error("illegal catch attempt") }, delegateYield: function (a, b, c) { return this.delegate = { iterator: T(a), resultName: b, nextLoc: c }, "next" === this.method && (this.arg = l), x } }, k } function be(a, b, c, d, f, g, i) { try { var h = a[g](i), j = h.value } catch (a) { return void c(a) } h.done ? b(j) : Promise.resolve(j).then(d, f) } function bf(j) { return function () { var i = this, h = arguments; return new Promise((function (b, c) { var d = j.apply(i, h); function f(a) { be(d, b, c, f, g, "next", a) } function g(a) { be(d, b, c, f, g, "throw", a) } f(void 0) })) } } function bg(a, b) { for (var c = 0; c < b.length; c++) { var d = b[c]; d.enumerable = d.enumerable || !1, d.configurable = !0, "value" in d && (d.writable = !0), Object.defineProperty(a, bh(d.key), d) } } function bi(a, b, c) { return b && bg(a.prototype, b), c && bg(a, c), Object.defineProperty(a, "prototype", { writable: !1 }), a } function bj(a, b) { if (!(a instanceof b)) throw new TypeError("Cannot call a class as a function") } function bw(d, f, g) { return f = E(f), function (b, c) { if (c && ("object" == e(c) || "function" == typeof c)) return c; if (void 0 !== c) throw new TypeError("Derived constructors may only return object or undefined"); return function (a) { if (void 0 === a) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return a }(b) }(d, V() ? Reflect.construct(f, g || [], E(d).constructor) : f.apply(d, g)) } function W(h) { var j = "function" == typeof Map ? new Map : void 0; return W = function (g) { if (null === g || !function (g) { try { return -1 !== Function.toString.call(g).indexOf("[native code]") } catch (j) { return "function" == typeof g } }(g)) return g; if ("function" != typeof g) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== j) { if (j.has(g)) return j.get(g); j.set(g, i) } function i() { return function (a, b, c) { if (V()) return Reflect.construct.apply(null, arguments); var d = [null]; d.push.apply(d, b); var f = new (a.bind.apply(a, d)); return c && F(f, c.prototype), f }(g, arguments, E(this).constructor) } return i.prototype = Object.create(g.prototype, { constructor: { value: i, enumerable: !1, writable: !0, configurable: !0 } }), F(i, g) }, W(h) } function V() { try { var a = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], (function () { }))) } catch (a) { } return (V = function () { return !!a })() } function F(c, d) { return F = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (a, b) { return a.__proto__ = b, a }, F(c, d) } function E(b) { return E = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (a) { return a.__proto__ || Object.getPrototypeOf(a) }, E(b) } function bk(b, c) { var d = Object.keys(b); if (Object.getOwnPropertySymbols) { var f = Object.getOwnPropertySymbols(b); c && (f = f.filter((function (a) { return Object.getOwnPropertyDescriptor(b, a).enumerable }))), d.push.apply(d, f) } return d } function A(b) { for (var c = 1; c < arguments.length; c++) { var d = null != arguments[c] ? arguments[c] : {}; c % 2 ? bk(Object(d), !0).forEach((function (a) { bx(b, a, d[a]) })) : Object.getOwnPropertyDescriptors ? Object.defineProperties(b, Object.getOwnPropertyDescriptors(d)) : bk(Object(d)).forEach((function (a) { Object.defineProperty(b, a, Object.getOwnPropertyDescriptor(d, a)) })) } return b } function bx(a, b, c) { return (b = bh(b)) in a ? Object.defineProperty(a, b, { value: c, enumerable: !0, configurable: !0, writable: !0 }) : a[b] = c, a } function bh(f) { var g = function (a, b) { if ("object" != e(a) || !a) return a; var c = a[Symbol.toPrimitive]; if (void 0 !== c) { var d = c.call(a, b || "default"); if ("object" != e(d)) return d; throw new TypeError("@@toPrimitive must return a primitive value.") } return ("string" === b ? String : Number)(a) }(f, "string"); return "symbol" == e(g) ? g : g + "" } function by(b, c) { var d = "undefined" != typeof Symbol && b[Symbol.iterator] || b["@@iterator"]; if (!d) { if (Array.isArray(b) || (d = function (b, c) { if (b) { if ("string" == typeof b) return bl(b, c); var d = {}.toString.call(b).slice(8, -1); return "Object" === d && b.constructor && (d = b.constructor.name), "Map" === d || "Set" === d ? Array.from(b) : "Arguments" === d || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(d) ? bl(b, c) : void 0 } }(b)) || c && b && "number" == typeof b.length) { d && (b = d); var f = 0, g = function () { }; return { s: g, n: function () { return f >= b.length ? { done: !0 } : { done: !1, value: b[f++] } }, e: function (a) { throw a }, f: g } } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.") } var i, h = !0, j = !1; return { s: function () { d = d.call(b) }, n: function () { var a = d.next(); return h = a.done, a }, e: function (a) { j = !0, i = a }, f: function () { try { h || null == d.return || d.return() } finally { if (j) throw i } } } } function bl(a, b) { (null == b || b > a.length) && (b = a.length); for (var c = 0, d = Array(b); c < b; c++)d[c] = a[c]; return d } function u(a) { var b, c = "", d = by(new Uint8Array(a)); try { for (d.s(); !(b = d.n()).done;) { var f = b.value; c += String.fromCharCode(f) } } catch (a) { d.e(a) } finally { d.f() } return btoa(c).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "") } function G(a) { for (var b = a.replace(/-/g, "+").replace(/_/g, "/"), c = (4 - b.length % 4) % 4, d = b.padEnd(b.length + c, "="), f = atob(d), g = new ArrayBuffer(f.length), i = new Uint8Array(g), h = 0; h < f.length; h++)i[h] = f.charCodeAt(h); return g } function H() { var a; return bz.stubThis(void 0 !== (null === (a = window) || void 0 === a ? void 0 : a.PublicKeyCredential) && "function" == typeof window.PublicKeyCredential) } Object.defineProperty(n, "__esModule", { value: !0 }), n._browserSupportsWebAuthnInternals = n._browserSupportsWebAuthnAutofillInternals = n.WebAuthnError = n.WebAuthnAbortService = void 0, n.base64URLStringToBuffer = G, n.browserSupportsWebAuthn = H, n.browserSupportsWebAuthnAutofill = bm, n.bufferToBase64URLString = u, n.platformAuthenticatorIsAvailable = function () { if (!H()) return new Promise((function (e) { return e(!1) })); return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() }, n.startAuthentication = function (a) { return bn.apply(this, arguments) }, n.startRegistration = function (a) { return bo.apply(this, arguments) }; var bz = n._browserSupportsWebAuthnInternals = { stubThis: function (a) { return a } }; function bp(a) { var b = a.id; return A(A({}, a), {}, { id: G(b), transports: a.transports }) } function bq(a) { return "localhost" === a || /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(a) } var m = n.WebAuthnError = function (i) { function h(a) { var b, c = a.message, d = a.code, f = a.cause, g = a.name; return bj(this, h), b = bw(this, h, [c, { cause: f }]), Object.defineProperty(b, "code", { enumerable: !0, configurable: !0, writable: !0, value: void 0 }), b.name = null != g ? g : f.name, b.code = d, b } return function (a, b) { if ("function" != typeof b && null !== b) throw new TypeError("Super expression must either be null or a function"); a.prototype = Object.create(b && b.prototype, { constructor: { value: a, writable: !0, configurable: !0 } }), Object.defineProperty(a, "prototype", { writable: !1 }), b && F(a, b) }(h, i), bi(h) }(W(Error)); function bA(a) { var b = a.error, c = a.options, d = c.publicKey; if (!d) throw Error("options was missing required publicKey property"); if ("AbortError" === b.name) { if (c.signal instanceof AbortSignal) return new m({ message: "注册流程收到了中止信号", code: "ERROR_CEREMONY_ABORTED", cause: b }) } else if ("ConstraintError" === b.name) { var f, g, i; if (!0 === (null === (f = d.authenticatorSelection) || void 0 === f ? void 0 : f.requireResidentKey)) return new m({ message: "要求使用可发现凭证,但可用的验证器不支持", code: "ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT", cause: b }); if ("conditional" === c.mediation && "required" === (null === (g = d.authenticatorSelection) || void 0 === g ? void 0 : g.userVerification)) return new m({ message: "自动注册时要求用户验证,但无法执行", code: "ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE", cause: b }); if ("required" === (null === (i = d.authenticatorSelection) || void 0 === i ? void 0 : i.userVerification)) return new m({ message: "要求用户验证,但可用的验证器不支持", code: "ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT", cause: b }) } else { if ("InvalidStateError" === b.name) return new m({ message: "该验证器已被注册过", code: "ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED", cause: b }); if ("NotAllowedError" === b.name) return new m({ message: b.message, code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY", cause: b }); if ("NotSupportedError" === b.name) return 0 === d.pubKeyCredParams.filter((function (a) { return "public-key" === a.type })).length ? new m({ message: 'pubKeyCredParams 中没有 type 为 "public-key" 的条目', code: "ERROR_MALFORMED_PUBKEYCREDPARAMS", cause: b }) : new m({ message: "没有可用的验证器支持指定的任何 pubKeyCredParams 算法", code: "ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG", cause: b }); if ("SecurityError" === b.name) { var h = window.location.hostname; if (!bq(h)) return new m({ message: "".concat(window.location.hostname, " 是无效域名"), code: "ERROR_INVALID_DOMAIN", cause: b }); if (d.rp.id !== h) return new m({ message: 'RP ID "'.concat(d.rp.id, '" 对于当前域名无效'), code: "ERROR_INVALID_RP_ID", cause: b }) } else if ("TypeError" === b.name) { if (d.user.id.byteLength < 1 || d.user.id.byteLength > 64) return new m({ message: "用户 ID 长度不在1~64字节之间", code: "ERROR_INVALID_USER_ID_LENGTH", cause: b }) } else if ("UnknownError" === b.name) return new m({ message: "验证器无法处理指定的选项或创建新的凭证", code: "ERROR_AUTHENTICATOR_GENERAL_ERROR", cause: b }) } return b } var bB = function () { return bi((function c() { bj(this, c), Object.defineProperty(this, "controller", { enumerable: !0, configurable: !0, writable: !0, value: void 0 }) }), [{ key: "createNewAbortSignal", value: function () { if (this.controller) { var a = new Error("正在取消已有的 WebAuthn API 调用,然后进行新的调用"); a.name = "AbortError", this.controller.abort(a) } var b = new AbortController; return this.controller = b, b.signal } }, { key: "cancelCeremony", value: function () { if (this.controller) { var a = new Error("正在取消 WebAuthn API 调用"); a.name = "AbortError", this.controller.abort(a), this.controller = void 0 } } }]) }(), br = n.WebAuthnAbortService = new bB, bC = ["cross-platform", "platform"]; function bs(a) { if (a && !(bC.indexOf(a) < 0)) return a } function bo() { return (bo = bf(I().mark((function B(b) { var c, d, f, g, i, h, j, o, r, y, l, k, s, p, t, q, v, z; return I().wrap((function (a) { for (; ;)switch (a.prev = a.next) { case 0: if (!b.optionsJSON && b.challenge && (console.warn("startRegistration() 调用方式不正确;将尝试继续使用提供的选项,但建议按照正确的调用结构重构;"), b = { optionsJSON: b }), f = (d = b).optionsJSON, g = d.useAutoRegister, i = void 0 !== g && g, H()) { a.next = 4; break } throw new Error("当前浏览器不支持 WebAuthn"); case 4: return h = A(A({}, f), {}, { challenge: G(f.challenge), user: A(A({}, f.user), {}, { id: G(f.user.id) }), excludeCredentials: null === (c = f.excludeCredentials) || void 0 === c ? void 0 : c.map(bp) }), j = {}, i && (j.mediation = "conditional"), j.publicKey = h, j.signal = br.createNewAbortSignal(), a.prev = 9, a.next = 12, navigator.credentials.create(j); case 12: o = a.sent, a.next = 18; break; case 15: throw a.prev = 15, a.t0 = a.catch(9), bA({ error: a.t0, options: j }); case 18: if (o) { a.next = 20; break } throw new Error("注册未完成"); case 20: if (y = (r = o).id, l = r.rawId, k = r.response, s = r.type, p = void 0, "function" == typeof k.getTransports && (p = k.getTransports()), t = void 0, "function" == typeof k.getPublicKeyAlgorithm) try { t = k.getPublicKeyAlgorithm() } catch (a) { X("getPublicKeyAlgorithm()", a) } if (q = void 0, "function" == typeof k.getPublicKey) try { null !== (v = k.getPublicKey()) && (q = u(v)) } catch (a) { X("getPublicKey()", a) } if ("function" == typeof k.getAuthenticatorData) try { z = u(k.getAuthenticatorData()) } catch (a) { X("getAuthenticatorData()", a) } return a.abrupt("return", { id: y, rawId: u(l), response: { attestationObject: u(k.attestationObject), clientDataJSON: u(k.clientDataJSON), transports: p, publicKeyAlgorithm: t, publicKey: q, authenticatorData: z }, type: s, clientExtensionResults: o.getClientExtensionResults(), authenticatorAttachment: bs(o.authenticatorAttachment) }); case 29: case "end": return a.stop() } }), B, null, [[9, 15]]) })))).apply(this, arguments) } function X(a, b) { console.warn("拦截此 WebAuthn API 调用的浏览器扩展错误地实现了 ".concat(a, ";请向扩展开发者报告此问题;\n"), b) } function bm() { if (!H()) return Y.stubThis(new Promise((function (b) { return b(!1) }))); var b = window.PublicKeyCredential; return void 0 === (null == b ? void 0 : b.isConditionalMediationAvailable) ? Y.stubThis(new Promise((function (a) { return a(!1) }))) : Y.stubThis(b.isConditionalMediationAvailable()) } var Y = n._browserSupportsWebAuthnAutofillInternals = { stubThis: function (a) { return a } }; function bD(a) { var b = a.error, c = a.options, d = c.publicKey; if (!d) throw Error("options was missing required publicKey property"); if ("AbortError" === b.name) { if (c.signal instanceof AbortSignal) return new m({ message: "认证流程收到了中止信号", code: "ERROR_CEREMONY_ABORTED", cause: b }) } else { if ("NotAllowedError" === b.name) return new m({ message: b.message, code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY", cause: b }); if ("SecurityError" === b.name) { var f = window.location.hostname; if (!bq(f)) return new m({ message: "".concat(window.location.hostname, " 是无效域名"), code: "ERROR_INVALID_DOMAIN", cause: b }); if (d.rpId !== f) return new m({ message: 'RP ID "'.concat(d.rpId, '" 对于当前域名无效'), code: "ERROR_INVALID_RP_ID", cause: b }) } else if ("UnknownError" === b.name) return new m({ message: "验证器无法处理指定的选项或创建新的断言签名", code: "ERROR_AUTHENTICATOR_GENERAL_ERROR", cause: b }) } return b } function bn() { return (bn = bf(I().mark((function B(b) { var c, d, f, g, i, h, j, o, r, y, l, k, s, p, t, q, v, z; return I().wrap((function (a) { for (; ;)switch (a.prev = a.next) { case 0: if (!b.optionsJSON && b.challenge && (console.warn("startAuthentication() 调用方式不正确;将尝试继续使用提供的选项,但建议按照正确的调用结构重构;"), b = { optionsJSON: b }), f = (d = b).optionsJSON, g = d.useBrowserAutofill, i = void 0 !== g && g, h = d.verifyBrowserAutofillInput, j = void 0 === h || h, H()) { a.next = 4; break } throw new Error("当前浏览器不支持 WebAuthn"); case 4: if (0 !== (null === (c = f.allowCredentials) || void 0 === c ? void 0 : c.length) && (o = null === (r = f.allowCredentials) || void 0 === r ? void 0 : r.map(bp)), y = A(A({}, f), {}, { challenge: G(f.challenge), allowCredentials: o }), l = {}, !i) { a.next = 17; break } return a.next = 10, bm(); case 10: if (a.sent) { a.next = 12; break } throw Error("当前浏览器不支持 WebAuthn 自动填充"); case 12: if (!(document.querySelectorAll("input[autocomplete$='webauthn']").length < 1 && j)) { a.next = 15; break } throw Error('未检测到任何 `autocomplete` 属性值以 "webauthn" 结尾的 <input> 元素'); case 15: l.mediation = "conditional", y.allowCredentials = []; case 17: return l.publicKey = y, l.signal = br.createNewAbortSignal(), a.prev = 19, a.next = 22, navigator.credentials.get(l); case 22: k = a.sent, a.next = 28; break; case 25: throw a.prev = 25, a.t0 = a.catch(19), bD({ error: a.t0, options: l }); case 28: if (k) { a.next = 30; break } throw new Error("认证未完成"); case 30: return p = (s = k).id, t = s.rawId, q = s.response, v = s.type, z = void 0, q.userHandle && (z = u(q.userHandle)), a.abrupt("return", { id: p, rawId: u(t), response: { authenticatorData: u(q.authenticatorData), clientDataJSON: u(q.clientDataJSON), signature: u(q.signature), userHandle: z }, type: v, clientExtensionResults: k.getClientExtensionResults(), authenticatorAttachment: bs(k.authenticatorAttachment) }); case 34: case "end": return a.stop() } }), B, null, [[19, 25]]) })))).apply(this, arguments) } }));