@flun/webauthn-browser 2.0.2

package/methods/startRegistration.js

@@ -0,0 +1,123 @@
+import {
+    bufferToBase64URLString, base64URLStringToBuffer, browserSupportsWebAuthn, identifyRegistrationError,
+    toAuthenticatorAttachment, toPublicKeyCredentialDescriptor, WebAuthnAbortService
+} from '../helpers/index.js';
+
+/**
+ * 通过 WebAuthn 证明开始认证器“注册”
+ * - 查看定义:@see {@link startRegistration}
+ *
+ * @param {Object} options - 配置选项
+ * @param {PublicKeyCredentialCreationOptionsJSON} options.optionsJSON - 来自 **@flun/webauthn-server** 的 `generateRegistrationOptions()` 的输出
+ * @param {boolean} [options.useAutoRegister] - 尝试静默使用用户刚刚登录的密码管理器创建一个通行密钥,默认为 `false`
+ * @returns {Promise<{
+ *   id: string,
+ *   rawId: string,
+ *   response: {
+ *     attestationObject: string,
+ *     clientDataJSON: string,
+ *     transports?: AuthenticatorTransport[],
+ *     publicKeyAlgorithm?: COSEAlgorithmIdentifier,
+ *     publicKey?: string,
+ *     authenticatorData?: string
+ *   },
+ *   type: PublicKeyCredentialType,
+ *   clientExtensionResults: AuthenticationExtensionsClientOutputs,
+ *   authenticatorAttachment: AuthenticatorAttachment | null
+ * }>}
+ */
+const startRegistration = async options => {
+    // 有意检查旧的调用结构，以警告不正确的 API 调用
+    if (!options.optionsJSON && options.challenge) {
+        console.warn('startRegistration() 的调用方式不正确；将继续尝试使用提供的选项,但应重构此调用以使用预期的调用结构；');
+        options = { optionsJSON: options };  // 将作为位置参数传入的 options 重新赋值给预期的变量
+    }
+
+    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()` 的选项
+
+    /**
+     * 尝试使用条件创建（conditional create）为用户注册一个通行密钥，
+     * 使用用户刚刚用于认证的密码管理器；浏览器不会向用户显示任何突出的 UI；
+     * 注意：`mediation` 在 CredentialCreationOptions 中尚不存在，但自 2024 年 9 月起已可用
+     */
+    if (useAutoRegister) createOptions.mediation = 'conditional';
+
+    createOptions.publicKey = publicKey; // 最终确定选项
+    createOptions.signal = WebAuthnAbortService.createNewAbortSignal(); // 设置取消此请求的能力（如果用户尝试另一个请求）
+
+    // 等待用户完成证明
+    let credential;
+    try {
+        credential = await navigator.credentials.create(createOptions);
+    } catch (err) {
+        throw identifyRegistrationError({ error: err, options: createOptions });
+    }
+
+    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 {
+            responsePublicKeyAlgorithm = response.getPublicKeyAlgorithm();
+        } catch (error) { warnOnBrokenImplementation('getPublicKeyAlgorithm()', error); }
+    }
+
+    let responsePublicKey = void 0;
+    if (typeof response.getPublicKey === 'function') {
+        try {
+            const _publicKey = response.getPublicKey();
+            if (_publicKey !== null) responsePublicKey = bufferToBase64URLString(_publicKey);
+        } catch (error) { warnOnBrokenImplementation('getPublicKey()', error); }
+    }
+
+    // L3 声称这是必需的，但浏览器和 WebView 的支持仍不保证
+    let responseAuthenticatorData;
+    if (typeof response.getAuthenticatorData === 'function') {
+        try {
+            responseAuthenticatorData = bufferToBase64URLString(response.getAuthenticatorData());
+        } catch (error) { warnOnBrokenImplementation('getAuthenticatorData()', error); }
+    }
+
+    return {
+        id,
+        rawId: bufferToBase64URLString(rawId),
+        response: {
+            attestationObject: bufferToBase64URLString(response.attestationObject),
+            clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
+            transports,
+            publicKeyAlgorithm: responsePublicKeyAlgorithm,
+            publicKey: responsePublicKey,
+            authenticatorData: responseAuthenticatorData,
+        },
+        type,
+        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

@@ -0,0 +1,52 @@
+{
+  "name": "@flun/webauthn-browser",
+  "version": "2.0.2",
+  "decjsion": "WebAuthn 前端库,提供简单易用的接口来处理 WebAuthn 认证流程,支持 Passkeys 和 FIDO2 标准;",
+  "keywords": [
+    "typescript",
+    "webauthn",
+    "passkeys",
+    "fido",
+    "umd"
+  ],
+  "main": "./index.js",
+  "module": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "unpkg": "dist/index.js",
+  "author": "flun <cn@flun.top>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "types": "./index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "dist/",
+    "helpers/",
+    "methods/",
+    "types/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flunGit/webauthn-browser.git"
+  },
+  "homepage": "https://www.npmjs.com/package/@flun/webauthn-browser#readme",
+  "bugs": {
+    "url": "https://github.com/flunGit/webauthn-browser/issues"
+  },
+  "license": "ISC",
+  "dependencies": {},
+  "engines": {
+    "node": ">=22.12.0",
+    "npm": ">=10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  }
+}

package/types/dom.d.ts

@@ -0,0 +1,302 @@
+/**
+ * 请勿修改这些文件！
+ *
+ * 这些文件是从 **types** 包复制而来的;要更新此文件,请修改相应包中的文件，
+ * 然后从 monorepo 根目录运行命令： deno task codegen:types
+ */
+/**
+ * 由 typescript@5.6.3 生成
+ * 要重新生成,请从包根目录运行命令： deno task extract-dom-types
+ */
+/**
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAssertionResponse)
+ */
+export interface AuthenticatorAssertionResponse extends AuthenticatorResponse {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAssertionResponse/authenticatorData) */
+    readonly authenticatorData: ArrayBuffer;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAssertionResponse/signature) */
+    readonly signature: ArrayBuffer;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAssertionResponse/userHandle) */
+    readonly userHandle: ArrayBuffer | null;
+}
+/**
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse)
+ */
+export interface AuthenticatorAttestationResponse extends AuthenticatorResponse {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse/attestationObject) */
+    readonly attestationObject: ArrayBuffer;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse/getAuthenticatorData) */
+    getAuthenticatorData(): ArrayBuffer;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse/getPublicKey) */
+    getPublicKey(): ArrayBuffer | null;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse/getPublicKeyAlgorithm) */
+    getPublicKeyAlgorithm(): COSEAlgorithmIdentifier;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorAttestationResponse/getTransports) */
+    getTransports(): string[];
+}
+export interface AuthenticationExtensionsClientInputs {
+    appid?: string, credProps?: boolean, hmacCreateSecret?: boolean, minPinLength?: boolean;
+}
+export interface AuthenticationExtensionsClientOutputs {
+    appid?: boolean, credProps?: CredentialPropertiesOutput, hmacCreateSecret?: boolean;
+}
+export interface AuthenticatorSelectionCriteria {
+    authenticatorAttachment?: AuthenticatorAttachment;
+    requireResidentKey?: boolean, residentKey?: ResidentKeyRequirement;
+    userVerification?: UserVerificationRequirement;
+}
+/**
+ * 当前上下文中可用的基本加密功能。它允许访问密码学强随机数生成器和加密原语。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto)
+ */
+export interface Crypto {
+    /**
+     * 仅在安全上下文（secure contexts）中可用。
+     *
+     * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/subtle)
+     */
+    readonly subtle: SubtleCrypto;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
+    getRandomValues<T extends ArrayBufferView | null>(array: T): T;
+    /**
+     * 仅在安全上下文（secure contexts）中可用。
+     *
+     * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
+     */
+    randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
+}
+/**
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential)
+ */
+export interface PublicKeyCredential extends Credential {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/authenticatorAttachment) */
+    readonly authenticatorAttachment: string | null;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/rawId) */
+    readonly rawId: ArrayBuffer;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/response) */
+    readonly response: AuthenticatorResponse;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/PublicKeyCredential/getClientExtensionResults) */
+    getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
+}
+export interface PublicKeyCredentialCreationOptions {
+    attestation?: AttestationConveyancePreference;
+    authenticatorSelection?: AuthenticatorSelectionCriteria, challenge: BufferSource;
+    excludeCredentials?: PublicKeyCredentialDescriptor[];
+    extensions?: AuthenticationExtensionsClientInputs;
+    pubKeyCredParams: PublicKeyCredentialParameters[];
+    rp: PublicKeyCredentialRpEntity;
+    timeout?: number, user: PublicKeyCredentialUserEntity;
+}
+export interface PublicKeyCredentialDescriptor {
+    id: BufferSource, transports?: AuthenticatorTransport[], type: PublicKeyCredentialType;
+}
+export interface PublicKeyCredentialParameters {
+    alg: COSEAlgorithmIdentifier, type: PublicKeyCredentialType;
+}
+export interface PublicKeyCredentialRequestOptions {
+    allowCredentials?: PublicKeyCredentialDescriptor[];
+    challenge: BufferSource;
+    extensions?: AuthenticationExtensionsClientInputs;
+    rpId?: string, timeout?: number;
+    userVerification?: UserVerificationRequirement;
+}
+export interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
+    displayName: string, id: BufferSource;
+}
+/**
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorResponse)
+ */
+export interface AuthenticatorResponse {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/AuthenticatorResponse/clientDataJSON) */
+    readonly clientDataJSON: ArrayBuffer;
+}
+export interface CredentialPropertiesOutput {
+    rk?: boolean;
+}
+/**
+ * 此 Web Crypto API 接口提供了一系列低级加密函数;可通过窗口上下文中的 Crypto.subtle 属性访问（通过 Window.crypto）;
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto)
+ */
+export interface SubtleCrypto {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt) */
+    decrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey,
+        data: BufferSource): Promise<ArrayBuffer>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits) */
+    deriveBits(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey,
+        length: number): Promise<ArrayBuffer>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */
+    deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey,
+        derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params,
+        extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest) */
+    digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/encrypt) */
+    encrypt(algorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, key: CryptoKey,
+        data: BufferSource): Promise<ArrayBuffer>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/exportKey) */
+    exportKey(format: "jwk", key: CryptoKey): Promise<JsonWebKey>;
+    exportKey(format: Exclude<KeyFormat, "jwk">, key: CryptoKey): Promise<ArrayBuffer>;
+    exportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey) */
+    generateKey(algorithm: "Ed25519", extractable: boolean, keyUsages: ReadonlyArray<"sign" | "verify">):
+        Promise<CryptoKeyPair>;
+    generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean,
+        keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;
+    generateKey(algorithm: AesKeyGenParams | HmacKeyGenParams | Pbkdf2Params, extractable: boolean,
+        keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKey>;
+    generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]):
+        Promise<CryptoKeyPair | CryptoKey>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey) */
+    importKey(format: "jwk", keyData: JsonWebKey, algorithm: AlgorithmIdentifier | RsaHashedImportParams |
+        EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>)
+        : Promise<CryptoKey>;
+    importKey(format: Exclude<KeyFormat, "jwk">, keyData: BufferSource, algorithm: AlgorithmIdentifier |
+        RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean,
+        keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/sign) */
+    sign(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, data: BufferSource):
+        Promise<ArrayBuffer>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey) */
+    unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier
+        | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier
+            | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean,
+        keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/verify) */
+    verify(algorithm: AlgorithmIdentifier | RsaPssParams | EcdsaParams, key: CryptoKey, signature: BufferSource,
+        data: BufferSource): Promise<boolean>;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey) */
+    wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier |
+        RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams): Promise<ArrayBuffer>;
+}
+/**
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/Credential)
+ */
+export interface Credential {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/Credential/id) */
+    readonly id: string;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/Credential/type) */
+    readonly type: string;
+}
+export interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
+    id?: string;
+}
+export interface PublicKeyCredentialEntity {
+    name: string;
+}
+export interface RsaOaepParams extends Algorithm {
+    label?: BufferSource;
+}
+export interface AesCtrParams extends Algorithm {
+    counter: BufferSource, length: number;
+}
+export interface AesCbcParams extends Algorithm {
+    iv: BufferSource;
+}
+export interface AesGcmParams extends Algorithm {
+    additionalData?: BufferSource, iv: BufferSource, tagLength?: number;
+}
+/**
+ * Web Crypto API 的 CryptoKey 字典表示一个加密密钥。
+ * 仅在安全上下文（secure contexts）中可用。
+ *
+ * [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey)
+ */
+export interface CryptoKey {
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm) */
+    readonly algorithm: KeyAlgorithm;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable) */
+    readonly extractable: boolean;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey/type) */
+    readonly type: KeyType;
+    /** [MDN 参考](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages) */
+    readonly usages: KeyUsage[];
+}
+export interface EcdhKeyDeriveParams extends Algorithm {
+    public: CryptoKey;
+}
+export interface HkdfParams extends Algorithm {
+    hash: HashAlgorithmIdentifier, info: BufferSource, salt: BufferSource;
+}
+export interface Pbkdf2Params extends Algorithm {
+    hash: HashAlgorithmIdentifier, iterations: number, salt: BufferSource;
+}
+export interface AesDerivedKeyParams extends Algorithm {
+    length: number;
+}
+export interface HmacImportParams extends Algorithm {
+    hash: HashAlgorithmIdentifier, length?: number;
+}
+export interface JsonWebKey {
+    alg?: string, crv?: string, d?: string, dp?: string, dq?: string, e?: string, ext?: boolean, k?: string;
+    key_ops?: string[], kty?: string, n?: string, oth?: RsaOtherPrimesInfo[], p?: string, q?: string;
+    qi?: string, use?: string, x?: string, y?: string;
+}
+export interface CryptoKeyPair {
+    privateKey: CryptoKey, publicKey: CryptoKey;
+}
+export interface RsaHashedKeyGenParams extends RsaKeyGenParams {
+    hash: HashAlgorithmIdentifier;
+}
+export interface EcKeyGenParams extends Algorithm {
+    namedCurve: NamedCurve;
+}
+export interface AesKeyGenParams extends Algorithm {
+    length: number;
+}
+export interface HmacKeyGenParams extends Algorithm {
+    hash: HashAlgorithmIdentifier;
+    length?: number;
+}
+export interface RsaHashedImportParams extends Algorithm {
+    hash: HashAlgorithmIdentifier;
+}
+export interface EcKeyImportParams extends Algorithm {
+    namedCurve: NamedCurve;
+}
+export interface AesKeyAlgorithm extends KeyAlgorithm {
+    length: number;
+}
+export interface RsaPssParams extends Algorithm {
+    saltLength: number;
+}
+export interface EcdsaParams extends Algorithm {
+    hash: HashAlgorithmIdentifier;
+}
+export interface Algorithm {
+    name: string;
+}
+export interface KeyAlgorithm {
+    name: string;
+}
+export interface RsaOtherPrimesInfo { d?: string, r?: string, t?: string; }
+export interface RsaKeyGenParams extends Algorithm {
+    modulusLength: number, publicExponent: BigInteger;
+}
+export type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
+export type AuthenticatorTransport = "ble" | "hybrid" | "internal" | "nfc" | "usb";
+export type COSEAlgorithmIdentifier = number;
+export type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
+export type UserVerificationRequirement = "discouraged" | "preferred" | "required";
+export type AuthenticatorAttachment = "cross-platform" | "platform";
+export type BufferSource = ArrayBufferView | ArrayBuffer;
+export type PublicKeyCredentialType = "public-key";
+export type AlgorithmIdentifier = Algorithm | string;
+export type KeyUsage = "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey";
+export type KeyFormat = "jwk" | "pkcs8" | "raw" | "spki";
+export type KeyType = "private" | "public" | "secret";
+export type HashAlgorithmIdentifier = AlgorithmIdentifier;
+export type NamedCurve = string;
+export type BigInteger = Uint8Array;