akey-electron-webauthn-macos 1.3.10

package/dist/index.js

@@ -0,0 +1,3587 @@
+// src/helpers/index.ts
+function PromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function bufferToBase64Url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0;i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBuffer(b64url) {
+  if (typeof b64url !== "string")
+    throw new TypeError("base64Url must be a string");
+  let b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = b64.length % 4;
+  if (pad === 2)
+    b64 += "==";
+  else if (pad === 3)
+    b64 += "=";
+  else if (pad !== 0)
+    throw new Error("Invalid base64url length");
+  return Buffer.from(b64, "base64");
+}
+function bufferSourceToBuffer(src) {
+  if (!src)
+    return null;
+  if (Buffer.isBuffer(src))
+    return src;
+  if (src instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && src instanceof SharedArrayBuffer) {
+    return Buffer.from(src);
+  }
+  if (ArrayBuffer.isView(src)) {
+    return Buffer.from(src.buffer, src.byteOffset, src.byteLength);
+  }
+  return null;
+}
+
+// src/helpers/rpid.ts
+import net from "node:net";
+import { domainToASCII } from "node:url";
+function isRpIdAllowedForOrigin(origin, rpIdInput, opts = {}) {
+  const allowInsecureLocalhost = opts.allowInsecureLocalhost ?? true;
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return { ok: false, rpId: normalizeRpId(rpIdInput ?? ""), reason: "Invalid origin URL" };
+  }
+  const scheme = url.protocol.toLowerCase();
+  const originHost = normalizeHost(url.hostname);
+  if (!originHost)
+    return { ok: false, rpId: normalizeRpId(rpIdInput ?? ""), reason: "Origin has no hostname" };
+  const originIsIP = net.isIP(originHost) !== 0;
+  const originIsLocalhost = originHost === "localhost" || originIsIP;
+  const secureEnough = scheme === "https:" || scheme === "wss:" || allowInsecureLocalhost && scheme === "http:" && originIsLocalhost;
+  if (!secureEnough) {
+    return { ok: false, rpId: normalizeRpId(rpIdInput ?? originHost), reason: "Origin is not a secure context" };
+  }
+  const rpId = normalizeRpId(rpIdInput ?? originHost);
+  if (!rpId)
+    return { ok: false, rpId, reason: "rpId is empty" };
+  if (/[/:@]/.test(rpId)) {
+    return { ok: false, rpId, reason: "rpId must be a hostname only (no scheme/port/path/userinfo)" };
+  }
+  const rpIdIsIP = net.isIP(rpId) !== 0;
+  if (originIsIP) {
+    if (rpId !== originHost) {
+      return { ok: false, rpId, reason: "For IP origins, rpId must exactly match the IP" };
+    }
+    return { ok: true, rpId };
+  }
+  if (rpIdIsIP) {
+    return { ok: false, rpId, reason: "rpId cannot be an IP if origin host is a domain" };
+  }
+  if (!(rpId === originHost || originHost.endsWith("." + rpId))) {
+    return { ok: false, rpId, reason: "rpId is not equal to or a suffix of the origin hostname" };
+  }
+  if (opts.isPublicSuffix) {
+    if (opts.isPublicSuffix(rpId)) {
+      return { ok: false, rpId, reason: "rpId is a public suffix (eTLD), which is not allowed" };
+    }
+  } else {
+    if (!rpId.includes(".") && rpId !== "localhost") {
+      return { ok: false, rpId, reason: "rpId looks like a public suffix/single-label domain (no PSL check provided)" };
+    }
+  }
+  return { ok: true, rpId };
+}
+function normalizeHost(hostname) {
+  const h = (hostname ?? "").trim().toLowerCase().replace(/\.$/, "");
+  return domainToASCII(h) || "";
+}
+function normalizeRpId(rpId) {
+  return normalizeHost(rpId);
+}
+
+// src/helpers/validation.ts
+function isString(value) {
+  return value && typeof value === "string";
+}
+function isNumber(value) {
+  return value && typeof value === "number";
+}
+function isObject(value) {
+  return value && typeof value === "object";
+}
+
+// src/get/authorization-controller.ts
+import { NobjcClass, getPointer } from "objc-js";
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/Foundation/index.js
+import { NobjcLibrary } from "objc-js";
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/bind.js
+var _kindCache = new WeakMap;
+function _isKindOfClass(obj, cls) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let m = _kindCache.get(obj);
+  if (m) {
+    const v = m.get(cls);
+    if (v !== undefined)
+      return v;
+  }
+  try {
+    if (!m) {
+      m = new Map;
+      _kindCache.set(obj, m);
+    }
+    const r = obj.isKindOfClass$(cls);
+    m.set(cls, r);
+    return r;
+  } catch {
+    return false;
+  }
+}
+function _bindClass(lib, name) {
+  const cls = lib[name];
+  if (!cls) {
+    return;
+  }
+  Object.defineProperty(cls, Symbol.hasInstance, {
+    value: (obj) => _isKindOfClass(obj, cls)
+  });
+  return cls;
+}
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/Foundation/index.js
+var Foundation = /* @__PURE__ */ new NobjcLibrary("/System/Library/Frameworks/Foundation.framework/Foundation");
+var NSArray = /* @__PURE__ */ _bindClass(Foundation, "NSArray");
+var NSData = /* @__PURE__ */ _bindClass(Foundation, "NSData");
+var NSDictionary = /* @__PURE__ */ _bindClass(Foundation, "NSDictionary");
+var NSNumber = /* @__PURE__ */ _bindClass(Foundation, "NSNumber");
+var NSProcessInfo = /* @__PURE__ */ _bindClass(Foundation, "NSProcessInfo");
+var NSString = /* @__PURE__ */ _bindClass(Foundation, "NSString");
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/helpers.js
+function NSStringFromString(str) {
+  const nsString = NSString.stringWithUTF8String$(str);
+  if (!nsString) {
+    throw new Error(`Failed to create NSString from string: ${str}`);
+  }
+  return nsString;
+}
+function NSArrayFromObjects(objects) {
+  if (objects.length === 0) {
+    return NSArray.array();
+  }
+  let array = NSArray.arrayWithObject$(objects[0]);
+  for (let i = 1;i < objects.length; i++) {
+    array = array.arrayByAddingObject$(objects[i]);
+  }
+  return array;
+}
+function NSDictionaryFromKeysAndValues(keys, values) {
+  if (keys.length !== values.length) {
+    throw new Error("Keys and values arrays must have the same length");
+  }
+  const keysArray = NSArrayFromObjects(keys);
+  const valuesArray = NSArrayFromObjects(values);
+  return NSDictionary.dictionaryWithObjects$forKeys$(valuesArray, keysArray);
+}
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/nsdata.js
+function NSDataFromBuffer(buffer) {
+  return NSData.dataWithBytes$length$(buffer, buffer.length);
+}
+function bufferFromNSDataDirect(data) {
+  const nsData = data;
+  const length = nsData.length();
+  if (length === 0) {
+    return Buffer.alloc(0);
+  }
+  const buffer = Buffer.alloc(length);
+  nsData.getBytes$length$(buffer, length);
+  return buffer;
+}
+
+// src/get/authorization-controller.ts
+var getControllerState = new Map;
+function getObjectPointerString(self) {
+  return getPointer(self).toString("base64");
+}
+function setClientDataHash(self, clientDataHash) {
+  const selfPointer = getObjectPointerString(self);
+  getControllerState.set(selfPointer, clientDataHash);
+}
+function removeClientDataHash(self) {
+  const selfPointer = getObjectPointerString(self);
+  getControllerState.delete(selfPointer);
+}
+var WebauthnGetController = NobjcClass.define({
+  name: "WebauthnGetController",
+  superclass: "ASAuthorizationController",
+  methods: {
+    _requestContextWithRequests$error$: {
+      types: "@@:@^@",
+      implementation: (self, requests, outError) => {
+        const context = NobjcClass.super(self, "_requestContextWithRequests$error$", requests, outError);
+        const selfPointer = getObjectPointerString(self);
+        if (getControllerState.has(selfPointer)) {
+          let assertionOptions = context.platformKeyCredentialAssertionOptions();
+          if (!assertionOptions) {
+            assertionOptions = context.securityKeyCredentialAssertionOptions();
+          }
+          const clientDataHash = getControllerState.get(selfPointer);
+          assertionOptions.setClientDataHash$(NSDataFromBuffer(clientDataHash));
+          context.setPlatformKeyCredentialAssertionOptions$(assertionOptions.copyWithZone$(null));
+        }
+        return context;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/index.js
+import { NobjcLibrary as NobjcLibrary2 } from "objc-js";
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationPublicKeyCredentialAttachment.js
+var ASAuthorizationPublicKeyCredentialAttachment = {
+  Platform: 0,
+  CrossPlatform: 1
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationPublicKeyCredentialLargeBlobAssertionOperation.js
+var ASAuthorizationPublicKeyCredentialLargeBlobAssertionOperation = {
+  Read: 0,
+  Write: 1
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationPublicKeyCredentialLargeBlobSupportRequirement.js
+var ASAuthorizationPublicKeyCredentialLargeBlobSupportRequirement = {
+  Required: 0,
+  Preferred: 1
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState.js
+var ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState = {
+  Authorized: 0,
+  Denied: 1,
+  NotDetermined: 2
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationPublicKeyCredentialAttestationKind.js
+var ASAuthorizationPublicKeyCredentialAttestationKind = {
+  None: "none",
+  Direct: "direct",
+  Indirect: "indirect",
+  Enterprise: "enterprise"
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/ASAuthorizationPublicKeyCredentialUserVerificationPreference.js
+var ASAuthorizationPublicKeyCredentialUserVerificationPreference = {
+  Preferred: "preferred",
+  Required: "required",
+  Discouraged: "discouraged"
+};
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/index.js
+var AuthenticationServices = /* @__PURE__ */ new NobjcLibrary2("/System/Library/Frameworks/AuthenticationServices.framework/AuthenticationServices");
+var ASAuthorizationPlatformPublicKeyCredentialAssertion = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPlatformPublicKeyCredentialAssertion");
+var ASAuthorizationPlatformPublicKeyCredentialDescriptor = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPlatformPublicKeyCredentialDescriptor");
+var ASAuthorizationPlatformPublicKeyCredentialProvider = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPlatformPublicKeyCredentialProvider");
+var ASAuthorizationPlatformPublicKeyCredentialRegistration = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPlatformPublicKeyCredentialRegistration");
+var ASAuthorizationPublicKeyCredentialLargeBlobAssertionInput = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialLargeBlobAssertionInput");
+var ASAuthorizationPublicKeyCredentialLargeBlobRegistrationInput = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialLargeBlobRegistrationInput");
+var ASAuthorizationPublicKeyCredentialPRFAssertionInput = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialPRFAssertionInput");
+var ASAuthorizationPublicKeyCredentialPRFAssertionInputValues = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialPRFAssertionInputValues");
+var ASAuthorizationPublicKeyCredentialPRFRegistrationInput = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialPRFRegistrationInput");
+var ASAuthorizationPublicKeyCredentialParameters = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationPublicKeyCredentialParameters");
+var ASAuthorizationSecurityKeyPublicKeyCredentialAssertion = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationSecurityKeyPublicKeyCredentialAssertion");
+var ASAuthorizationSecurityKeyPublicKeyCredentialProvider = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationSecurityKeyPublicKeyCredentialProvider");
+var ASAuthorizationSecurityKeyPublicKeyCredentialRegistration = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationSecurityKeyPublicKeyCredentialRegistration");
+var ASAuthorizationWebBrowserPublicKeyCredentialManager = /* @__PURE__ */ _bindClass(AuthenticationServices, "ASAuthorizationWebBrowserPublicKeyCredentialManager");
+
+// src/helpers/prf.ts
+function createPRFInput(prf) {
+  return ASAuthorizationPublicKeyCredentialPRFAssertionInputValues.alloc().initWithSaltInput1$saltInput2$(NSDataFromBuffer(prf.first), prf.second ? NSDataFromBuffer(prf.second) : null);
+}
+
+// src/helpers/client-data.ts
+import { createHash } from "crypto";
+
+// src/helpers/origin.ts
+function serializeOrigin(origin) {
+  if (origin === "null" || !origin) {
+    return null;
+  }
+  try {
+    const url = new URL(origin);
+    let result = url.protocol;
+    if (!result.endsWith("://")) {
+      result = result.replace(/:$/, "") + "://";
+    }
+    result += url.hostname;
+    if (url.port) {
+      result += ":" + url.port;
+    }
+    return result;
+  } catch (error) {
+    return null;
+  }
+}
+var DEFAULT_PORT = {
+  http: 80,
+  https: 443,
+  ws: 80,
+  wss: 443,
+  ftp: 21
+};
+var TUPLE_SCHEMES = new Set(["http", "https", "ws", "wss", "ftp"]);
+function computeOrigin(input) {
+  if (typeof input === "string" && input.trim().toLowerCase() === "null") {
+    return { type: "opaque", reason: "explicit 'null' origin string" };
+  }
+  const url = toURL(input);
+  if (!url)
+    return { type: "opaque", reason: "unparseable URL/origin string" };
+  const scheme = url.protocol.replace(/:$/, "").toLowerCase();
+  if (scheme === "blob") {
+    const embedded = url.href.slice("blob:".length);
+    const embeddedUrl = toURL(embedded);
+    return embeddedUrl ? computeOrigin(embeddedUrl) : { type: "opaque", reason: "blob: with unparseable embedded URL" };
+  }
+  if (!TUPLE_SCHEMES.has(scheme)) {
+    return { type: "opaque", reason: `non-tuple scheme '${scheme}'` };
+  }
+  const host = url.hostname;
+  if (!host)
+    return { type: "opaque", reason: "missing hostname" };
+  const rawPort = url.port ? safeParsePort(url.port) : null;
+  const port = normalizePort(scheme, rawPort);
+  return { type: "tuple", scheme, host, port };
+}
+function normalizePort(scheme, port) {
+  if (port == null)
+    return null;
+  const def = DEFAULT_PORT[scheme];
+  if (def != null && port === def)
+    return null;
+  return port;
+}
+function safeParsePort(portStr) {
+  const n = Number(portStr);
+  if (!Number.isInteger(n) || n < 0 || n > 65535)
+    return null;
+  return n;
+}
+function toURL(input) {
+  if (input instanceof URL)
+    return input;
+  try {
+    return new URL(input);
+  } catch {
+    return null;
+  }
+}
+function isSameOrigin(a, b, opts = {}) {
+  const oa = computeOrigin(a);
+  const ob = computeOrigin(b);
+  if (oa.type === "tuple" && ob.type === "tuple") {
+    return oa.scheme === ob.scheme && oa.host === ob.host && oa.port === ob.port;
+  }
+  if (opts.allowOpaqueStringEquality) {
+    const sa = originString(a);
+    const sb = originString(b);
+    return sa != null && sb != null && sa === sb;
+  }
+  return false;
+}
+function originString(x) {
+  if (typeof x === "string") {
+    return serializeOrigin(x);
+  }
+  const url = toURL(x);
+  if (!url) {
+    return null;
+  }
+  const o = computeOrigin(url);
+  if (o.type === "opaque")
+    return null;
+  return `${o.scheme}://${o.host}${o.port == null ? "" : `:${o.port}`}`;
+}
+
+// src/helpers/client-data.ts
+function generateWebauthnClientData(type, origin, challenge, topFrameOrigin) {
+  const serializedOrigin = serializeOrigin(origin);
+  const clientData = {
+    type,
+    challenge: bufferToBase64Url(challenge),
+    origin: serializedOrigin,
+    crossOrigin: false
+  };
+  if (topFrameOrigin) {
+    const sameOrigin = isSameOrigin(origin, topFrameOrigin);
+    if (!sameOrigin) {
+      const serializedTopFrameOrigin = serializeOrigin(topFrameOrigin);
+      clientData.topOrigin = serializedTopFrameOrigin;
+      clientData.crossOrigin = true;
+    }
+  }
+  return clientData;
+}
+function clientDataJsonBufferToHash(clientDataJSON) {
+  if (!Buffer.isBuffer(clientDataJSON)) {
+    throw new TypeError("clientDataJsonBufferToHash: clientDataJSON must be a Buffer");
+  }
+  if (clientDataJSON.length === 0) {
+    throw new RangeError("clientDataJsonBufferToHash: clientDataJSON is empty");
+  }
+  return createHash("sha256").update(clientDataJSON).digest();
+}
+function generateClientDataInfo(clientData) {
+  const clientDataJSON = JSON.stringify(clientData);
+  const clientDataBuffer = Buffer.from(clientDataJSON, "utf-8");
+  const clientDataHash = clientDataJsonBufferToHash(clientDataBuffer);
+  return { clientDataJSON, clientDataBuffer, clientDataHash };
+}
+
+// src/helpers/presentation.ts
+import { fromPointer } from "objc-js";
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/delegates.js
+import { NobjcProtocol } from "objc-js";
+function createDelegate(protocolName, methods) {
+  return NobjcProtocol.implement(protocolName, methods);
+}
+// src/helpers/presentation.ts
+function createPresentationContextProviderFromNativeWindowHandle(nativeWindowHandle) {
+  return createDelegate("ASAuthorizationControllerPresentationContextProviding", {
+    presentationAnchorForAuthorizationController$: () => {
+      const nsView = fromPointer(nativeWindowHandle);
+      const nsWindow = nsView.window();
+      return nsWindow;
+    }
+  });
+}
+
+// src/get/internal-handler.ts
+function setupPublicKeyCredentialRequest(type, keyRequest, userVerificationPreference, enabledExtensions, allowedCredentialIds, additionalOptions) {
+  if (userVerificationPreference === "preferred") {
+    keyRequest.setUserVerificationPreference$(NSStringFromString("preferred"));
+  } else if (userVerificationPreference === "required") {
+    keyRequest.setUserVerificationPreference$(NSStringFromString("required"));
+  } else if (userVerificationPreference === "discouraged") {
+    keyRequest.setUserVerificationPreference$(NSStringFromString("discouraged"));
+  }
+  if (type === "platform") {
+    const largeBlobRead = enabledExtensions.includes("largeBlobRead");
+    const largeBlobWrite = enabledExtensions.includes("largeBlobWrite");
+    if (largeBlobRead) {
+      const operation = ASAuthorizationPublicKeyCredentialLargeBlobAssertionOperation.Read;
+      const largeBlobInput = ASAuthorizationPublicKeyCredentialLargeBlobAssertionInput.alloc().initWithOperation$(operation);
+      keyRequest.setLargeBlob$(largeBlobInput);
+    } else if (largeBlobWrite) {
+      if (additionalOptions.largeBlobDataToWrite) {
+        const operation = ASAuthorizationPublicKeyCredentialLargeBlobAssertionOperation.Write;
+        const largeBlobInput = ASAuthorizationPublicKeyCredentialLargeBlobAssertionInput.alloc().initWithOperation$(operation);
+        largeBlobInput.setDataToWrite$(NSDataFromBuffer(additionalOptions.largeBlobDataToWrite));
+        keyRequest.setLargeBlob$(largeBlobInput);
+      } else {
+        console.warn("[electron-webauthn] largeBlobWrite is enabled but largeBlobDataToWrite is not provided, skipping large blob write");
+      }
+    }
+  }
+  if (type === "platform" && enabledExtensions.includes("prf")) {
+    if (additionalOptions.prf || additionalOptions.prfByCredential) {
+      let inputValues = null;
+      if (additionalOptions.prf) {
+        inputValues = createPRFInput(additionalOptions.prf);
+      }
+      let perCredentialInputValues = null;
+      if (additionalOptions.prfByCredential && allowedCredentialIds.length > 0) {
+        const keys = [];
+        const values = [];
+        for (const [credentialId, prfInput2] of Object.entries(additionalOptions.prfByCredential)) {
+          const credentialIdBuffer = base64UrlToBuffer(credentialId);
+          const credentialIdData = NSDataFromBuffer(credentialIdBuffer);
+          keys.push(credentialIdData);
+          values.push(createPRFInput(prfInput2));
+        }
+        perCredentialInputValues = NSDictionaryFromKeysAndValues(keys, values);
+      }
+      const prfInput = ASAuthorizationPublicKeyCredentialPRFAssertionInput.alloc().initWithInputValues$perCredentialInputValues$(inputValues, perCredentialInputValues);
+      keyRequest.setPrf$(prfInput);
+    } else {
+      console.warn("[electron-webauthn] prf is enabled but prf or prfByCredential is not provided, skipping PRF");
+    }
+  }
+}
+function getCredentialInternal(rpid, challenge, nativeWindowHandle, origin, timeout, enabledExtensions = [], allowedCredentialIds, userVerificationPreference, additionalOptions = {}) {
+  const { promise, resolve, reject } = PromiseWithResolvers();
+  const NS_rpID = NSStringFromString(rpid);
+  const NS_challenge = NSDataFromBuffer(challenge);
+  const platformProvider = ASAuthorizationPlatformPublicKeyCredentialProvider.alloc().initWithRelyingPartyIdentifier$(NS_rpID);
+  const platformKeyRequest = platformProvider.createCredentialAssertionRequestWithChallenge$(NS_challenge);
+  setupPublicKeyCredentialRequest("platform", platformKeyRequest, userVerificationPreference, enabledExtensions, allowedCredentialIds, additionalOptions);
+  const requestArrayInput = [platformKeyRequest];
+  if (additionalOptions.allowSecurityKeyRequests) {
+    const securityKeyProvider = ASAuthorizationSecurityKeyPublicKeyCredentialProvider.alloc().initWithRelyingPartyIdentifier$(NS_rpID);
+    const securityKeyRequest = securityKeyProvider.createCredentialAssertionRequestWithChallenge$(NS_challenge);
+    setupPublicKeyCredentialRequest("security-key", securityKeyRequest, userVerificationPreference, enabledExtensions, allowedCredentialIds, additionalOptions);
+    requestArrayInput.push(securityKeyRequest);
+  }
+  const requestsArray = NSArrayFromObjects(requestArrayInput);
+  const authController = WebauthnGetController.alloc().initWithAuthorizationRequests$(requestsArray);
+  const clientData = generateWebauthnClientData("webauthn.get", origin, challenge, additionalOptions.topFrameOrigin);
+  const { clientDataHash, clientDataBuffer } = generateClientDataInfo(clientData);
+  setClientDataHash(authController, clientDataHash);
+  let isFinished = false;
+  let timeoutHandlerId = null;
+  const finished = (_success) => {
+    isFinished = true;
+    removeClientDataHash(authController);
+    if (timeoutHandlerId) {
+      clearTimeout(timeoutHandlerId);
+      timeoutHandlerId = null;
+    }
+  };
+  if (allowedCredentialIds.length > 0) {
+    const allowedCredentials = NSArrayFromObjects(allowedCredentialIds.map((id) => ASAuthorizationPlatformPublicKeyCredentialDescriptor.alloc().initWithCredentialID$(NSDataFromBuffer(id))));
+    platformKeyRequest.setAllowedCredentials$(allowedCredentials);
+  }
+  const delegate = createDelegate("ASAuthorizationControllerDelegate", {
+    authorizationController$didCompleteWithAuthorization$: (_, authorization) => {
+      const credential = authorization.credential();
+      const isPlatform = credential instanceof ASAuthorizationPlatformPublicKeyCredentialAssertion;
+      const isSecurityKey = credential instanceof ASAuthorizationSecurityKeyPublicKeyCredentialAssertion;
+      if (!isPlatform && !isSecurityKey) {
+        reject(new Error("Resulting credential is not a platform or security key credential"));
+        finished(false);
+        return;
+      }
+      const id_data = credential.credentialID();
+      const id = bufferFromNSDataDirect(id_data);
+      let authenticatorAttachment = "cross-platform";
+      if (isPlatform && credential.attachment() === ASAuthorizationPublicKeyCredentialAttachment.Platform) {
+        authenticatorAttachment = "platform";
+      }
+      const prf = credential.prf();
+      const prfFirst = prf?.first ? prf.first() : null;
+      const prfSecond = prf?.second ? prf.second() : null;
+      let largeBlobBuffer = null;
+      let largeBlobWritten = null;
+      if (credential.largeBlob()) {
+        const largeBlobData = credential.largeBlob().readData();
+        if (largeBlobData) {
+          largeBlobBuffer = bufferFromNSDataDirect(largeBlobData);
+        } else {
+          largeBlobWritten = credential.largeBlob().didWrite();
+        }
+      }
+      resolve({
+        id,
+        authenticatorAttachment,
+        clientDataJSON: clientDataBuffer,
+        authenticatorData: bufferFromNSDataDirect(credential.rawAuthenticatorData()),
+        signature: bufferFromNSDataDirect(credential.signature()),
+        userHandle: bufferFromNSDataDirect(credential.userID()),
+        prf: [
+          prfFirst ? bufferFromNSDataDirect(prfFirst) : null,
+          prfSecond ? bufferFromNSDataDirect(prfSecond) : null
+        ],
+        largeBlob: largeBlobBuffer,
+        largeBlobWritten
+      });
+      finished(true);
+    },
+    authorizationController$didCompleteWithError$: (_, error) => {
+      const errorMessage = error.localizedDescription().UTF8String();
+      reject(new Error(errorMessage));
+      finished(false);
+    }
+  });
+  authController.setDelegate$(delegate);
+  const presentationContextProvider = createPresentationContextProviderFromNativeWindowHandle(nativeWindowHandle);
+  authController.setPresentationContextProvider$(presentationContextProvider);
+  authController.performRequests();
+  timeoutHandlerId = setTimeout(() => {
+    if (isFinished)
+      return;
+    authController.cancel();
+  }, timeout);
+  return promise;
+}
+
+// src/get/handler.ts
+function getExtensionsConfiguration(extensionsData) {
+  if (!(extensionsData && typeof extensionsData === "object")) {
+    return {
+      extensions: []
+    };
+  }
+  const extensions = [];
+  let largeBlobWriteBuffer;
+  if (extensionsData.largeBlob) {
+    const largeBlobConfig = extensionsData.largeBlob;
+    if (largeBlobConfig.read) {
+      extensions.push("largeBlobRead");
+    }
+    if (largeBlobConfig.write) {
+      extensions.push("largeBlobWrite");
+      largeBlobWriteBuffer = bufferSourceToBuffer(largeBlobConfig.write);
+    }
+  }
+  let prf;
+  let prfByCredential;
+  const prfExtension = extensionsData.prf;
+  if (prfExtension && (prfExtension.eval || prfExtension.evalByCredential)) {
+    extensions.push("prf");
+    if (prfExtension.eval) {
+      prf = {
+        first: bufferSourceToBuffer(prfExtension.eval.first),
+        second: prfExtension.eval.second ? bufferSourceToBuffer(prfExtension.eval.second) : undefined
+      };
+    }
+    if (prfExtension.evalByCredential) {
+      prfByCredential = {};
+      for (const [credId, value] of Object.entries(prfExtension.evalByCredential)) {
+        prfByCredential[credId] = {
+          first: bufferSourceToBuffer(value.first),
+          second: value.second ? bufferSourceToBuffer(value.second) : undefined
+        };
+      }
+    }
+  }
+  return {
+    extensions,
+    largeBlobWriteBuffer,
+    prf,
+    prfByCredential
+  };
+}
+async function getCredential(publicKeyOptions, additionalOptions) {
+  if (!publicKeyOptions) {
+    return null;
+  }
+  const rpId = publicKeyOptions.rpId;
+  if (!isString(rpId)) {
+    return { success: false, error: "TypeError" };
+  }
+  let timeout = publicKeyOptions.timeout;
+  if (!isNumber(timeout) || timeout <= 0) {
+    timeout = 10 * 60 * 1000;
+  } else if (timeout > 60 * 60 * 1000) {
+    timeout = 60 * 60 * 1000;
+  }
+  const challenge = bufferSourceToBuffer(publicKeyOptions.challenge);
+  if (!challenge) {
+    return { success: false, error: "TypeError" };
+  }
+  const userVerification = publicKeyOptions.userVerification;
+  if (userVerification && !isString(userVerification)) {
+    return { success: false, error: "TypeError" };
+  }
+  const allowedCredentialsArray = [];
+  const allowedCredentials = publicKeyOptions.allowCredentials;
+  if (allowedCredentials && Array.isArray(allowedCredentials)) {
+    for (const allowedCredential of allowedCredentials) {
+      if (!(allowedCredential && typeof allowedCredential === "object"))
+        continue;
+      if (allowedCredential.type !== "public-key")
+        continue;
+      const id = bufferSourceToBuffer(allowedCredential.id);
+      if (!id)
+        continue;
+      allowedCredentialsArray.push(id);
+    }
+  }
+  const {
+    extensions: enabledExtensions,
+    largeBlobWriteBuffer,
+    prf,
+    prfByCredential
+  } = getExtensionsConfiguration(publicKeyOptions.extensions);
+  const { currentOrigin, topFrameOrigin, isPublicSuffix, nativeWindowHandle } = additionalOptions;
+  const isRpIdAllowed = isRpIdAllowedForOrigin(currentOrigin, rpId, {
+    isPublicSuffix
+  });
+  if (!isRpIdAllowed.ok) {
+    return { success: false, error: "NotAllowedError" };
+  }
+  let errorResult = null;
+  const result = await getCredentialInternal(rpId, challenge, nativeWindowHandle, currentOrigin, timeout, enabledExtensions, allowedCredentialsArray, userVerification, {
+    allowSecurityKeyRequests: additionalOptions.allowSecurityKeyRequests ?? false,
+    topFrameOrigin,
+    largeBlobDataToWrite: largeBlobWriteBuffer,
+    prf,
+    prfByCredential
+  }).catch((error) => {
+    errorResult = error;
+    if (error.message.startsWith("The operation couldn’t be completed.")) {
+      return "NotAllowedError";
+    }
+    return "NotAllowedError";
+  });
+  if (typeof result === "string") {
+    return { success: false, error: result, errorObject: errorResult };
+  }
+  const data = {
+    credentialId: bufferToBase64Url(result.id),
+    clientDataJSON: bufferToBase64Url(result.clientDataJSON),
+    authenticatorData: bufferToBase64Url(result.authenticatorData),
+    signature: bufferToBase64Url(result.signature),
+    userHandle: bufferToBase64Url(result.userHandle),
+    extensions: {}
+  };
+  if (result.prf && (result.prf[0] || result.prf[1])) {
+    data.extensions.prf = {
+      results: {
+        first: bufferToBase64Url(result.prf[0]),
+        second: result.prf[1] ? bufferToBase64Url(result.prf[1]) : undefined
+      }
+    };
+  }
+  if (result.largeBlob || result.largeBlobWritten) {
+    data.extensions.largeBlob = {
+      blob: result.largeBlob ? bufferToBase64Url(result.largeBlob) : undefined,
+      written: result.largeBlobWritten !== null ? result.largeBlobWritten : undefined
+    };
+  }
+  return { success: true, data };
+}
+// src/helpers/public-key.ts
+function encodeBigIntToBuffer(value, byteLength) {
+  const hex = value.toString(16).padStart(byteLength * 2, "0");
+  return Buffer.from(hex, "hex");
+}
+function encodeEC2PublicKeyToSPKI(x, y) {
+  const xBuffer = encodeBigIntToBuffer(x, 32);
+  const yBuffer = encodeBigIntToBuffer(y, 32);
+  const uncompressedPoint = Buffer.concat([
+    Buffer.from([4]),
+    xBuffer,
+    yBuffer
+  ]);
+  const bitString = Buffer.concat([
+    Buffer.from([3]),
+    Buffer.from([66]),
+    Buffer.from([0]),
+    uncompressedPoint
+  ]);
+  const algorithmIdentifier = Buffer.from([
+    48,
+    19,
+    6,
+    7,
+    42,
+    134,
+    72,
+    206,
+    61,
+    2,
+    1,
+    6,
+    8,
+    42,
+    134,
+    72,
+    206,
+    61,
+    3,
+    1,
+    7
+  ]);
+  const spki = Buffer.concat([
+    Buffer.from([48]),
+    Buffer.from([89]),
+    algorithmIdentifier,
+    bitString
+  ]);
+  return spki;
+}
+
+// src/create/authorization-controller.ts
+import { NobjcClass as NobjcClass2, getPointer as getPointer2 } from "objc-js";
+
+// src/additional-objc/ASCPublicKeyCredentialDescriptor.ts
+var ASCPublicKeyCredentialDescriptor = AuthenticationServices.ASCPublicKeyCredentialDescriptor;
+
+// src/create/authorization-controller.ts
+var createControllerState = new Map;
+function getObjectPointerString2(self) {
+  return getPointer2(self).toString("base64");
+}
+function setControllerState(self, clientDataHash, pubKeyCredParams, residentKeyRequired, excludeCredentialIds) {
+  const selfPointer = getObjectPointerString2(self);
+  createControllerState.set(selfPointer, [
+    clientDataHash,
+    pubKeyCredParams,
+    residentKeyRequired,
+    excludeCredentialIds
+  ]);
+}
+function removeControllerState(self) {
+  const selfPointer = getObjectPointerString2(self);
+  createControllerState.delete(selfPointer);
+}
+var WebauthnCreateController = NobjcClass2.define({
+  name: "WebauthnCreateController",
+  superclass: "ASAuthorizationController",
+  methods: {
+    _requestContextWithRequests$error$: {
+      types: "@@:@^@",
+      implementation: (self, requests, outError) => {
+        const context = NobjcClass2.super(self, "_requestContextWithRequests$error$", requests, outError);
+        const selfPointer = getObjectPointerString2(self);
+        if (context && createControllerState.has(selfPointer)) {
+          let isSecurityKey = false;
+          let registrationOptions = context.platformKeyCredentialCreationOptions();
+          if (!registrationOptions) {
+            registrationOptions = context.securityKeyCredentialCreationOptions();
+            isSecurityKey = true;
+          }
+          const [
+            clientDataHash,
+            pubKeyCredParams,
+            residentKeyRequired,
+            excludeCredentials
+          ] = createControllerState.get(selfPointer);
+          registrationOptions.setClientDataHash$(NSDataFromBuffer(clientDataHash));
+          registrationOptions.setChallenge$(null);
+          const supportedAlgos = [];
+          for (const param of pubKeyCredParams) {
+            if (param.type === "public-key") {
+              const nsNum = NSNumber.numberWithInteger$(param.algorithm);
+              supportedAlgos.push(nsNum);
+            }
+          }
+          if (supportedAlgos.length > 0) {
+            registrationOptions.setSupportedAlgorithmIdentifiers$(NSArrayFromObjects(supportedAlgos));
+          }
+          if (!isSecurityKey) {
+            registrationOptions.setShouldRequireResidentKey$(residentKeyRequired);
+          }
+          const excludeList = [];
+          for (const cred of excludeCredentials) {
+            const transports = [];
+            if (cred.transports) {
+              for (const transport of cred.transports) {
+                transports.push(NSStringFromString(transport));
+              }
+            }
+            const credentialID = NSDataFromBuffer(cred.id);
+            const transportsArray = NSArrayFromObjects(transports);
+            const initializedDescriptor = ASCPublicKeyCredentialDescriptor.alloc().initWithCredentialID$transports$(credentialID, transportsArray);
+            excludeList.push(initializedDescriptor);
+          }
+          if (excludeList.length > 0) {
+            registrationOptions.setExcludedCredentials$(NSArrayFromObjects(excludeList));
+          }
+        }
+        return context;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.bun/@oslojs+binary@1.0.0/node_modules/@oslojs/binary/dist/uint.js
+class BigEndian {
+  uint8(data, offset) {
+    if (data.byteLength < offset + 1) {
+      throw new TypeError("Insufficient bytes");
+    }
+    return data[offset];
+  }
+  uint16(data, offset) {
+    if (data.byteLength < offset + 2) {
+      throw new TypeError("Insufficient bytes");
+    }
+    return data[offset] << 8 | data[offset + 1];
+  }
+  uint32(data, offset) {
+    if (data.byteLength < offset + 4) {
+      throw new TypeError("Insufficient bytes");
+    }
+    let result = 0;
+    for (let i = 0;i < 4; i++) {
+      result |= data[offset + i] << 24 - i * 8;
+    }
+    return result;
+  }
+  uint64(data, offset) {
+    if (data.byteLength < offset + 8) {
+      throw new TypeError("Insufficient bytes");
+    }
+    let result = 0n;
+    for (let i = 0;i < 8; i++) {
+      result |= BigInt(data[offset + i]) << BigInt(56 - i * 8);
+    }
+    return result;
+  }
+  putUint8(target, value, offset) {
+    if (target.length < offset + 1) {
+      throw new TypeError("Not enough space");
+    }
+    if (value < 0 || value > 255) {
+      throw new TypeError("Invalid uint8 value");
+    }
+    target[offset] = value;
+  }
+  putUint16(target, value, offset) {
+    if (target.length < offset + 2) {
+      throw new TypeError("Not enough space");
+    }
+    if (value < 0 || value > 65535) {
+      throw new TypeError("Invalid uint16 value");
+    }
+    target[offset] = value >> 8;
+    target[offset + 1] = value & 255;
+  }
+  putUint32(target, value, offset) {
+    if (target.length < offset + 4) {
+      throw new TypeError("Not enough space");
+    }
+    if (value < 0 || value > 4294967295) {
+      throw new TypeError("Invalid uint32 value");
+    }
+    for (let i = 0;i < 4; i++) {
+      target[offset + i] = value >> (3 - i) * 8 & 255;
+    }
+  }
+  putUint64(target, value, offset) {
+    if (target.length < offset + 8) {
+      throw new TypeError("Not enough space");
+    }
+    if (value < 0 || value > 18446744073709551615n) {
+      throw new TypeError("Invalid uint64 value");
+    }
+    for (let i = 0;i < 8; i++) {
+      target[offset + i] = Number(value >> BigInt((7 - i) * 8) & 0xffn);
+    }
+  }
+}
+
+class LittleEndian {
+  uint8(data, offset) {
+    if (data.byteLength < offset + 1) {
+      throw new TypeError("Insufficient bytes");
+    }
+    return data[offset];
+  }
+  uint16(data, offset) {
+    if (data.byteLength < offset + 2) {
+      throw new TypeError("Insufficient bytes");
+    }
+    return data[offset] | data[offset + 1] << 8;
+  }
+  uint32(data, offset) {
+    if (data.byteLength < offset + 4) {
+      throw new TypeError("Insufficient bytes");
+    }
+    let result = 0;
+    for (let i = 0;i < 4; i++) {
+      result |= data[offset + i] << i * 8;
+    }
+    return result;
+  }
+  uint64(data, offset) {
+    if (data.byteLength < offset + 8) {
+      throw new TypeError("Insufficient bytes");
+    }
+    let result = 0n;
+    for (let i = 0;i < 8; i++) {
+      result |= BigInt(data[offset + i]) << BigInt(i * 8);
+    }
+    return result;
+  }
+  putUint8(target, value, offset) {
+    if (target.length < 1 + offset) {
+      throw new TypeError("Insufficient space");
+    }
+    if (value < 0 || value > 255) {
+      throw new TypeError("Invalid uint8 value");
+    }
+    target[offset] = value;
+  }
+  putUint16(target, value, offset) {
+    if (target.length < 2 + offset) {
+      throw new TypeError("Insufficient space");
+    }
+    if (value < 0 || value > 65535) {
+      throw new TypeError("Invalid uint16 value");
+    }
+    target[offset + 1] = value >> 8;
+    target[offset] = value & 255;
+  }
+  putUint32(target, value, offset) {
+    if (target.length < 4 + offset) {
+      throw new TypeError("Insufficient space");
+    }
+    if (value < 0 || value > 4294967295) {
+      throw new TypeError("Invalid uint32 value");
+    }
+    for (let i = 0;i < 4; i++) {
+      target[offset + i] = value >> i * 8 & 255;
+    }
+  }
+  putUint64(target, value, offset) {
+    if (target.length < 8 + offset) {
+      throw new TypeError("Insufficient space");
+    }
+    if (value < 0 || value > 18446744073709551615n) {
+      throw new TypeError("Invalid uint64 value");
+    }
+    for (let i = 0;i < 8; i++) {
+      target[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
+    }
+  }
+}
+var bigEndian = new BigEndian;
+var littleEndian = new LittleEndian;
+// ../../node_modules/.bun/@oslojs+binary@1.0.0/node_modules/@oslojs/binary/dist/bytes.js
+function compareBytes(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0;i < b.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+class DynamicBuffer {
+  value;
+  capacity;
+  length = 0;
+  constructor(capacity) {
+    this.value = new Uint8Array(capacity);
+    this.capacity = capacity = capacity;
+  }
+  write(bytes) {
+    if (this.length + bytes.byteLength <= this.capacity) {
+      this.value.set(bytes, this.length);
+      this.length += bytes.byteLength;
+      return;
+    }
+    while (this.length + bytes.byteLength > this.capacity) {
+      if (this.capacity === 0) {
+        this.capacity = 1;
+      } else {
+        this.capacity = this.capacity * 2;
+      }
+    }
+    const newValue = new Uint8Array(this.capacity);
+    newValue.set(this.value.subarray(0, this.length));
+    newValue.set(bytes, this.length);
+    this.value = newValue;
+    this.length += bytes.byteLength;
+  }
+  writeByte(byte) {
+    if (this.length + 1 <= this.capacity) {
+      this.value[this.length] = byte;
+      this.length += 1;
+      return;
+    }
+    if (this.capacity === 0) {
+      this.capacity = 1;
+    } else {
+      this.capacity = this.capacity * 2;
+    }
+    const newValue = new Uint8Array(this.capacity);
+    newValue.set(this.value.subarray(0, this.length));
+    newValue[this.length] = byte;
+    this.value = newValue;
+    this.length += 1;
+  }
+  readInto(target) {
+    if (target.byteLength < this.length) {
+      throw new TypeError("Not enough space");
+    }
+    target.set(this.value.subarray(0, this.length));
+  }
+  bytes() {
+    return this.value.slice(0, this.length);
+  }
+  clear() {
+    this.length = 0;
+  }
+}
+// ../../node_modules/.bun/@oslojs+binary@1.0.0/node_modules/@oslojs/binary/dist/bits.js
+function rotr32(x, n) {
+  return (x << 32 - n | x >>> n) >>> 0;
+}
+function rotr64(x, n) {
+  return (x << BigInt(64 - n) | x >> BigInt(n)) & 0xffffffffffffffffn;
+}
+// ../../node_modules/.bun/@oslojs+binary@1.0.0/node_modules/@oslojs/binary/dist/big.js
+function bigIntFromBytes(bytes) {
+  if (bytes.byteLength < 1) {
+    throw new TypeError("Empty Uint8Array");
+  }
+  let decoded = 0n;
+  for (let i = 0;i < bytes.byteLength; i++) {
+    decoded += BigInt(bytes[i]) << BigInt((bytes.byteLength - 1 - i) * 8);
+  }
+  return decoded;
+}
+// ../../node_modules/.bun/@oslojs+cbor@1.0.0/node_modules/@oslojs/cbor/dist/float.js
+function toFloat16(data) {
+  if (data.byteLength !== 2) {
+    throw new TypeError;
+  }
+  const sign = (-1) ** (data[0] >> 7);
+  let fraction = 0;
+  fraction += 2 ** -1 * (data[0] >> 1 & 1);
+  fraction += 2 ** -2 * (data[0] & 1);
+  for (let i = 0;i < 8; i++) {
+    if ((data[1] >> 7 - i & 1) === 1) {
+      fraction += 2 ** -(3 + i);
+    }
+  }
+  const exponent = data[0] >> 2 & 31;
+  if (exponent === 0) {
+    return sign * 2 ** -14 * fraction;
+  }
+  if (exponent === 31 && fraction === 0) {
+    return sign * Infinity;
+  }
+  if (exponent === 31 && fraction !== 0) {
+    return NaN;
+  }
+  return sign * 2 ** (exponent - 15) * (1 + fraction);
+}
+function toFloat32(data) {
+  if (data.byteLength !== 4) {
+    throw new TypeError;
+  }
+  const sign = (-1) ** (data[0] >> 7);
+  const exponent = ((data[0] & 127) << 1) + (data[1] >> 7);
+  let fractionPart = data[1] & 127;
+  for (let i = 0;i < 3; i++) {
+    fractionPart |= data[2 + i];
+  }
+  if (exponent === 255 && fractionPart === 0) {
+    return sign * Infinity;
+  }
+  if (exponent === 255 && fractionPart !== 0) {
+    return NaN;
+  }
+  let bias;
+  let result;
+  if (exponent === 0) {
+    bias = 126;
+    result = 0;
+  } else {
+    bias = 127;
+    result = 2 ** (exponent - bias);
+  }
+  for (let i = 0;i < 7; i++) {
+    if ((data[1] >> 6 - i & 1) === 1) {
+      result += 2 ** (-1 - i + exponent - bias);
+    }
+  }
+  for (let i = 0;i < 2; i++) {
+    for (let j = 0;j < 8; j++) {
+      if ((data[2 + i] >> 7 - j & 1) === 1) {
+        const position = 8 + i * 8 + j;
+        result += 2 ** (exponent - bias - position);
+      }
+    }
+  }
+  return sign * result;
+}
+function toFloat64(data) {
+  if (data.byteLength !== 8) {
+    throw new TypeError;
+  }
+  const sign = (-1) ** (data[0] >> 7);
+  const exponent = ((data[0] & 127) << 4) + (data[1] >> 4);
+  let fractionPart = data[1] & 15;
+  for (let i = 0;i < 6; i++) {
+    fractionPart |= data[2 + i];
+  }
+  if (exponent === 2047 && fractionPart === 0) {
+    return sign * Infinity;
+  }
+  if (exponent === 2047 && fractionPart !== 0) {
+    return NaN;
+  }
+  let bias;
+  let result;
+  if (exponent === 0) {
+    bias = 1022;
+    result = 0;
+  } else {
+    bias = 1023;
+    result = 2 ** (exponent - bias);
+  }
+  for (let i = 0;i < 4; i++) {
+    if ((data[1] >> 3 - i & 1) === 1) {
+      result += 2 ** (-1 - i + exponent - bias);
+    }
+  }
+  for (let i = 0;i < 6; i++) {
+    for (let j = 0;j < 8; j++) {
+      if ((data[2 + i] >> 7 - j & 1) === 1) {
+        const position = 5 + i * 8 + j;
+        result += 2 ** (exponent - bias - position);
+      }
+    }
+  }
+  return sign * result;
+}
+
+// ../../node_modules/.bun/@oslojs+cbor@1.0.0/node_modules/@oslojs/cbor/dist/cbor.js
+class CBORPositiveInteger {
+  value;
+  constructor(value) {
+    if (value < 0) {
+      throw new TypeError;
+    }
+    this.value = value;
+  }
+  isNumber() {
+    return BigInt(Number(this.value)) === this.value;
+  }
+}
+
+class CBORNegativeInteger {
+  value;
+  constructor(value) {
+    if (value > -1) {
+      throw new TypeError;
+    }
+    this.value = value;
+  }
+  isNumber() {
+    return BigInt(Number(this.value)) === this.value;
+  }
+}
+
+class CBORByteString {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class CBORTextString {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  decodeText() {
+    try {
+      return new TextDecoder("utf-8", {
+        fatal: true
+      }).decode(this.value);
+    } catch {
+      throw new CBORInvalidError;
+    }
+  }
+}
+
+class CBORArray {
+  elements;
+  constructor(elements) {
+    this.elements = elements;
+  }
+}
+
+class CBORMap {
+  entries;
+  constructor(entries) {
+    this.entries = entries;
+  }
+  has(key) {
+    for (const [entryKey] of this.entries) {
+      if (compareCBORValues(key, entryKey)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  get(key) {
+    for (const [entryKey, entryValue] of this.entries) {
+      if (compareCBORValues(key, entryKey)) {
+        return entryValue;
+      }
+    }
+    return null;
+  }
+  getAll(key) {
+    const result = [];
+    for (const [entryKey, entryValue] of this.entries) {
+      if (compareCBORValues(key, entryKey)) {
+        result.push(entryValue);
+      }
+    }
+    return result;
+  }
+  hasDuplicateKeys() {
+    for (let i = 0;i < this.entries.length; i++) {
+      for (let j = i + 1;j < this.entries.length; j++) {
+        if (compareCBORValues(this.entries[i][0], this.entries[j][0])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}
+
+class CBORFloat16 {
+  value;
+  constructor(value) {
+    if (value.byteLength !== 2) {
+      throw new TypeError;
+    }
+    this.value = value;
+  }
+  toNumber() {
+    return toFloat16(this.value);
+  }
+}
+
+class CBORFloat32 {
+  value;
+  constructor(value) {
+    if (value.byteLength !== 4) {
+      throw new TypeError;
+    }
+    this.value = value;
+  }
+  toNumber() {
+    return toFloat32(this.value);
+  }
+}
+
+class CBORFloat64 {
+  value;
+  constructor(value) {
+    if (value.byteLength !== 8) {
+      throw new TypeError;
+    }
+    this.value = value;
+  }
+  toNumber() {
+    return toFloat64(this.value);
+  }
+}
+
+class CBORTagged {
+  tagNumber;
+  value;
+  constructor(tagNumber, value) {
+    this.tagNumber = tagNumber;
+    this.value = value;
+  }
+}
+
+class CBORSimple {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class CBORBreak {
+  value = null;
+}
+function compareCBORValues(a, b) {
+  if (a instanceof CBORPositiveInteger && b instanceof CBORPositiveInteger) {
+    return a.value === b.value;
+  }
+  if (a instanceof CBORNegativeInteger && b instanceof CBORNegativeInteger) {
+    return a.value === b.value;
+  }
+  if (a instanceof CBORByteString && b instanceof CBORByteString) {
+    return compareBytes(a.value, b.value);
+  }
+  if (a instanceof CBORTextString && b instanceof CBORTextString) {
+    return a.value === b.value;
+  }
+  if (a instanceof CBORSimple && b instanceof CBORSimple) {
+    return a.value === b.value;
+  }
+  if (a instanceof CBORTagged && b instanceof CBORTagged) {
+    return a.tagNumber === b.tagNumber && compareCBORValues(a.value, b.value);
+  }
+  if (a instanceof CBORFloat16 && b instanceof CBORFloat16) {
+    return compareBytes(a.value, b.value);
+  }
+  if (a instanceof CBORFloat32 && b instanceof CBORFloat32) {
+    return compareBytes(a.value, b.value);
+  }
+  if (a instanceof CBORFloat64 && b instanceof CBORFloat64) {
+    return compareBytes(a.value, b.value);
+  }
+  if (a instanceof CBORArray && b instanceof CBORArray) {
+    if (a.elements.length !== b.elements.length) {
+      return false;
+    }
+    for (let i = 0;i < a.elements.length; i++) {
+      if (!compareCBORValues(a.elements[i], b.elements[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof CBORMap && b instanceof CBORMap) {
+    if (a.entries.length !== b.entries.length) {
+      return false;
+    }
+    const checkedIndexes = [];
+    for (let i = 0;i < a.entries.length; i++) {
+      for (let j = 0;j < b.entries.length; j++) {
+        if (!checkedIndexes.includes(i)) {
+          if (!compareCBORValues(a.entries[i][0], b.entries[j][0])) {
+            continue;
+          }
+          if (!compareCBORValues(a.entries[i][1], b.entries[j][1])) {
+            continue;
+          }
+          checkedIndexes.push(j);
+          break;
+        }
+      }
+      if (checkedIndexes.length !== i + 1) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+class CBORNotWellFormedError extends Error {
+  constructor() {
+    super("CBOR is not well-formed");
+  }
+}
+
+class CBORLeftoverBytesError extends Error {
+  constructor(count) {
+    super(`Leftover bytes: ${count}`);
+  }
+}
+
+class CBORTooDeepError extends Error {
+  constructor() {
+    super("Exceeds maximum depth");
+  }
+}
+
+class CBORInvalidError extends Error {
+  constructor() {
+    super("Invalid CBOR");
+  }
+}
+// ../../node_modules/.bun/@oslojs+cbor@1.0.0/node_modules/@oslojs/cbor/dist/transform.js
+function transformCBORValueToNative(cbor) {
+  if (cbor instanceof CBORPositiveInteger || cbor instanceof CBORNegativeInteger) {
+    if (cbor.isNumber()) {
+      return Number(cbor.value);
+    }
+    return cbor.value;
+  }
+  if (cbor instanceof CBORTextString) {
+    return cbor.decodeText();
+  }
+  if (cbor instanceof CBORByteString) {
+    return cbor.value;
+  }
+  if (cbor instanceof CBORFloat16 || cbor instanceof CBORFloat32 || cbor instanceof CBORFloat64) {
+    return cbor.toNumber();
+  }
+  if (cbor instanceof CBORSimple) {
+    if (cbor.value === 20) {
+      return false;
+    }
+    if (cbor.value === 21) {
+      return true;
+    }
+    if (cbor.value === 22) {
+      return null;
+    }
+    if (cbor.value === 23) {
+      return;
+    }
+    throw new CBORInvalidError;
+  }
+  if (cbor instanceof CBORArray) {
+    const result = new Array(cbor.elements.length);
+    for (let i = 0;i < cbor.elements.length; i++) {
+      result[i] = transformCBORValueToNative(cbor.elements[i]);
+    }
+    return result;
+  }
+  if (cbor instanceof CBORMap) {
+    const result = {};
+    for (let i = 0;i < cbor.entries.length; i++) {
+      const [entryKey, entryValue] = cbor.entries[i];
+      let stringifiedKey;
+      if (entryKey instanceof CBORTextString) {
+        stringifiedKey = entryKey.decodeText();
+      } else if (entryKey instanceof CBORPositiveInteger || entryKey instanceof CBORNegativeInteger) {
+        stringifiedKey = entryKey.value.toString();
+      } else if (entryKey instanceof CBORFloat16 || entryKey instanceof CBORFloat32 || entryKey instanceof CBORFloat64) {
+        const valueNumber = entryKey.toNumber();
+        if (Number.isNaN(valueNumber)) {
+          throw new CBORInvalidError;
+        }
+        stringifiedKey = valueNumber.toString();
+      } else {
+        throw new CBORInvalidError;
+      }
+      if (stringifiedKey === "__proto__") {
+        throw new CBORInvalidError;
+      }
+      if (stringifiedKey in result) {
+        throw new CBORInvalidError;
+      }
+      result[stringifiedKey] = transformCBORValueToNative(entryValue);
+    }
+    return result;
+  }
+  if (cbor instanceof CBORTagged) {
+    return transformCBORValueToNative(cbor.value);
+  }
+  throw new CBORInvalidError;
+}
+
+// ../../node_modules/.bun/@oslojs+cbor@1.0.0/node_modules/@oslojs/cbor/dist/decode.js
+function decodeCBORToNativeValueNoLeftoverBytes(data, maxDepth) {
+  const decoded = decodeCBORNoLeftoverBytes(data, maxDepth);
+  return transformCBORValueToNative(decoded);
+}
+function decodeCBORToNativeValue(data, maxDepth) {
+  const [decoded, size] = decodeCBOR(data, maxDepth);
+  return [transformCBORValueToNative(decoded), size];
+}
+function decodeCBORNoLeftoverBytes(data, maxDepth) {
+  const [result, size] = decodeCBOR(data, maxDepth);
+  if (size !== data.byteLength) {
+    throw new CBORLeftoverBytesError(data.byteLength - size);
+  }
+  return result;
+}
+function decodeCBOR(data, maxDepth) {
+  const [value, size] = decodeCBORIncludingBreaks(data, maxDepth, 0);
+  if (value instanceof CBORBreak) {
+    throw new CBORNotWellFormedError;
+  }
+  return [value, size];
+}
+function decodeCBORIncludingBreaks(data, maxDepth, currentDepth) {
+  if (currentDepth > maxDepth) {
+    throw new CBORTooDeepError;
+  }
+  if (data.byteLength < 1) {
+    throw new CBORNotWellFormedError;
+  }
+  const majorType = data[0] >> 5;
+  if (majorType === 0) {
+    const additionalInformation = data[0] & 31;
+    if (additionalInformation < 24) {
+      return [new CBORPositiveInteger(BigInt(additionalInformation)), 1];
+    }
+    const argumentSize = getArgumentSize(additionalInformation);
+    const value = getVariableUint(data, argumentSize, 1);
+    return [new CBORPositiveInteger(value), 1 + argumentSize];
+  }
+  if (majorType === 1) {
+    const additionalInformation = data[0] & 31;
+    if (additionalInformation < 24) {
+      return [new CBORNegativeInteger(BigInt(-1 - additionalInformation)), 1];
+    }
+    const argumentSize = getArgumentSize(additionalInformation);
+    const value = getVariableUint(data, argumentSize, 1);
+    return [new CBORNegativeInteger(-1n - BigInt(value)), 1 + argumentSize];
+  }
+  if (majorType === 2) {
+    const additionalInformation = data[0] & 31;
+    if (additionalInformation === 31) {
+      let offset2 = 1;
+      let size = offset2;
+      const buffer = new DynamicBuffer(0);
+      while (true) {
+        if (data.byteLength < offset2 + 1) {
+          throw new CBORNotWellFormedError;
+        }
+        const innerMajorType = data[offset2] >> 5;
+        const innerAdditionalInformation = data[offset2] & 31;
+        if (innerMajorType === 7 && innerAdditionalInformation === 31) {
+          size += 1;
+          break;
+        }
+        if (innerMajorType !== 2) {
+          throw new CBORNotWellFormedError;
+        }
+        let innerByteSize;
+        let innerOffset;
+        if (innerAdditionalInformation < 24) {
+          innerByteSize = innerAdditionalInformation;
+          innerOffset = 1;
+        } else {
+          const innerArgumentSize = getArgumentSize(innerAdditionalInformation);
+          innerByteSize = Number(getVariableUint(data, innerArgumentSize, offset2 + 1));
+          innerOffset = 1 + innerArgumentSize;
+        }
+        if (data.byteLength < offset2 + innerByteSize) {
+          throw new CBORNotWellFormedError;
+        }
+        buffer.write(data.subarray(offset2 + innerOffset, offset2 + innerOffset + innerByteSize));
+        size += innerOffset + innerByteSize;
+        offset2 += innerOffset + innerByteSize;
+      }
+      return [new CBORByteString(buffer.bytes()), size];
+    }
+    let offset;
+    let byteSize;
+    if (additionalInformation < 24) {
+      byteSize = additionalInformation;
+      offset = 1;
+    } else {
+      const argumentSize = getArgumentSize(additionalInformation);
+      byteSize = Number(getVariableUint(data, argumentSize, 1));
+      offset = 1 + argumentSize;
+    }
+    if (data.byteLength < offset + byteSize) {
+      throw new CBORNotWellFormedError;
+    }
+    const value = data.slice(offset, offset + byteSize);
+    return [new CBORByteString(value), offset + byteSize];
+  }
+  if (majorType === 3) {
+    const additionalInformation = data[0] & 31;
+    let offset;
+    if (additionalInformation === 31) {
+      offset = 1;
+      let size = offset;
+      const buffer = new DynamicBuffer(0);
+      while (true) {
+        if (data.byteLength < offset + 1) {
+          throw new CBORNotWellFormedError;
+        }
+        const innerMajorType = data[offset] >> 5;
+        const innerAdditionalInformation = data[offset] & 31;
+        if (innerMajorType === 7 && innerAdditionalInformation === 31) {
+          offset += 1;
+          size += 1;
+          break;
+        }
+        if (innerMajorType !== 3) {
+          throw new CBORNotWellFormedError;
+        }
+        let innerByteSize;
+        let innerOffset;
+        if (innerAdditionalInformation < 24) {
+          innerByteSize = innerAdditionalInformation;
+          innerOffset = 1;
+        } else {
+          const innerArgumentSize = getArgumentSize(innerAdditionalInformation);
+          innerByteSize = Number(getVariableUint(data, innerArgumentSize, offset + 1));
+          innerOffset = 1 + innerArgumentSize;
+        }
+        if (data.byteLength < offset + innerByteSize) {
+          throw new CBORNotWellFormedError;
+        }
+        buffer.write(data.subarray(offset + innerOffset, offset + innerOffset + innerByteSize));
+        size += innerOffset + innerByteSize;
+        offset += innerOffset + innerByteSize;
+      }
+      return [new CBORTextString(buffer.bytes()), size];
+    }
+    let byteSize;
+    if (additionalInformation < 24) {
+      byteSize = additionalInformation;
+      offset = 1;
+    } else {
+      const argumentSize = getArgumentSize(additionalInformation);
+      byteSize = Number(getVariableUint(data, argumentSize, 1));
+      offset = 1 + argumentSize;
+    }
+    if (data.byteLength < offset + byteSize) {
+      throw new CBORNotWellFormedError;
+    }
+    const value = data.slice(offset, offset + byteSize);
+    return [new CBORTextString(value), offset + byteSize];
+  }
+  if (majorType === 4) {
+    const additionalInformation = data[0] & 31;
+    let offset = 1;
+    if (additionalInformation === 31) {
+      let size2 = offset;
+      const elements2 = [];
+      while (true) {
+        const [element, elementByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+        size2 += elementByteSize;
+        if (element instanceof CBORBreak) {
+          break;
+        }
+        offset += elementByteSize;
+        elements2.push(element);
+      }
+      return [new CBORArray(elements2), size2];
+    }
+    let arraySize;
+    if (additionalInformation < 24) {
+      arraySize = additionalInformation;
+    } else {
+      const argumentSize = getArgumentSize(additionalInformation);
+      arraySize = Number(getVariableUint(data, argumentSize, 1));
+      offset += argumentSize;
+    }
+    const elements = new Array(arraySize);
+    let size = offset;
+    for (let i = 0;i < arraySize; i++) {
+      const [element, elementByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+      if (element instanceof CBORBreak) {
+        throw new CBORNotWellFormedError;
+      }
+      offset += elementByteSize;
+      size += elementByteSize;
+      elements[i] = element;
+    }
+    return [new CBORArray(elements), size];
+  }
+  if (majorType === 5) {
+    const additionalInformation = data[0] & 31;
+    let offset = 1;
+    if (additionalInformation === 31) {
+      let size2 = offset;
+      const entries = [];
+      while (true) {
+        const [entryKey, keyByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+        if (entryKey instanceof CBORBreak) {
+          size2 += keyByteSize;
+          break;
+        }
+        offset += keyByteSize;
+        size2 += keyByteSize;
+        const [entryValue, valueByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+        if (entryValue instanceof CBORBreak) {
+          throw new CBORNotWellFormedError;
+        }
+        entries.push([entryKey, entryValue]);
+        offset += valueByteSize;
+        size2 += valueByteSize;
+      }
+      return [new CBORMap(entries), size2];
+    }
+    let pairCount;
+    if (additionalInformation < 24) {
+      pairCount = additionalInformation;
+    } else {
+      const argumentSize = getArgumentSize(additionalInformation);
+      pairCount = Number(getVariableUint(data, argumentSize, 1));
+      offset += argumentSize;
+    }
+    if (pairCount > data.byteLength) {
+      throw new CBORNotWellFormedError;
+    }
+    const value = new Array(pairCount);
+    let size = offset;
+    for (let i = 0;i < pairCount; i++) {
+      const [entryKey, keyByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+      if (entryKey instanceof CBORBreak) {
+        throw new CBORNotWellFormedError;
+      }
+      offset += keyByteSize;
+      size += keyByteSize;
+      const [entryValue, valueByteSize] = decodeCBORIncludingBreaks(data.subarray(offset), maxDepth, currentDepth + 1);
+      if (entryValue instanceof CBORBreak) {
+        throw new CBORNotWellFormedError;
+      }
+      value[i] = [entryKey, entryValue];
+      offset += valueByteSize;
+      size += valueByteSize;
+    }
+    return [new CBORMap(value), size];
+  }
+  if (majorType === 6) {
+    const additionalInformation = data[0] & 31;
+    let tagNumber;
+    let headSize;
+    if (additionalInformation < 24) {
+      tagNumber = BigInt(additionalInformation);
+      headSize = 1;
+    } else {
+      const argumentSize = getArgumentSize(additionalInformation);
+      tagNumber = getVariableUint(data, argumentSize, 1);
+      headSize = 1 + argumentSize;
+    }
+    const [value, valueSize] = decodeCBORIncludingBreaks(data.subarray(headSize), maxDepth, currentDepth + 1);
+    return [new CBORTagged(tagNumber, value), headSize + valueSize];
+  }
+  if (majorType === 7) {
+    const additionalInformation = data[0] & 31;
+    if (additionalInformation < 24) {
+      return [new CBORSimple(additionalInformation), 1];
+    }
+    if (additionalInformation === 24) {
+      if (data.byteLength < 2) {
+        throw new CBORNotWellFormedError;
+      }
+      if (data[1] < 24) {
+        throw new CBORNotWellFormedError;
+      }
+      return [new CBORSimple(data[1]), 2];
+    }
+    if (additionalInformation === 25) {
+      if (data.byteLength < 2) {
+        throw new CBORNotWellFormedError;
+      }
+      return [new CBORFloat16(data.subarray(1, 3)), 3];
+    }
+    if (additionalInformation === 26) {
+      if (data.byteLength < 4) {
+        throw new CBORNotWellFormedError;
+      }
+      return [new CBORFloat32(data.subarray(1, 5)), 5];
+    }
+    if (additionalInformation === 27) {
+      if (data.byteLength < 8) {
+        throw new CBORNotWellFormedError;
+      }
+      return [new CBORFloat64(data.subarray(1, 9)), 9];
+    }
+    if (additionalInformation === 31) {
+      return [new CBORBreak, 1];
+    }
+    throw new CBORNotWellFormedError;
+  }
+  throw new CBORNotWellFormedError;
+}
+function getArgumentSize(additionalInformation) {
+  if (additionalInformation === 24) {
+    return 1;
+  } else if (additionalInformation === 25) {
+    return 2;
+  } else if (additionalInformation === 26) {
+    return 4;
+  } else if (additionalInformation === 27) {
+    return 8;
+  } else {
+    throw new CBORNotWellFormedError;
+  }
+}
+function getVariableUint(data, size, offset) {
+  if (data.byteLength < size + offset) {
+    throw new Error;
+  }
+  if (size === 1) {
+    return BigInt(data[offset]);
+  }
+  if (size === 2) {
+    return BigInt(bigEndian.uint16(data, offset));
+  }
+  if (size === 4) {
+    return BigInt(bigEndian.uint32(data, offset));
+  }
+  if (size === 8) {
+    return bigEndian.uint64(data, offset);
+  }
+  throw new TypeError("Invalid size");
+}
+// ../../node_modules/.bun/@oslojs+encoding@1.0.0/node_modules/@oslojs/encoding/dist/base32.js
+var EncodingPadding;
+(function(EncodingPadding2) {
+  EncodingPadding2[EncodingPadding2["Include"] = 0] = "Include";
+  EncodingPadding2[EncodingPadding2["None"] = 1] = "None";
+})(EncodingPadding || (EncodingPadding = {}));
+var DecodingPadding;
+(function(DecodingPadding2) {
+  DecodingPadding2[DecodingPadding2["Required"] = 0] = "Required";
+  DecodingPadding2[DecodingPadding2["Ignore"] = 1] = "Ignore";
+})(DecodingPadding || (DecodingPadding = {}));
+// ../../node_modules/.bun/@oslojs+encoding@1.0.0/node_modules/@oslojs/encoding/dist/base64.js
+var EncodingPadding2;
+(function(EncodingPadding3) {
+  EncodingPadding3[EncodingPadding3["Include"] = 0] = "Include";
+  EncodingPadding3[EncodingPadding3["None"] = 1] = "None";
+})(EncodingPadding2 || (EncodingPadding2 = {}));
+var DecodingPadding2;
+(function(DecodingPadding3) {
+  DecodingPadding3[DecodingPadding3["Required"] = 0] = "Required";
+  DecodingPadding3[DecodingPadding3["Ignore"] = 1] = "Ignore";
+})(DecodingPadding2 || (DecodingPadding2 = {}));
+// ../../node_modules/.bun/@oslojs+webauthn@1.0.0/node_modules/@oslojs/webauthn/dist/cose.js
+function decodeCOSEPublicKey(data) {
+  let decoded;
+  let size;
+  try {
+    [decoded, size] = decodeCBORToNativeValue(data, 4);
+  } catch {
+    throw new Error("Failed to decode CBOR");
+  }
+  if (typeof decoded !== "object" || decoded === null) {
+    throw new Error("Invalid CBOR map");
+  }
+  return [new COSEPublicKey(decoded), size];
+}
+
+class COSEPublicKey {
+  decoded;
+  constructor(decoded) {
+    this.decoded = decoded;
+  }
+  type() {
+    if (!(1 in this.decoded) || typeof this.decoded[1] !== "number") {
+      throw new Error("Invalid or missing parameter 'kty'");
+    }
+    const typeId = this.decoded[1];
+    if (typeId in COSE_KEY_ID_MAP) {
+      return COSE_KEY_ID_MAP[typeId];
+    }
+    throw new Error(`Unknown 'kty' value '${typeId}'`);
+  }
+  isAlgorithmDefined() {
+    if (!(3 in this.decoded)) {
+      return false;
+    }
+    if (typeof this.decoded[3] !== "number") {
+      throw new Error("Invalid parameter 'alg'");
+    }
+    return true;
+  }
+  algorithm() {
+    if (!(3 in this.decoded) || typeof this.decoded[3] !== "number") {
+      throw new Error("Invalid or missing parameter 'alg'");
+    }
+    return this.decoded[3];
+  }
+  ec2() {
+    if (this.type() !== COSEKeyType.EC2) {
+      throw new Error("Expected an elliptic curve public key");
+    }
+    if (!("-1" in this.decoded) || typeof this.decoded["-1"] !== "number") {
+      throw new Error("Invalid or missing parameter 'crv'");
+    }
+    const curve = this.decoded["-1"];
+    if (!("-2" in this.decoded) || !(this.decoded["-2"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'x'");
+    }
+    const xBytes = this.decoded["-2"];
+    if (xBytes.byteLength !== 32) {
+      throw new Error("Invalid or missing parameter 'x'");
+    }
+    if (!("-3" in this.decoded) || !(this.decoded["-3"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'y'");
+    }
+    const yBytes = this.decoded["-3"];
+    if (yBytes.byteLength !== 32) {
+      throw new Error("Invalid or missing parameter 'y'");
+    }
+    const publicKey = {
+      curve,
+      x: bigIntFromBytes(xBytes),
+      y: bigIntFromBytes(yBytes)
+    };
+    return publicKey;
+  }
+  rsa() {
+    if (this.type() !== COSEKeyType.RSA) {
+      throw new Error("Expected an RSA public key");
+    }
+    if (!("-1" in this.decoded) || !(this.decoded["-1"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'n'");
+    }
+    const nBytes = this.decoded["-1"];
+    if (nBytes.byteLength !== 256) {
+      throw new Error("Invalid or missing parameter 'n'");
+    }
+    if (!("-2" in this.decoded) || !(this.decoded["-2"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'e'");
+    }
+    const eBytes = this.decoded["-2"];
+    if (eBytes.byteLength !== 3) {
+      throw new Error("Invalid or missing parameter 'e'");
+    }
+    const publicKey = {
+      n: bigIntFromBytes(nBytes),
+      e: bigIntFromBytes(eBytes)
+    };
+    return publicKey;
+  }
+  okp() {
+    if (this.type() !== COSEKeyType.OKP) {
+      throw new Error("Expected an octet key pair public key");
+    }
+    if (!("-1" in this.decoded) || typeof this.decoded["-1"] !== "number") {
+      throw new Error("Invalid or missing parameter 'curve'");
+    }
+    const curve = this.decoded["-1"];
+    if (!("-2" in this.decoded) || !(this.decoded["-2"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'x'");
+    }
+    const x = this.decoded["-2"];
+    if ("-4" in this.decoded) {
+      throw new Error("Unexpected parameter 'd'");
+    }
+    const publicKey = {
+      curve,
+      x
+    };
+    return publicKey;
+  }
+  symmetric() {
+    if (this.type() !== COSEKeyType.Symmetric) {
+      throw new Error("Expected an symmetric key");
+    }
+    if (!("-1" in this.decoded) || !(this.decoded["-1"] instanceof Uint8Array)) {
+      throw new Error("Invalid or missing parameter 'k'");
+    }
+    const k = this.decoded["-1"];
+    return k;
+  }
+}
+var COSEKeyType;
+(function(COSEKeyType2) {
+  COSEKeyType2[COSEKeyType2["OKP"] = 0] = "OKP";
+  COSEKeyType2[COSEKeyType2["EC2"] = 1] = "EC2";
+  COSEKeyType2[COSEKeyType2["RSA"] = 2] = "RSA";
+  COSEKeyType2[COSEKeyType2["Symmetric"] = 3] = "Symmetric";
+  COSEKeyType2[COSEKeyType2["HSSLMS"] = 4] = "HSSLMS";
+  COSEKeyType2[COSEKeyType2["WalnutDSA"] = 5] = "WalnutDSA";
+})(COSEKeyType || (COSEKeyType = {}));
+var COSE_KEY_ID_MAP = {
+  1: COSEKeyType.OKP,
+  2: COSEKeyType.EC2,
+  3: COSEKeyType.RSA,
+  4: COSEKeyType.Symmetric,
+  5: COSEKeyType.HSSLMS,
+  6: COSEKeyType.WalnutDSA
+};
+
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha224.js
+class SHA224 {
+  blockSize = 64;
+  size = 32;
+  blocks = new Uint8Array(64);
+  currentBlockSize = 0;
+  H = new Uint32Array([
+    3238371032,
+    914150663,
+    812702999,
+    4144912697,
+    4290775857,
+    1750603025,
+    1694076839,
+    3204075428
+  ]);
+  l = 0n;
+  w = new Uint32Array(64);
+  update(data) {
+    this.l += BigInt(data.byteLength) * 8n;
+    if (this.currentBlockSize + data.byteLength < 64) {
+      this.blocks.set(data, this.currentBlockSize);
+      this.currentBlockSize += data.byteLength;
+      return;
+    }
+    let processed = 0;
+    if (this.currentBlockSize > 0) {
+      const next = data.slice(0, 64 - this.currentBlockSize);
+      this.blocks.set(next, this.currentBlockSize);
+      this.process();
+      processed += next.byteLength;
+      this.currentBlockSize = 0;
+    }
+    while (processed + 64 <= data.byteLength) {
+      const next = data.slice(processed, processed + 64);
+      this.blocks.set(next);
+      this.process();
+      processed += 64;
+    }
+    if (data.byteLength - processed > 0) {
+      const remaining = data.slice(processed);
+      this.blocks.set(remaining);
+      this.currentBlockSize = remaining.byteLength;
+    }
+  }
+  digest() {
+    this.blocks[this.currentBlockSize] = 128;
+    this.currentBlockSize += 1;
+    if (64 - this.currentBlockSize < 8) {
+      this.blocks.fill(0, this.currentBlockSize);
+      this.process();
+      this.currentBlockSize = 0;
+    }
+    this.blocks.fill(0, this.currentBlockSize);
+    bigEndian.putUint64(this.blocks, this.l, this.blockSize - 8);
+    this.process();
+    const result = new Uint8Array(28);
+    for (let i = 0;i < 7; i++) {
+      bigEndian.putUint32(result, this.H[i], i * 4);
+    }
+    return result;
+  }
+  process() {
+    for (let t = 0;t < 16; t++) {
+      this.w[t] = (this.blocks[t * 4] << 24 | this.blocks[t * 4 + 1] << 16 | this.blocks[t * 4 + 2] << 8 | this.blocks[t * 4 + 3]) >>> 0;
+    }
+    for (let t = 16;t < 64; t++) {
+      const sigma1 = (rotr32(this.w[t - 2], 17) ^ rotr32(this.w[t - 2], 19) ^ this.w[t - 2] >>> 10) >>> 0;
+      const sigma0 = (rotr32(this.w[t - 15], 7) ^ rotr32(this.w[t - 15], 18) ^ this.w[t - 15] >>> 3) >>> 0;
+      this.w[t] = sigma1 + this.w[t - 7] + sigma0 + this.w[t - 16] | 0;
+    }
+    let a = this.H[0];
+    let b = this.H[1];
+    let c = this.H[2];
+    let d = this.H[3];
+    let e = this.H[4];
+    let f = this.H[5];
+    let g = this.H[6];
+    let h = this.H[7];
+    for (let t = 0;t < 64; t++) {
+      const sigma1 = (rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25)) >>> 0;
+      const ch = (e & f ^ ~e & g) >>> 0;
+      const t1 = h + sigma1 + ch + K[t] + this.w[t] | 0;
+      const sigma0 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) >>> 0;
+      const maj = (a & b ^ a & c ^ b & c) >>> 0;
+      const t2 = sigma0 + maj | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    this.H[0] = a + this.H[0] | 0;
+    this.H[1] = b + this.H[1] | 0;
+    this.H[2] = c + this.H[2] | 0;
+    this.H[3] = d + this.H[3] | 0;
+    this.H[4] = e + this.H[4] | 0;
+    this.H[5] = f + this.H[5] | 0;
+    this.H[6] = g + this.H[6] | 0;
+    this.H[7] = h + this.H[7] | 0;
+  }
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha256.js
+function sha256(data) {
+  const hash = new SHA256;
+  hash.update(data);
+  return hash.digest();
+}
+
+class SHA256 {
+  blockSize = 64;
+  size = 32;
+  blocks = new Uint8Array(64);
+  currentBlockSize = 0;
+  H = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  l = 0n;
+  w = new Uint32Array(64);
+  update(data) {
+    this.l += BigInt(data.byteLength) * 8n;
+    if (this.currentBlockSize + data.byteLength < 64) {
+      this.blocks.set(data, this.currentBlockSize);
+      this.currentBlockSize += data.byteLength;
+      return;
+    }
+    let processed = 0;
+    if (this.currentBlockSize > 0) {
+      const next = data.slice(0, 64 - this.currentBlockSize);
+      this.blocks.set(next, this.currentBlockSize);
+      this.process();
+      processed += next.byteLength;
+      this.currentBlockSize = 0;
+    }
+    while (processed + 64 <= data.byteLength) {
+      const next = data.slice(processed, processed + 64);
+      this.blocks.set(next);
+      this.process();
+      processed += 64;
+    }
+    if (data.byteLength - processed > 0) {
+      const remaining = data.slice(processed);
+      this.blocks.set(remaining);
+      this.currentBlockSize = remaining.byteLength;
+    }
+  }
+  digest() {
+    this.blocks[this.currentBlockSize] = 128;
+    this.currentBlockSize += 1;
+    if (64 - this.currentBlockSize < 8) {
+      this.blocks.fill(0, this.currentBlockSize);
+      this.process();
+      this.currentBlockSize = 0;
+    }
+    this.blocks.fill(0, this.currentBlockSize);
+    bigEndian.putUint64(this.blocks, this.l, this.blockSize - 8);
+    this.process();
+    const result = new Uint8Array(32);
+    for (let i = 0;i < 8; i++) {
+      bigEndian.putUint32(result, this.H[i], i * 4);
+    }
+    return result;
+  }
+  process() {
+    for (let t = 0;t < 16; t++) {
+      this.w[t] = (this.blocks[t * 4] << 24 | this.blocks[t * 4 + 1] << 16 | this.blocks[t * 4 + 2] << 8 | this.blocks[t * 4 + 3]) >>> 0;
+    }
+    for (let t = 16;t < 64; t++) {
+      const sigma1 = (rotr32(this.w[t - 2], 17) ^ rotr32(this.w[t - 2], 19) ^ this.w[t - 2] >>> 10) >>> 0;
+      const sigma0 = (rotr32(this.w[t - 15], 7) ^ rotr32(this.w[t - 15], 18) ^ this.w[t - 15] >>> 3) >>> 0;
+      this.w[t] = sigma1 + this.w[t - 7] + sigma0 + this.w[t - 16] | 0;
+    }
+    let a = this.H[0];
+    let b = this.H[1];
+    let c = this.H[2];
+    let d = this.H[3];
+    let e = this.H[4];
+    let f = this.H[5];
+    let g = this.H[6];
+    let h = this.H[7];
+    for (let t = 0;t < 64; t++) {
+      const sigma1 = (rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25)) >>> 0;
+      const ch = (e & f ^ ~e & g) >>> 0;
+      const t1 = h + sigma1 + ch + K2[t] + this.w[t] | 0;
+      const sigma0 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) >>> 0;
+      const maj = (a & b ^ a & c ^ b & c) >>> 0;
+      const t2 = sigma0 + maj | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    this.H[0] = a + this.H[0] | 0;
+    this.H[1] = b + this.H[1] | 0;
+    this.H[2] = c + this.H[2] | 0;
+    this.H[3] = d + this.H[3] | 0;
+    this.H[4] = e + this.H[4] | 0;
+    this.H[5] = f + this.H[5] | 0;
+    this.H[6] = g + this.H[6] | 0;
+    this.H[7] = h + this.H[7] | 0;
+  }
+}
+var K2 = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha512.js
+class SharedSHA512 {
+  blockSize = 128;
+  size = 64;
+  blocks = new Uint8Array(128);
+  currentBlockSize = 0;
+  l = 0n;
+  w = new BigUint64Array(80);
+  H;
+  constructor(H) {
+    if (H.byteLength !== 64) {
+      throw new TypeError;
+    }
+    this.H = H;
+  }
+  update(data) {
+    this.l += BigInt(data.byteLength) * 8n;
+    if (this.currentBlockSize + data.byteLength < 128) {
+      this.blocks.set(data, this.currentBlockSize);
+      this.currentBlockSize += data.byteLength;
+      return;
+    }
+    let processed = 0;
+    if (this.currentBlockSize > 0) {
+      const next = data.slice(0, 128 - this.currentBlockSize);
+      this.blocks.set(next, this.currentBlockSize);
+      this.process();
+      processed += next.byteLength;
+      this.currentBlockSize = 0;
+    }
+    while (processed + 128 <= data.byteLength) {
+      const next = data.slice(processed, processed + 128);
+      this.blocks.set(next);
+      this.process();
+      processed += 128;
+      this.currentBlockSize = 0;
+    }
+    if (data.byteLength - processed > 0) {
+      const remaining = data.slice(processed);
+      this.blocks.set(remaining);
+      this.currentBlockSize = remaining.byteLength;
+    }
+  }
+  putDigest(result) {
+    if (result.byteLength > 64 || result.byteLength % 8 !== 0) {
+      throw new TypeError;
+    }
+    this.blocks[this.currentBlockSize] = 128;
+    this.currentBlockSize += 1;
+    if (128 - this.currentBlockSize < 16) {
+      this.blocks.fill(0, this.currentBlockSize);
+      this.process();
+      this.currentBlockSize = 0;
+    }
+    this.blocks.fill(0, this.currentBlockSize);
+    bigEndian.putUint64(this.blocks, this.l, this.blockSize - 8);
+    this.process();
+    for (let i = 0;i < result.byteLength / 8; i++) {
+      bigEndian.putUint64(result, this.H[i], i * 8);
+    }
+  }
+  process() {
+    for (let t = 0;t < 16; t++) {
+      this.w[t] = BigInt(this.blocks[t * 8]) << 56n | BigInt(this.blocks[t * 8 + 1]) << 48n | BigInt(this.blocks[t * 8 + 2]) << 40n | BigInt(this.blocks[t * 8 + 3]) << 32n | BigInt(this.blocks[t * 8 + 4]) << 24n | BigInt(this.blocks[t * 8 + 5]) << 16n | BigInt(this.blocks[t * 8 + 6]) << 8n | BigInt(this.blocks[t * 8 + 7]);
+    }
+    for (let t = 16;t < 80; t++) {
+      const sigma1 = (rotr64(this.w[t - 2], 19) ^ rotr64(this.w[t - 2], 61) ^ this.w[t - 2] >> 6n) & 0xffffffffffffffffn;
+      const sigma0 = (rotr64(this.w[t - 15], 1) ^ rotr64(this.w[t - 15], 8) ^ this.w[t - 15] >> 7n) & 0xffffffffffffffffn;
+      this.w[t] = sigma1 + this.w[t - 7] + sigma0 + this.w[t - 16] & 0xffffffffffffffffn;
+    }
+    let a = this.H[0];
+    let b = this.H[1];
+    let c = this.H[2];
+    let d = this.H[3];
+    let e = this.H[4];
+    let f = this.H[5];
+    let g = this.H[6];
+    let h = this.H[7];
+    for (let t = 0;t < 80; t++) {
+      const sigma1 = (rotr64(e, 14) ^ rotr64(e, 18) ^ rotr64(e, 41)) & 0xffffffffffffffffn;
+      const ch = (e & f ^ ~e & g) & 0xffffffffffffffffn;
+      const t1 = h + sigma1 + ch + K3[t] + this.w[t] & 0xffffffffffffffffn;
+      const sigma0 = (rotr64(a, 28) ^ rotr64(a, 34) ^ rotr64(a, 39)) & 0xffffffffffffffffn;
+      const maj = (a & b ^ a & c ^ b & c) & 0xffffffffffffffffn;
+      const t2 = sigma0 + maj & 0xffffffffffffffffn;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 & 0xffffffffffffffffn;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 & 0xffffffffffffffffn;
+    }
+    this.H[0] = a + this.H[0] & 0xffffffffffffffffn;
+    this.H[1] = b + this.H[1] & 0xffffffffffffffffn;
+    this.H[2] = c + this.H[2] & 0xffffffffffffffffn;
+    this.H[3] = d + this.H[3] & 0xffffffffffffffffn;
+    this.H[4] = e + this.H[4] & 0xffffffffffffffffn;
+    this.H[5] = f + this.H[5] & 0xffffffffffffffffn;
+    this.H[6] = g + this.H[6] & 0xffffffffffffffffn;
+    this.H[7] = h + this.H[7] & 0xffffffffffffffffn;
+  }
+}
+
+class SHA512 {
+  blockSize = 128;
+  size = 64;
+  sha512 = new SharedSHA512(new BigUint64Array([
+    0x6a09e667f3bcc908n,
+    0xbb67ae8584caa73bn,
+    0x3c6ef372fe94f82bn,
+    0xa54ff53a5f1d36f1n,
+    0x510e527fade682d1n,
+    0x9b05688c2b3e6c1fn,
+    0x1f83d9abfb41bd6bn,
+    0x5be0cd19137e2179n
+  ]));
+  update(data) {
+    this.sha512.update(data);
+  }
+  digest() {
+    const result = new Uint8Array(64);
+    this.sha512.putDigest(result);
+    return result;
+  }
+}
+var K3 = new BigUint64Array([
+  0x428a2f98d728ae22n,
+  0x7137449123ef65cdn,
+  0xb5c0fbcfec4d3b2fn,
+  0xe9b5dba58189dbbcn,
+  0x3956c25bf348b538n,
+  0x59f111f1b605d019n,
+  0x923f82a4af194f9bn,
+  0xab1c5ed5da6d8118n,
+  0xd807aa98a3030242n,
+  0x12835b0145706fben,
+  0x243185be4ee4b28cn,
+  0x550c7dc3d5ffb4e2n,
+  0x72be5d74f27b896fn,
+  0x80deb1fe3b1696b1n,
+  0x9bdc06a725c71235n,
+  0xc19bf174cf692694n,
+  0xe49b69c19ef14ad2n,
+  0xefbe4786384f25e3n,
+  0x0fc19dc68b8cd5b5n,
+  0x240ca1cc77ac9c65n,
+  0x2de92c6f592b0275n,
+  0x4a7484aa6ea6e483n,
+  0x5cb0a9dcbd41fbd4n,
+  0x76f988da831153b5n,
+  0x983e5152ee66dfabn,
+  0xa831c66d2db43210n,
+  0xb00327c898fb213fn,
+  0xbf597fc7beef0ee4n,
+  0xc6e00bf33da88fc2n,
+  0xd5a79147930aa725n,
+  0x06ca6351e003826fn,
+  0x142929670a0e6e70n,
+  0x27b70a8546d22ffcn,
+  0x2e1b21385c26c926n,
+  0x4d2c6dfc5ac42aedn,
+  0x53380d139d95b3dfn,
+  0x650a73548baf63den,
+  0x766a0abb3c77b2a8n,
+  0x81c2c92e47edaee6n,
+  0x92722c851482353bn,
+  0xa2bfe8a14cf10364n,
+  0xa81a664bbc423001n,
+  0xc24b8b70d0f89791n,
+  0xc76c51a30654be30n,
+  0xd192e819d6ef5218n,
+  0xd69906245565a910n,
+  0xf40e35855771202an,
+  0x106aa07032bbd1b8n,
+  0x19a4c116b8d2d0c8n,
+  0x1e376c085141ab53n,
+  0x2748774cdf8eeb99n,
+  0x34b0bcb5e19b48a8n,
+  0x391c0cb3c5c95a63n,
+  0x4ed8aa4ae3418acbn,
+  0x5b9cca4f7763e373n,
+  0x682e6ff3d6b2b8a3n,
+  0x748f82ee5defb2fcn,
+  0x78a5636f43172f60n,
+  0x84c87814a1f0ab72n,
+  0x8cc702081a6439ecn,
+  0x90befffa23631e28n,
+  0xa4506cebde82bde9n,
+  0xbef9a3f7b2c67915n,
+  0xc67178f2e372532bn,
+  0xca273eceea26619cn,
+  0xd186b8c721c0c207n,
+  0xeada7dd6cde0eb1en,
+  0xf57d4f7fee6ed178n,
+  0x06f067aa72176fban,
+  0x0a637dc5a2c898a6n,
+  0x113f9804bef90daen,
+  0x1b710b35131c471bn,
+  0x28db77f523047d84n,
+  0x32caab7b40c72493n,
+  0x3c9ebe0a15c9bebcn,
+  0x431d67c49c100d4cn,
+  0x4cc5d4becb3e42b6n,
+  0x597f299cfc657e2an,
+  0x5fcb6fab3ad6faecn,
+  0x6c44198c4a475817n
+]);
+
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha384.js
+class SHA384 {
+  blockSize = 128;
+  size = 48;
+  sha512 = new SharedSHA512(new BigUint64Array([
+    0xcbbb9d5dc1059ed8n,
+    0x629a292a367cd507n,
+    0x9159015a3070dd17n,
+    0x152fecd8f70e5939n,
+    0x67332667ffc00b31n,
+    0x8eb44a8768581511n,
+    0xdb0c2e0d64f98fa7n,
+    0x47b5481dbefa4fa4n
+  ]));
+  update(data) {
+    this.sha512.update(data);
+  }
+  digest() {
+    const result = new Uint8Array(48);
+    this.sha512.putDigest(result);
+    return result;
+  }
+}
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha512_224.js
+class SHA512_224 {
+  blockSize = 128;
+  size = 28;
+  sha512 = new SharedSHA512(new BigUint64Array([
+    0x8c3d37c819544da2n,
+    0x73e1996689dcd4d6n,
+    0x1dfab7ae32ff9c82n,
+    0x679dd514582f9fcfn,
+    0x0f6d2b697bd44da8n,
+    0x77e36f7304c48942n,
+    0x3f9d85a86a1d36c8n,
+    0x1112e6ad91d692a1n
+  ]));
+  update(data) {
+    this.sha512.update(data);
+  }
+  digest() {
+    const result = new Uint8Array(32);
+    this.sha512.putDigest(result);
+    return result.slice(0, 28);
+  }
+}
+// ../../node_modules/.bun/@oslojs+crypto@1.0.0/node_modules/@oslojs/crypto/dist/sha2/sha512_256.js
+class SHA512_256 {
+  blockSize = 128;
+  size = 28;
+  sha512 = new SharedSHA512(new BigUint64Array([
+    0x22312194fc2bf72cn,
+    0x9f555fa3c84c64c2n,
+    0x2393b86b6f53b151n,
+    0x963877195940eabdn,
+    0x96283ee2a88effe3n,
+    0xbe5e1e2553863992n,
+    0x2b0199fc2c85b8aan,
+    0x0eb72ddc81c52ca2n
+  ]));
+  update(data) {
+    this.sha512.update(data);
+  }
+  digest() {
+    const result = new Uint8Array(32);
+    this.sha512.putDigest(result);
+    return result;
+  }
+}
+// ../../node_modules/.bun/@oslojs+webauthn@1.0.0/node_modules/@oslojs/webauthn/dist/auth.js
+var ClientDataType;
+(function(ClientDataType2) {
+  ClientDataType2[ClientDataType2["Get"] = 0] = "Get";
+  ClientDataType2[ClientDataType2["Create"] = 1] = "Create";
+})(ClientDataType || (ClientDataType = {}));
+var TokenBindingStatus;
+(function(TokenBindingStatus2) {
+  TokenBindingStatus2[TokenBindingStatus2["Supported"] = 0] = "Supported";
+  TokenBindingStatus2[TokenBindingStatus2["Present"] = 1] = "Present";
+})(TokenBindingStatus || (TokenBindingStatus = {}));
+function parseAuthenticatorData(encoded) {
+  if (encoded.byteLength < 37) {
+    throw new AuthenticatorDataParseError("Insufficient bytes");
+  }
+  const relyingPartyIdHash = encoded.slice(0, 32);
+  const flags = {
+    userPresent: (encoded[32] & 1) === 1,
+    userVerified: (encoded[32] >> 2 & 1) === 1
+  };
+  const signatureCounter = bigEndian.uint32(encoded, 33);
+  const includesAttestedCredentialData = (encoded[32] >> 6 & 1) === 1;
+  let credential = null;
+  if (includesAttestedCredentialData) {
+    if (encoded.byteLength < 37 + 18) {
+      throw new AuthenticatorDataParseError("Invalid credential data");
+    }
+    const aaguid = encoded.slice(37, 53);
+    const credentialIdLength = bigEndian.uint16(encoded, 53);
+    if (encoded.byteLength < 37 + 18 + credentialIdLength) {
+      throw new AuthenticatorDataParseError("Insufficient bytes");
+    }
+    const credentialId = encoded.slice(55, 55 + credentialIdLength);
+    let credentialPublicKey;
+    try {
+      [credentialPublicKey] = decodeCOSEPublicKey(encoded.slice(55 + credentialIdLength));
+    } catch (e) {
+      throw new AuthenticatorDataParseError("Failed to parse public key");
+    }
+    credential = {
+      authenticatorAAGUID: aaguid,
+      id: credentialId,
+      publicKey: credentialPublicKey
+    };
+  }
+  const authenticatorData = new AuthenticatorData(relyingPartyIdHash, flags, signatureCounter, credential, null);
+  return authenticatorData;
+}
+
+class AuthenticatorData {
+  relyingPartyIdHash;
+  userPresent;
+  userVerified;
+  signatureCounter;
+  credential;
+  extensions;
+  constructor(relyingPartyIdHash, flags, signatureCounter, credential, extensions) {
+    this.relyingPartyIdHash = relyingPartyIdHash;
+    this.userPresent = flags.userPresent;
+    this.userVerified = flags.userVerified;
+    this.signatureCounter = signatureCounter;
+    this.credential = credential;
+    this.extensions = extensions;
+  }
+  verifyRelyingPartyIdHash(relyingPartyId) {
+    const relyingPartyIdHash = sha256(new TextEncoder().encode(relyingPartyId));
+    return compareBytes(this.relyingPartyIdHash, relyingPartyIdHash);
+  }
+}
+
+class AuthenticatorDataParseError extends Error {
+  constructor(message) {
+    super(`Failed to parse authenticator data: ${message}`);
+  }
+}
+
+// ../../node_modules/.bun/@oslojs+webauthn@1.0.0/node_modules/@oslojs/webauthn/dist/attestation.js
+function parseAttestationObject(encoded) {
+  let decoded;
+  try {
+    decoded = decodeCBORToNativeValueNoLeftoverBytes(encoded, 4);
+  } catch {
+    throw new AttestationObjectParseError("Invalid CBOR data");
+  }
+  if (typeof decoded !== "object" || decoded === null) {
+    throw new AttestationObjectParseError("Invalid CBOR data");
+  }
+  if (!("fmt" in decoded) || typeof decoded.fmt !== "string") {
+    throw new AttestationObjectParseError("Invalid or missing property 'fmt'");
+  }
+  if (!("attStmt" in decoded) || typeof decoded.attStmt !== "object" || decoded.attStmt === null) {
+    throw new AttestationObjectParseError("Invalid or missing property 'attStmt'");
+  }
+  if (!("authData" in decoded) || !(decoded.authData instanceof Uint8Array)) {
+    throw new AttestationObjectParseError("Invalid or missing property 'authData'");
+  }
+  let attestationFormat;
+  if (decoded.fmt === "packed") {
+    attestationFormat = AttestationStatementFormat.Packed;
+  } else if (decoded.fmt === "tpm") {
+    attestationFormat = AttestationStatementFormat.TPM;
+  } else if (decoded.fmt === "android-key") {
+    attestationFormat = AttestationStatementFormat.AndroidKey;
+  } else if (decoded.fmt === "android-safetynet") {
+    attestationFormat = AttestationStatementFormat.AndroidSafetyNet;
+  } else if (decoded.fmt === "fido-u2f") {
+    attestationFormat = AttestationStatementFormat.FIDOU2F;
+  } else if (decoded.fmt === "none") {
+    attestationFormat = AttestationStatementFormat.None;
+  } else if (decoded.fmt === "apple") {
+    attestationFormat = AttestationStatementFormat.AppleAnonymous;
+  } else {
+    throw new AttestationObjectParseError(`Unsupported attestation statement format '${decoded.fmt}'`);
+  }
+  const attestationObject = {
+    authenticatorData: parseAuthenticatorData(decoded.authData),
+    attestationStatement: new AttestationStatement(attestationFormat, decoded.attStmt)
+  };
+  return attestationObject;
+}
+
+class AttestationObjectParseError extends Error {
+  constructor(message) {
+    super(`Failed to parse attestation object: ${message}`);
+  }
+}
+
+class AttestationStatement {
+  format;
+  decoded;
+  constructor(format, decoded) {
+    this.format = format;
+    this.decoded = decoded;
+  }
+  packed() {
+    if (this.format !== AttestationStatementFormat.Packed) {
+      throw new Error("Invalid format");
+    }
+    if (!("alg" in this.decoded) || typeof this.decoded.alg !== "number") {
+      throw new Error("Invalid or missing property 'alg'");
+    }
+    if (!("sig" in this.decoded) || !(this.decoded.sig instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'sig'");
+    }
+    let certificates = null;
+    if ("x5c" in this.decoded) {
+      if (!Array.isArray(this.decoded.x5c)) {
+        throw new Error("Invalid property 'x5c'");
+      }
+      if (this.decoded.x5c.length < 1) {
+        throw new Error("Invalid property 'x5c'");
+      }
+      certificates = [];
+      for (const certificate of this.decoded.x5c) {
+        if (!(certificate instanceof Uint8Array)) {
+          throw new Error("Invalid property 'x5c'");
+        }
+        certificates.push(certificate);
+      }
+    }
+    const statement = {
+      algorithm: this.decoded.alg,
+      signature: this.decoded.sig,
+      certificates
+    };
+    return statement;
+  }
+  tpm() {
+    if (this.format !== AttestationStatementFormat.TPM) {
+      throw new Error("Invalid format");
+    }
+    if (!("alg" in this.decoded) || typeof this.decoded.alg !== "number") {
+      throw new Error("Invalid or missing property 'alg'");
+    }
+    if (!("sig" in this.decoded) || !(this.decoded.sig instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'sig'");
+    }
+    if (!("x5c" in this.decoded) || !Array.isArray(this.decoded.x5c)) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    if (this.decoded.x5c.length < 1) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    const certificates = [];
+    for (const certificate of this.decoded.x5c) {
+      if (!(certificate instanceof Uint8Array)) {
+        throw new Error("Invalid or missing property 'x5c'");
+      }
+      certificates.push(certificate);
+    }
+    if (!("certInfo" in this.decoded) || !(this.decoded.certInfo instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'certInfo'");
+    }
+    if (!("pubArea" in this.decoded) || !(this.decoded.pubArea instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'pubArea'");
+    }
+    const statement = {
+      algorithm: this.decoded.alg,
+      signature: this.decoded.sig,
+      certificates,
+      attestation: this.decoded.certInfo,
+      publicKey: this.decoded.pubArea
+    };
+    return statement;
+  }
+  androidKey() {
+    if (this.format !== AttestationStatementFormat.AndroidKey) {
+      throw new Error("Invalid format");
+    }
+    if (!("alg" in this.decoded) || typeof this.decoded.alg !== "number") {
+      throw new Error("Invalid or missing property 'alg'");
+    }
+    if (!("sig" in this.decoded) || !(this.decoded.sig instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'sig'");
+    }
+    if (!("x5c" in this.decoded) || !Array.isArray(this.decoded.x5c)) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    if (this.decoded.x5c.length < 1) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    const certificates = [];
+    for (const certificate of this.decoded.x5c) {
+      if (!(certificate instanceof Uint8Array)) {
+        throw new Error("Invalid or missing property 'x5c'");
+      }
+      certificates.push(certificate);
+    }
+    const statement = {
+      algorithm: this.decoded.alg,
+      signature: this.decoded.sig,
+      certificates
+    };
+    return statement;
+  }
+  androidSafetyNet() {
+    if (this.format !== AttestationStatementFormat.AndroidKey) {
+      throw new Error("Invalid format");
+    }
+    if (!("ver" in this.decoded) || typeof this.decoded.ver !== "string") {
+      throw new Error("Invalid or missing property 'ver'");
+    }
+    if (!("response" in this.decoded) || !(this.decoded.response instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'response'");
+    }
+    const statement = {
+      version: this.decoded.ver,
+      response: this.decoded.response
+    };
+    return statement;
+  }
+  fidoU2F() {
+    if (this.format !== AttestationStatementFormat.FIDOU2F) {
+      throw new Error("Invalid format");
+    }
+    if (!("sig" in this.decoded) || !(this.decoded.sig instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'sig'");
+    }
+    if (!("x5c" in this.decoded) || !Array.isArray(this.decoded.x5c)) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    if (this.decoded.x5c.length !== 1) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    const certificate = this.decoded.x5c[0];
+    if (!(certificate instanceof Uint8Array)) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    const statement = {
+      signature: this.decoded.sig,
+      certificate
+    };
+    return statement;
+  }
+  appleAnonymous() {
+    if (this.format !== AttestationStatementFormat.AppleAnonymous) {
+      throw new Error("Invalid format");
+    }
+    if (!("x5c" in this.decoded) || !Array.isArray(this.decoded.x5c)) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    if (this.decoded.x5c.length < 1) {
+      throw new Error("Invalid or missing property 'x5c'");
+    }
+    const certificates = [];
+    for (const certificate of this.decoded.x5c) {
+      if (!(certificate instanceof Uint8Array)) {
+        throw new Error("Invalid or missing property 'x5c'");
+      }
+      certificates.push(certificate);
+    }
+    const statement = { certificates };
+    return statement;
+  }
+}
+var AttestationStatementFormat;
+(function(AttestationStatementFormat2) {
+  AttestationStatementFormat2[AttestationStatementFormat2["Packed"] = 0] = "Packed";
+  AttestationStatementFormat2[AttestationStatementFormat2["TPM"] = 1] = "TPM";
+  AttestationStatementFormat2[AttestationStatementFormat2["AndroidKey"] = 2] = "AndroidKey";
+  AttestationStatementFormat2[AttestationStatementFormat2["AndroidSafetyNet"] = 3] = "AndroidSafetyNet";
+  AttestationStatementFormat2[AttestationStatementFormat2["FIDOU2F"] = 4] = "FIDOU2F";
+  AttestationStatementFormat2[AttestationStatementFormat2["AppleAnonymous"] = 5] = "AppleAnonymous";
+  AttestationStatementFormat2[AttestationStatementFormat2["None"] = 6] = "None";
+})(AttestationStatementFormat || (AttestationStatementFormat = {}));
+// src/create/internal-handler.ts
+function setupPublicKeyCredentialRegistrationRequest(type, keyRequest, attestation, enabledExtensions, userVerification, pubKeyCredParams, additionalOptions) {
+  if (type === "platform" && enabledExtensions.includes("largeBlob")) {
+    let supportMode;
+    const largeBlobSupport = additionalOptions.largeBlobSupport;
+    if (largeBlobSupport === "required") {
+      supportMode = ASAuthorizationPublicKeyCredentialLargeBlobSupportRequirement.Required;
+    } else if (largeBlobSupport === "preferred") {
+      supportMode = ASAuthorizationPublicKeyCredentialLargeBlobSupportRequirement.Preferred;
+    } else {
+      console.warn("[electron-webauthn] largeBlobSupport is enabled but largeBlobSupport is not provided, skipping large blob support");
+    }
+    if (supportMode) {
+      const largeBlobInput = ASAuthorizationPublicKeyCredentialLargeBlobRegistrationInput.alloc().initWithSupportRequirement$(supportMode);
+      keyRequest.setLargeBlob$(largeBlobInput);
+    }
+  }
+  let attestationPreference = ASAuthorizationPublicKeyCredentialAttestationKind.None;
+  if (type === "security-key") {
+    if (attestation === "direct") {
+      attestationPreference = ASAuthorizationPublicKeyCredentialAttestationKind.Direct;
+    } else if (attestation === "enterprise") {
+      attestationPreference = ASAuthorizationPublicKeyCredentialAttestationKind.Enterprise;
+    } else if (attestation === "indirect") {
+      attestationPreference = ASAuthorizationPublicKeyCredentialAttestationKind.Indirect;
+    }
+  }
+  keyRequest.setAttestationPreference$(NSStringFromString(attestationPreference));
+  let userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreference.Preferred;
+  if (userVerification === "required") {
+    userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreference.Required;
+  } else if (userVerification === "discouraged") {
+    userVerificationPreference = ASAuthorizationPublicKeyCredentialUserVerificationPreference.Discouraged;
+  }
+  keyRequest.setUserVerificationPreference$(NSStringFromString(userVerificationPreference));
+  if (type === "platform" && additionalOptions.userDisplayName) {
+    const userDisplayName = NSStringFromString(additionalOptions.userDisplayName);
+    keyRequest.setDisplayName$(userDisplayName);
+  }
+  if (type === "security-key") {
+    const credentialParameters = [];
+    for (const param of pubKeyCredParams) {
+      if (param.type === "public-key" && param.algorithm === -7) {
+        const paramObj = ASAuthorizationPublicKeyCredentialParameters.alloc().initWithAlgorithm$(param.algorithm);
+        credentialParameters.push(paramObj);
+      }
+    }
+    const nsCredentialParameters = NSArrayFromObjects(credentialParameters);
+    keyRequest.setCredentialParameters$(nsCredentialParameters);
+  }
+  if (type === "platform" && enabledExtensions.includes("prf")) {
+    if (additionalOptions.prf) {
+      const inputValues = createPRFInput(additionalOptions.prf);
+      const prfInput = ASAuthorizationPublicKeyCredentialPRFRegistrationInput.alloc().initWithInputValues$(inputValues);
+      keyRequest.setPrf$(prfInput);
+    } else {
+      keyRequest.setPrf$(ASAuthorizationPublicKeyCredentialPRFRegistrationInput.checkForSupport());
+    }
+  }
+}
+function createCredentialInternal(rpid, challenge, username, userID, nativeWindowHandle, origin, timeout, enabledExtensions, attestation = "none", supportedAlgorithmIdentifiers = [], excludeCredentials, residentKeyRequired = false, preferredAuthenticatorAttachment = "all", userVerification = "preferred", additionalOptions = {}) {
+  const { promise, resolve, reject } = PromiseWithResolvers();
+  const NS_rpID = NSStringFromString(rpid);
+  const NS_challenge = NSDataFromBuffer(challenge);
+  const NS_username = NSStringFromString(username);
+  const NS_userID = NSDataFromBuffer(userID);
+  const requestArrayInput = [];
+  const allowSecurityKeyRequests = additionalOptions.allowSecurityKeyRequests ?? false;
+  const resolvedAuthenticatorAttachment = allowSecurityKeyRequests ? preferredAuthenticatorAttachment : "platform";
+  if (resolvedAuthenticatorAttachment === "all" || resolvedAuthenticatorAttachment === "platform") {
+    const platformProvider = ASAuthorizationPlatformPublicKeyCredentialProvider.alloc().initWithRelyingPartyIdentifier$(NS_rpID);
+    const platformKeyRequest = platformProvider.createCredentialRegistrationRequestWithChallenge$name$userID$(NS_challenge, NS_username, NS_userID);
+    setupPublicKeyCredentialRegistrationRequest("platform", platformKeyRequest, attestation, enabledExtensions, userVerification, supportedAlgorithmIdentifiers, additionalOptions);
+    requestArrayInput.push(platformKeyRequest);
+  }
+  if (resolvedAuthenticatorAttachment === "all" || resolvedAuthenticatorAttachment === "cross-platform") {
+    const securityKeyProvider = ASAuthorizationSecurityKeyPublicKeyCredentialProvider.alloc().initWithRelyingPartyIdentifier$(NS_rpID);
+    const securityKeyRequest = securityKeyProvider.createCredentialRegistrationRequestWithChallenge$displayName$name$userID$(NS_challenge, NSStringFromString(additionalOptions.userDisplayName || username), NS_username, NS_userID);
+    setupPublicKeyCredentialRegistrationRequest("security-key", securityKeyRequest, attestation, enabledExtensions, userVerification, supportedAlgorithmIdentifiers, additionalOptions);
+    requestArrayInput.push(securityKeyRequest);
+  }
+  const requestsArray = NSArrayFromObjects(requestArrayInput);
+  const authController = WebauthnCreateController.alloc().initWithAuthorizationRequests$(requestsArray);
+  const clientData = generateWebauthnClientData("webauthn.create", origin, challenge, additionalOptions.topFrameOrigin);
+  const { clientDataHash, clientDataBuffer } = generateClientDataInfo(clientData);
+  setControllerState(authController, clientDataHash, supportedAlgorithmIdentifiers, residentKeyRequired, excludeCredentials);
+  let isFinished = false;
+  let timeoutHandlerId = null;
+  const finished = (_success) => {
+    isFinished = true;
+    removeControllerState(authController);
+    if (timeoutHandlerId) {
+      clearTimeout(timeoutHandlerId);
+      timeoutHandlerId = null;
+    }
+  };
+  const delegate = createDelegate("ASAuthorizationControllerDelegate", {
+    authorizationController$didCompleteWithAuthorization$: (_, authorization) => {
+      const credential = authorization.credential();
+      console.log("Authorization succeeded:", credential);
+      const isPlatform = credential instanceof ASAuthorizationPlatformPublicKeyCredentialRegistration;
+      const isSecurityKey = credential instanceof ASAuthorizationSecurityKeyPublicKeyCredentialRegistration;
+      if (!isPlatform && !isSecurityKey) {
+        reject(new Error("Resulting credential is not a platform or security key credential"));
+        finished(false);
+        return;
+      }
+      const credentialIdBuffer = bufferFromNSDataDirect(credential.credentialID());
+      const attestationObjectBuffer = bufferFromNSDataDirect(credential.rawAttestationObject());
+      const attestation2 = parseAttestationObject(attestationObjectBuffer);
+      const publicKey = attestation2.authenticatorData.credential.publicKey;
+      const ec2Key = publicKey.ec2();
+      const publicKeySPKI = encodeEC2PublicKeyToSPKI(ec2Key.x, ec2Key.y);
+      const authenticatorData = Buffer.from(JSON.stringify(attestation2.authenticatorData));
+      let authenticatorAttachment = "cross-platform";
+      if (isPlatform && credential.attachment() === ASAuthorizationPublicKeyCredentialAttachment.Platform) {
+        authenticatorAttachment = "platform";
+      }
+      let isLargeBlobSupported = null;
+      if (enabledExtensions.includes("largeBlob")) {
+        const largeBlobOutput = credential.largeBlob();
+        if (largeBlobOutput) {
+          isLargeBlobSupported = largeBlobOutput.isSupported();
+        }
+      }
+      let prfFirst = null;
+      let prfSecond = null;
+      let isPRFSupported = null;
+      if (enabledExtensions.includes("prf")) {
+        const prfOutput = credential.prf();
+        if (prfOutput) {
+          const prfFirstData = prfOutput.first();
+          const prfSecondData = prfOutput.second();
+          if (prfFirstData) {
+            prfFirst = bufferFromNSDataDirect(prfFirstData);
+          }
+          if (prfSecondData) {
+            prfSecond = bufferFromNSDataDirect(prfSecondData);
+          }
+          isPRFSupported = prfOutput.isSupported();
+        }
+      }
+      const data = {
+        credentialId: credentialIdBuffer,
+        clientDataJSON: clientDataBuffer,
+        attestationObject: attestationObjectBuffer,
+        authenticatorData,
+        attachment: authenticatorAttachment,
+        transports: ["hybrid", "internal"],
+        isResidentKey: true,
+        publicKeyAlgorithm: publicKey.algorithm(),
+        publicKey: publicKeySPKI,
+        isLargeBlobSupported,
+        isPRFSupported,
+        prfFirst,
+        prfSecond
+      };
+      resolve(data);
+      finished(true);
+    },
+    authorizationController$didCompleteWithError$: (_, error) => {
+      const errorMessage = error.localizedDescription().UTF8String();
+      reject(new Error(errorMessage));
+      finished(false);
+    }
+  });
+  authController.setDelegate$(delegate);
+  const presentationContextProvider = createPresentationContextProviderFromNativeWindowHandle(nativeWindowHandle);
+  authController.setPresentationContextProvider$(presentationContextProvider);
+  authController.performRequests();
+  timeoutHandlerId = setTimeout(() => {
+    if (isFinished)
+      return;
+    authController.cancel();
+  }, timeout);
+  return promise;
+}
+
+// src/create/handler.ts
+function getExtensionsConfiguration2(extensionsData) {
+  if (!(extensionsData && typeof extensionsData === "object")) {
+    return {
+      extensions: []
+    };
+  }
+  const extensions = [];
+  let largeBlobSupport;
+  if (isObject(extensionsData.largeBlob)) {
+    extensions.push("largeBlob");
+    const largeBlobConfig = extensionsData.largeBlob;
+    if (largeBlobConfig.support === "required") {
+      largeBlobSupport = "required";
+    } else if (largeBlobConfig.support === "preferred") {
+      largeBlobSupport = "preferred";
+    }
+  }
+  let prf;
+  if (isObject(extensionsData.prf)) {
+    const prfEval = extensionsData.prf.eval;
+    if (prfEval) {
+      const first = bufferSourceToBuffer(prfEval.first);
+      const second = bufferSourceToBuffer(prfEval.second);
+      if (first) {
+        prf = {
+          first: first ? first : null,
+          second: second ? second : undefined
+        };
+      } else {
+        console.warn("[electron-webauthn] prf is enabled but prf.first is not valid, skipping PRF evaluation");
+      }
+    }
+  }
+  return {
+    extensions,
+    largeBlobSupport,
+    prf
+  };
+}
+async function createCredential(publicKeyOptions, additionalOptions) {
+  if (!publicKeyOptions) {
+    return null;
+  }
+  const rpInfo = publicKeyOptions.rp;
+  if (!isObject(rpInfo)) {
+    return { success: false, error: "TypeError" };
+  }
+  let rpId = rpInfo.id;
+  if (!rpId) {
+    try {
+      const url = new URL(additionalOptions.currentOrigin);
+      rpId = url.hostname;
+    } catch {}
+  }
+  if (!isString(rpId)) {
+    return { success: false, error: "TypeError" };
+  }
+  let timeout = publicKeyOptions.timeout;
+  if (!isNumber(timeout) || timeout <= 0) {
+    timeout = 10 * 60 * 1000;
+  } else if (timeout > 60 * 60 * 1000) {
+    timeout = 60 * 60 * 1000;
+  }
+  const challenge = bufferSourceToBuffer(publicKeyOptions.challenge);
+  if (!challenge) {
+    return { success: false, error: "TypeError" };
+  }
+  if (!isObject(publicKeyOptions.user)) {
+    return { success: false, error: "TypeError" };
+  }
+  const userName = publicKeyOptions.user.name;
+  const userDisplayName = publicKeyOptions.user.displayName;
+  if (!isString(userName) || !isString(userDisplayName)) {
+    return { success: false, error: "TypeError" };
+  }
+  const userID = bufferSourceToBuffer(publicKeyOptions.user.id);
+  if (!userID) {
+    return { success: false, error: "TypeError" };
+  }
+  const attestationPreference = publicKeyOptions.attestation;
+  if (attestationPreference && !isString(attestationPreference)) {
+    return { success: false, error: "TypeError" };
+  }
+  const pubKeyCredParams = publicKeyOptions.pubKeyCredParams;
+  const supportedAlgorithmIdentifiers = [];
+  if (pubKeyCredParams) {
+    if (Array.isArray(pubKeyCredParams)) {
+      for (const param of pubKeyCredParams) {
+        if (!isObject(param))
+          continue;
+        if (!isNumber(param.alg))
+          continue;
+        supportedAlgorithmIdentifiers.push({
+          type: "public-key",
+          algorithm: param.alg
+        });
+      }
+    } else {
+      return { success: false, error: "TypeError" };
+    }
+  }
+  if (supportedAlgorithmIdentifiers.length === 0) {
+    supportedAlgorithmIdentifiers.push({
+      type: "public-key",
+      algorithm: -7
+    });
+    supportedAlgorithmIdentifiers.push({
+      type: "public-key",
+      algorithm: -257
+    });
+  }
+  const excludeCredentials = [];
+  if (publicKeyOptions.excludeCredentials && Array.isArray(publicKeyOptions.excludeCredentials)) {
+    for (const excludeCredential of publicKeyOptions.excludeCredentials) {
+      if (!isObject(excludeCredential))
+        continue;
+      if (excludeCredential.type !== "public-key")
+        continue;
+      const idBuffer = bufferSourceToBuffer(excludeCredential.id);
+      if (!idBuffer)
+        continue;
+      excludeCredentials.push({
+        id: idBuffer,
+        transports: excludeCredential.transports
+      });
+    }
+  }
+  const { extensions, largeBlobSupport, prf } = getExtensionsConfiguration2(publicKeyOptions.extensions);
+  let residentKeyRequired = false;
+  let userVerificationPreference = "preferred";
+  let preferredAuthenticatorAttachment = "all";
+  if (publicKeyOptions.authenticatorSelection) {
+    if (publicKeyOptions.authenticatorSelection.residentKey === "required") {
+      residentKeyRequired = true;
+    } else if (publicKeyOptions.authenticatorSelection.requireResidentKey) {
+      residentKeyRequired = true;
+    }
+    const userVerifyParam = publicKeyOptions.authenticatorSelection.userVerification;
+    if (userVerifyParam === "required") {
+      userVerificationPreference = "required";
+    } else if (userVerifyParam === "discouraged") {
+      userVerificationPreference = "discouraged";
+    } else {
+      userVerificationPreference = "preferred";
+    }
+    const attachment = publicKeyOptions.authenticatorSelection.authenticatorAttachment;
+    if (attachment === "cross-platform") {
+      preferredAuthenticatorAttachment = "cross-platform";
+    } else if (attachment === "platform") {
+      preferredAuthenticatorAttachment = "platform";
+    }
+  }
+  const { currentOrigin, topFrameOrigin, isPublicSuffix, nativeWindowHandle } = additionalOptions;
+  const isRpIdAllowed = isRpIdAllowedForOrigin(currentOrigin, rpId, {
+    isPublicSuffix
+  });
+  if (!isRpIdAllowed.ok) {
+    return { success: false, error: "NotAllowedError" };
+  }
+  let errorResult = null;
+  const result = await createCredentialInternal(rpId, challenge, userName, userID, nativeWindowHandle, currentOrigin, timeout, extensions, attestationPreference, supportedAlgorithmIdentifiers, excludeCredentials, residentKeyRequired, preferredAuthenticatorAttachment, userVerificationPreference, {
+    allowSecurityKeyRequests: additionalOptions.allowSecurityKeyRequests ?? false,
+    topFrameOrigin,
+    largeBlobSupport,
+    prf
+  }).catch((error) => {
+    errorResult = error;
+    if (error.message.includes("(com.apple.AuthenticationServices.AuthorizationError error 1006.)")) {
+      return "InvalidStateError";
+    }
+    if (error.message.startsWith("The operation couldn’t be completed.")) {
+      return "NotAllowedError";
+    }
+    return null;
+  });
+  if (typeof result === "string") {
+    return { success: false, error: result, errorObject: errorResult };
+  }
+  const data = {
+    credentialId: bufferToBase64Url(result.credentialId),
+    clientDataJSON: bufferToBase64Url(result.clientDataJSON),
+    attestationObject: bufferToBase64Url(result.attestationObject),
+    authData: bufferToBase64Url(result.authenticatorData),
+    publicKey: bufferToBase64Url(result.publicKey),
+    publicKeyAlgorithm: result.publicKeyAlgorithm,
+    transports: result.transports,
+    extensions: {}
+  };
+  if (publicKeyOptions.extensions?.credProps) {
+    data.extensions.credProps = {
+      rk: result.isResidentKey
+    };
+  }
+  if (result.isLargeBlobSupported !== null) {
+    data.extensions.largeBlob = {
+      supported: result.isLargeBlobSupported
+    };
+  }
+  if (result.isPRFSupported !== null) {
+    const prfFirst = result.prfFirst;
+    const prfSecond = result.prfSecond;
+    data.extensions.prf = {
+      enabled: result.isPRFSupported,
+      results: {
+        first: prfFirst ? bufferToBase64Url(prfFirst) : undefined,
+        second: prfSecond ? bufferToBase64Url(prfSecond) : undefined
+      }
+    };
+  }
+  return { success: true, data };
+}
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/AuthenticationServices/blocks.js
+import { typedBlock } from "objc-js";
+function platformCredentialsForRelyingParty$completionHandler$Block(fn) {
+  return typedBlock("@?<v@?@>", fn);
+}
+function requestAuthorizationForPublicKeyCredentials$Block(fn) {
+  return typedBlock("@?<v@?q>", fn);
+}
+
+// src/helpers/passkey-authorization.ts
+function defaultPasskeyAuthorizationManagerFactory() {
+  return ASAuthorizationWebBrowserPublicKeyCredentialManager.alloc().init();
+}
+var passkeyAuthorizationManagerFactory = defaultPasskeyAuthorizationManagerFactory;
+function createPasskeyAuthorizationManager() {
+  return passkeyAuthorizationManagerFactory();
+}
+function normalizeAuthorizationStatus(rawState) {
+  switch (rawState) {
+    case ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState.Authorized:
+      return "authorized";
+    case ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState.Denied:
+      return "denied";
+    case ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState.NotDetermined:
+      return "notDetermined";
+    default:
+      throw new Error(`Unknown passkey authorization state: ${rawState}`);
+  }
+}
+async function requestAuthorization(manager) {
+  const rawState = await new Promise((resolve) => {
+    const block = requestAuthorizationForPublicKeyCredentials$Block((nextState) => {
+      resolve(nextState);
+    });
+    manager.requestAuthorizationForPublicKeyCredentials$(block);
+  });
+  return normalizeAuthorizationStatus(rawState);
+}
+async function resolvePasskeyAuthorization({
+  requestIfNeeded,
+  manager
+}) {
+  const authorizationManager = manager ?? createPasskeyAuthorizationManager();
+  const currentStatus = normalizeAuthorizationStatus(authorizationManager.authorizationStateForPlatformCredentials());
+  if (currentStatus !== "notDetermined" || !requestIfNeeded) {
+    return currentStatus;
+  }
+  return requestAuthorization(authorizationManager);
+}
+function normalizeAuthorizationError(error) {
+  return {
+    success: false,
+    error: error instanceof Error ? error : new Error(String(error))
+  };
+}
+async function getListPasskeyAuthorizationStatus() {
+  try {
+    return {
+      success: true,
+      status: await resolvePasskeyAuthorization({ requestIfNeeded: false })
+    };
+  } catch (error) {
+    return normalizeAuthorizationError(error);
+  }
+}
+async function requestListPasskeyAuthorization() {
+  try {
+    return {
+      success: true,
+      status: await resolvePasskeyAuthorization({ requestIfNeeded: true })
+    };
+  } catch (error) {
+    return normalizeAuthorizationError(error);
+  }
+}
+
+// ../../node_modules/.bun/objcjs-types@0.8.0+2a14cf54a30f3115/node_modules/objcjs-types/dist/osversion.js
+var cached;
+function getOSVersion() {
+  if (cached !== undefined)
+    return cached;
+  const raw = NSProcessInfo.processInfo().operatingSystemVersion();
+  cached = { major: raw.field0, minor: raw.field1, patch: raw.field2 };
+  return cached;
+}
+function compareVersions(a, b) {
+  if (a.major !== b.major)
+    return a.major - b.major;
+  if (a.minor !== b.minor)
+    return a.minor - b.minor;
+  return a.patch - b.patch;
+}
+function isAtLeast(target) {
+  return compareVersions(getOSVersion(), target) >= 0;
+}
+function version(major, minor = 0, patch = 0) {
+  return { major, minor, patch };
+}
+function formatVersion(v) {
+  return `${v.major}.${v.minor}.${v.patch}`;
+}
+var macOS = {
+  Tahoe: version(26),
+  Sequoia: version(15),
+  Sonoma: version(14),
+  Ventura: version(13),
+  Monterey: version(12),
+  BigSur: version(11),
+  Catalina: version(10, 15),
+  Mojave: version(10, 14),
+  HighSierra: version(10, 13),
+  Sierra: version(10, 12)
+};
+
+// src/list/support.ts
+var listPasskeysSupportOverride = null;
+function ensureListPasskeysSupported() {
+  const isSupported = listPasskeysSupportOverride === null ? isAtLeast(version(13, 3)) : listPasskeysSupportOverride;
+  if (isSupported) {
+    return;
+  }
+  const currentVersion = getOSVersion();
+  throw new Error(`Passkey listing requires macOS 13.3 or later (current: ${formatVersion(currentVersion)})`);
+}
+
+// src/list/handler.ts
+var LOGGING_ENABLED = false;
+function log(...args) {
+  if (!LOGGING_ENABLED)
+    return;
+  console.log(...args);
+}
+var AUTHORIZATION_DENIED_ERROR = "Authorization DENIED - user must grant permission in System Settings > Privacy & Security";
+var AUTHORIZATION_NOT_DETERMINED_ERROR = "Authorization not determined. Call requestListPasskeyAuthorization() first or pass { requestAuthorization: true } to listPasskeys().";
+async function getPlatformCredentials(manager, relyingPartyId) {
+  const rpIdString = NSStringFromString(relyingPartyId);
+  log(`[listPasskeys] Calling platformCredentialsForRelyingParty: ${relyingPartyId}`);
+  return new Promise((resolve) => {
+    const block = platformCredentialsForRelyingParty$completionHandler$Block((credentialsArray) => {
+      resolve(credentialsArray);
+    });
+    manager.platformCredentialsForRelyingParty$completionHandler$(rpIdString, block);
+  });
+}
+function isExpectedListPasskeysError(error) {
+  return error.message === AUTHORIZATION_DENIED_ERROR || error.message === AUTHORIZATION_NOT_DETERMINED_ERROR;
+}
+function getListPasskeyAuthorizationStatus2() {
+  return getListPasskeyAuthorizationStatus();
+}
+function requestListPasskeyAuthorization2() {
+  return requestListPasskeyAuthorization();
+}
+async function listPasskeys(relyingPartyId, options = {}) {
+  try {
+    ensureListPasskeysSupported();
+    const manager = createPasskeyAuthorizationManager();
+    const requestAuthorization2 = options.requestAuthorization ?? true;
+    const authorizationStatus = await resolvePasskeyAuthorization({
+      requestIfNeeded: requestAuthorization2,
+      manager
+    });
+    log(`[listPasskeys] Authorization status: ${authorizationStatus}`);
+    if (authorizationStatus === "denied") {
+      throw new Error(AUTHORIZATION_DENIED_ERROR);
+    }
+    if (authorizationStatus === "notDetermined") {
+      throw new Error(AUTHORIZATION_NOT_DETERMINED_ERROR);
+    }
+    const credentialsArray = await getPlatformCredentials(manager, relyingPartyId);
+    if (!credentialsArray) {
+      throw new Error("Unknown error occurred");
+    }
+    const count = credentialsArray.count();
+    log(`[listPasskeys] platformCredentials returned ${count} entries`);
+    const credentials = [];
+    for (let i = 0;i < count; i++) {
+      const cred = credentialsArray.objectAtIndex$(i);
+      const credentialIdData = cred.credentialID();
+      const userName = cred.name().UTF8String();
+      const userHandleData = cred.userHandle();
+      const credentialId = bufferToBase64Url(bufferFromNSDataDirect(credentialIdData));
+      const userHandle = bufferToBase64Url(bufferFromNSDataDirect(userHandleData));
+      log(`[listPasskeys] Found credential: name=${userName}, id=${credentialId.substring(0, 20)}...`);
+      credentials.push({
+        id: credentialId,
+        rpId: relyingPartyId,
+        userName,
+        userHandle
+      });
+    }
+    log(`[listPasskeys] Returning ${credentials.length} results`);
+    return {
+      success: true,
+      credentials
+    };
+  } catch (error) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    if (!isExpectedListPasskeysError(normalizedError)) {
+      console.error("[listPasskeys] ", normalizedError);
+    }
+    return {
+      success: false,
+      error: normalizedError
+    };
+  }
+}
+export {
+  requestListPasskeyAuthorization2 as requestListPasskeyAuthorization,
+  listPasskeys,
+  getListPasskeyAuthorizationStatus2 as getListPasskeyAuthorizationStatus,
+  getCredential,
+  createCredential
+};