@capgo/capacitor-passkey 8.2.0

package/dist/plugin.js

@@ -0,0 +1,710 @@
+var capacitorPasskey = (function (exports, core) {
+    'use strict';
+
+    const PASSKEY_TYPE = 'public-key';
+    function createNativeRequest(options) {
+        if ('mediation' in options) {
+            const getOptions = options;
+            return {
+                origin: resolveOrigin(getOptions.origin, getOptions.publicKey.rpId),
+                requestJson: JSON.stringify(normalizeRequestOptionsJSON(getOptions.publicKey, getOptions.origin)),
+            };
+        }
+        const createOptions = options;
+        return {
+            origin: resolveOrigin(createOptions.origin, createOptions.publicKey.rp.id),
+            requestJson: JSON.stringify(normalizeCreationOptionsJSON(createOptions.publicKey, createOptions.origin)),
+        };
+    }
+    function webAuthnCreationOptionsToJSON(options, origin) {
+        var _a;
+        return normalizeCreationOptionsJSON({
+            attestation: options.attestation,
+            authenticatorSelection: options.authenticatorSelection
+                ? {
+                    authenticatorAttachment: options.authenticatorSelection.authenticatorAttachment,
+                    requireResidentKey: options.authenticatorSelection.requireResidentKey,
+                    residentKey: options.authenticatorSelection.residentKey,
+                    userVerification: options.authenticatorSelection.userVerification,
+                }
+                : undefined,
+            challenge: encodeBase64Url(options.challenge),
+            excludeCredentials: (_a = options.excludeCredentials) === null || _a === void 0 ? void 0 : _a.map(descriptorToJSON),
+            extensions: cloneExtensions(options.extensions),
+            pubKeyCredParams: options.pubKeyCredParams.map((entry) => ({
+                alg: entry.alg,
+                type: entry.type,
+            })),
+            rp: {
+                id: options.rp.id,
+                name: options.rp.name,
+            },
+            timeout: options.timeout,
+            user: {
+                displayName: options.user.displayName,
+                id: encodeBase64Url(options.user.id),
+                name: options.user.name,
+            },
+        }, origin);
+    }
+    function webAuthnRequestOptionsToJSON(options, origin) {
+        var _a;
+        return normalizeRequestOptionsJSON({
+            allowCredentials: (_a = options.allowCredentials) === null || _a === void 0 ? void 0 : _a.map(descriptorToJSON),
+            challenge: encodeBase64Url(options.challenge),
+            extensions: cloneExtensions(options.extensions),
+            rpId: options.rpId,
+            timeout: options.timeout,
+            userVerification: options.userVerification,
+        }, origin);
+    }
+    function normalizeCreationOptionsJSON(options, origin) {
+        var _a, _b;
+        const rpId = (_a = options.rp.id) !== null && _a !== void 0 ? _a : deriveRpId(resolveOrigin(origin, options.rp.id));
+        if (!rpId) {
+            throw createPasskeyDomException('DataError', 'A relying party id or HTTPS origin is required.');
+        }
+        return Object.assign(Object.assign({}, options), { excludeCredentials: (_b = options.excludeCredentials) === null || _b === void 0 ? void 0 : _b.map(descriptorToJSON), pubKeyCredParams: options.pubKeyCredParams.map((entry) => {
+                var _a;
+                return ({
+                    alg: entry.alg,
+                    type: (_a = entry.type) !== null && _a !== void 0 ? _a : PASSKEY_TYPE,
+                });
+            }), rp: Object.assign(Object.assign({}, options.rp), { id: rpId }) });
+    }
+    function normalizeRequestOptionsJSON(options, origin) {
+        var _a, _b;
+        const rpId = (_a = options.rpId) !== null && _a !== void 0 ? _a : deriveRpId(resolveOrigin(origin, options.rpId));
+        return Object.assign(Object.assign({}, options), { allowCredentials: (_b = options.allowCredentials) === null || _b === void 0 ? void 0 : _b.map(descriptorToJSON), rpId });
+    }
+    function browserCreationOptionsFromJSON(options) {
+        var _a, _b;
+        return {
+            attestation: options.attestation,
+            authenticatorSelection: options.authenticatorSelection
+                ? {
+                    authenticatorAttachment: options.authenticatorSelection.authenticatorAttachment,
+                    requireResidentKey: options.authenticatorSelection.requireResidentKey,
+                    residentKey: options.authenticatorSelection.residentKey,
+                    userVerification: options.authenticatorSelection.userVerification,
+                }
+                : undefined,
+            challenge: decodeBase64Url(options.challenge),
+            excludeCredentials: (_a = options.excludeCredentials) === null || _a === void 0 ? void 0 : _a.map(jsonDescriptorToBrowser),
+            extensions: cloneExtensions(options.extensions),
+            pubKeyCredParams: options.pubKeyCredParams.map((entry) => {
+                var _a;
+                return ({
+                    alg: entry.alg,
+                    type: (_a = entry.type) !== null && _a !== void 0 ? _a : PASSKEY_TYPE,
+                });
+            }),
+            rp: {
+                id: options.rp.id,
+                name: options.rp.name,
+            },
+            timeout: options.timeout,
+            user: {
+                displayName: (_b = options.user.displayName) !== null && _b !== void 0 ? _b : options.user.name,
+                id: decodeBase64Url(options.user.id),
+                name: options.user.name,
+            },
+        };
+    }
+    function browserRequestOptionsFromJSON(options) {
+        var _a;
+        return {
+            allowCredentials: (_a = options.allowCredentials) === null || _a === void 0 ? void 0 : _a.map(jsonDescriptorToBrowser),
+            challenge: decodeBase64Url(options.challenge),
+            extensions: cloneExtensions(options.extensions),
+            rpId: options.rpId,
+            timeout: options.timeout,
+            userVerification: options.userVerification,
+        };
+    }
+    async function browserRegistrationToJSON(credential) {
+        var _a;
+        const publicKeyCredential = expectPublicKeyCredential(credential, 'registration');
+        const response = publicKeyCredential.response;
+        const nativeJson = credentialWithToJSON(publicKeyCredential);
+        if (nativeJson && 'attestationObject' in nativeJson.response) {
+            return normalizeRegistrationCredential(nativeJson);
+        }
+        return {
+            authenticatorAttachment: normalizeAttachment(publicKeyCredential.authenticatorAttachment),
+            clientExtensionResults: clientExtensionResultsToRecord((_a = publicKeyCredential.getClientExtensionResults) === null || _a === void 0 ? void 0 : _a.call(publicKeyCredential)),
+            id: publicKeyCredential.id,
+            rawId: encodeBase64Url(publicKeyCredential.rawId),
+            response: {
+                attestationObject: encodeBase64Url(response.attestationObject),
+                clientDataJSON: encodeBase64Url(response.clientDataJSON),
+                publicKey: response.getPublicKey ? nullableBufferToOptionalBase64Url(response.getPublicKey()) : undefined,
+                publicKeyAlgorithm: response.getPublicKeyAlgorithm ? response.getPublicKeyAlgorithm() : undefined,
+                transports: response.getTransports ? response.getTransports() : undefined,
+            },
+            type: PASSKEY_TYPE,
+        };
+    }
+    async function browserAuthenticationToJSON(credential) {
+        var _a;
+        const publicKeyCredential = expectPublicKeyCredential(credential, 'authentication');
+        const response = publicKeyCredential.response;
+        const nativeJson = credentialWithToJSON(publicKeyCredential);
+        if (nativeJson && 'authenticatorData' in nativeJson.response) {
+            return normalizeAuthenticationCredential(nativeJson);
+        }
+        return {
+            authenticatorAttachment: normalizeAttachment(publicKeyCredential.authenticatorAttachment),
+            clientExtensionResults: clientExtensionResultsToRecord((_a = publicKeyCredential.getClientExtensionResults) === null || _a === void 0 ? void 0 : _a.call(publicKeyCredential)),
+            id: publicKeyCredential.id,
+            rawId: encodeBase64Url(publicKeyCredential.rawId),
+            response: {
+                authenticatorData: encodeBase64Url(response.authenticatorData),
+                clientDataJSON: encodeBase64Url(response.clientDataJSON),
+                signature: encodeBase64Url(response.signature),
+                userHandle: nullableBufferToBase64Url(response.userHandle),
+            },
+            type: PASSKEY_TYPE,
+        };
+    }
+    function credentialFromJSON(credential) {
+        const shimCredential = new PasskeyPublicKeyCredential(credential);
+        if (typeof globalThis.PublicKeyCredential === 'function') {
+            Object.setPrototypeOf(shimCredential, globalThis.PublicKeyCredential.prototype);
+        }
+        return shimCredential;
+    }
+    function parseCreationOptionsFromJSON(options) {
+        return browserCreationOptionsFromJSON(normalizeCreationOptionsJSON(options));
+    }
+    function parseRequestOptionsFromJSON(options) {
+        return browserRequestOptionsFromJSON(normalizeRequestOptionsJSON(options));
+    }
+    function decodeBase64Url(value) {
+        const bytes = base64UrlToBytes(value);
+        return bytes.slice().buffer;
+    }
+    function encodeBase64Url(value) {
+        if (typeof value === 'undefined' || value === null) {
+            return '';
+        }
+        const bytes = toUint8Array(value);
+        let binary = '';
+        bytes.forEach((byte) => {
+            binary += String.fromCharCode(byte);
+        });
+        return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/u, '');
+    }
+    function resolveOrigin(explicitOrigin, rpId) {
+        if (explicitOrigin) {
+            return explicitOrigin;
+        }
+        if (typeof globalThis.location !== 'undefined' && /^https?:$/u.test(globalThis.location.protocol)) {
+            return globalThis.location.origin;
+        }
+        if (rpId) {
+            return `https://${rpId}`;
+        }
+        return undefined;
+    }
+    function createPasskeyDomException(name, message) {
+        if (typeof DOMException !== 'undefined') {
+            return new DOMException(message, name);
+        }
+        const error = new Error(message);
+        error.name = name;
+        return error;
+    }
+    function abortIfNeeded(signal) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw createPasskeyDomException('AbortError', 'The passkey request was aborted.');
+        }
+    }
+    function normalizePluginError(error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        const message = typeof error === 'object' && error && 'message' in error ? String(error.message) : String(error);
+        const name = resolveErrorName(error);
+        return createPasskeyDomException(name, message);
+    }
+    function credentialWithToJSON(credential) {
+        const toJSON = credential.toJSON;
+        if (typeof toJSON !== 'function') {
+            return null;
+        }
+        const json = toJSON();
+        if (!json || typeof json !== 'object') {
+            return null;
+        }
+        const response = json.response;
+        if (!response) {
+            return null;
+        }
+        if ('attestationObject' in response) {
+            return normalizeRegistrationCredential(json);
+        }
+        if ('authenticatorData' in response) {
+            return normalizeAuthenticationCredential(json);
+        }
+        return null;
+    }
+    function normalizeRegistrationCredential(credential) {
+        var _a, _b, _c, _d, _e;
+        return {
+            authenticatorAttachment: normalizeAttachment(credential.authenticatorAttachment),
+            clientExtensionResults: (_a = credential.clientExtensionResults) !== null && _a !== void 0 ? _a : {},
+            id: String((_b = credential.id) !== null && _b !== void 0 ? _b : ''),
+            rawId: String((_d = (_c = credential.rawId) !== null && _c !== void 0 ? _c : credential.id) !== null && _d !== void 0 ? _d : ''),
+            response: normalizeAttestationResponse((_e = credential.response) !== null && _e !== void 0 ? _e : {}),
+            type: PASSKEY_TYPE,
+        };
+    }
+    function normalizeAuthenticationCredential(credential) {
+        var _a, _b, _c, _d, _e;
+        return {
+            authenticatorAttachment: normalizeAttachment(credential.authenticatorAttachment),
+            clientExtensionResults: (_a = credential.clientExtensionResults) !== null && _a !== void 0 ? _a : {},
+            id: String((_b = credential.id) !== null && _b !== void 0 ? _b : ''),
+            rawId: String((_d = (_c = credential.rawId) !== null && _c !== void 0 ? _c : credential.id) !== null && _d !== void 0 ? _d : ''),
+            response: normalizeAssertionResponse((_e = credential.response) !== null && _e !== void 0 ? _e : {}),
+            type: PASSKEY_TYPE,
+        };
+    }
+    function normalizeAttestationResponse(response) {
+        var _a, _b;
+        return {
+            attestationObject: String((_a = response.attestationObject) !== null && _a !== void 0 ? _a : ''),
+            clientDataJSON: String((_b = response.clientDataJSON) !== null && _b !== void 0 ? _b : ''),
+            publicKey: response.publicKey,
+            publicKeyAlgorithm: response.publicKeyAlgorithm,
+            transports: response.transports,
+        };
+    }
+    function normalizeAssertionResponse(response) {
+        var _a, _b, _c;
+        return {
+            authenticatorData: String((_a = response.authenticatorData) !== null && _a !== void 0 ? _a : ''),
+            clientDataJSON: String((_b = response.clientDataJSON) !== null && _b !== void 0 ? _b : ''),
+            signature: String((_c = response.signature) !== null && _c !== void 0 ? _c : ''),
+            userHandle: typeof response.userHandle === 'undefined' ? null : response.userHandle,
+        };
+    }
+    function expectPublicKeyCredential(credential, flow) {
+        if (!credential || !(credential instanceof PublicKeyCredential)) {
+            throw createPasskeyDomException('InvalidStateError', `The browser did not return a ${flow} credential.`);
+        }
+        return credential;
+    }
+    function descriptorToJSON(descriptor) {
+        var _a;
+        return {
+            id: typeof descriptor.id === 'string' ? descriptor.id : encodeBase64Url(descriptor.id),
+            transports: descriptor.transports ? [...descriptor.transports] : undefined,
+            type: (_a = descriptor.type) !== null && _a !== void 0 ? _a : PASSKEY_TYPE,
+        };
+    }
+    function jsonDescriptorToBrowser(descriptor) {
+        var _a;
+        return {
+            id: decodeBase64Url(descriptor.id),
+            transports: descriptor.transports,
+            type: (_a = descriptor.type) !== null && _a !== void 0 ? _a : PASSKEY_TYPE,
+        };
+    }
+    function cloneExtensions(extensions) {
+        if (!extensions) {
+            return undefined;
+        }
+        return JSON.parse(JSON.stringify(extensions));
+    }
+    function nullableBufferToBase64Url(value) {
+        if (typeof value === 'undefined') {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        return encodeBase64Url(value);
+    }
+    function nullableBufferToOptionalBase64Url(value) {
+        const encoded = nullableBufferToBase64Url(value);
+        return encoded !== null && encoded !== void 0 ? encoded : undefined;
+    }
+    function deriveRpId(origin) {
+        if (!origin) {
+            return undefined;
+        }
+        try {
+            return new URL(origin).hostname;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    function base64UrlToBytes(value) {
+        const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
+        const padding = normalized.length % 4 === 0 ? '' : '='.repeat(4 - (normalized.length % 4));
+        const binary = atob(`${normalized}${padding}`);
+        const bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        return bytes;
+    }
+    function toUint8Array(value) {
+        if (Array.isArray(value)) {
+            return Uint8Array.from(value);
+        }
+        if (ArrayBuffer.isView(value)) {
+            return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        }
+        return new Uint8Array(value);
+    }
+    function normalizeAttachment(value) {
+        if (value === 'platform' || value === 'cross-platform') {
+            return value;
+        }
+        return undefined;
+    }
+    function clientExtensionResultsToRecord(value) {
+        if (!value) {
+            return {};
+        }
+        return JSON.parse(JSON.stringify(value));
+    }
+    class PasskeyAuthenticatorAttestationResponse {
+        constructor(json) {
+            this.json = json;
+            this.clientDataJSON = decodeBase64Url(json.clientDataJSON);
+            this.attestationObject = decodeBase64Url(json.attestationObject);
+        }
+        getPublicKey() {
+            return this.json.publicKey ? decodeBase64Url(this.json.publicKey) : null;
+        }
+        getPublicKeyAlgorithm() {
+            var _a;
+            return (_a = this.json.publicKeyAlgorithm) !== null && _a !== void 0 ? _a : -7;
+        }
+        getTransports() {
+            return this.json.transports ? [...this.json.transports] : [];
+        }
+        toJSON() {
+            return Object.assign({}, this.json);
+        }
+    }
+    class PasskeyAuthenticatorAssertionResponse {
+        constructor(json) {
+            this.json = json;
+            this.clientDataJSON = decodeBase64Url(json.clientDataJSON);
+            this.authenticatorData = decodeBase64Url(json.authenticatorData);
+            this.signature = decodeBase64Url(json.signature);
+            this.userHandle = json.userHandle ? decodeBase64Url(json.userHandle) : null;
+        }
+        toJSON() {
+            return Object.assign({}, this.json);
+        }
+    }
+    class PasskeyPublicKeyCredential {
+        constructor(json) {
+            var _a;
+            this.json = json;
+            this.type = PASSKEY_TYPE;
+            this.id = json.id;
+            this.rawId = decodeBase64Url(json.rawId);
+            this.authenticatorAttachment = (_a = json.authenticatorAttachment) !== null && _a !== void 0 ? _a : null;
+            this.response =
+                'attestationObject' in json.response
+                    ? new PasskeyAuthenticatorAttestationResponse(json.response)
+                    : new PasskeyAuthenticatorAssertionResponse(json.response);
+        }
+        getClientExtensionResults() {
+            var _a;
+            return ((_a = this.json.clientExtensionResults) !== null && _a !== void 0 ? _a : {});
+        }
+        toJSON() {
+            return JSON.parse(JSON.stringify(this.json));
+        }
+    }
+    function resolveErrorName(error) {
+        if (typeof error === 'object' && error) {
+            if ('code' in error && typeof error.code === 'string') {
+                return error.code;
+            }
+            if ('data' in error && error.data && typeof error.data === 'object' && 'name' in error.data) {
+                const candidate = error.data.name;
+                if (typeof candidate === 'string') {
+                    return candidate;
+                }
+            }
+        }
+        return 'UnknownError';
+    }
+
+    function installWebAuthnShim({ root = globalThis, plugin, options }) {
+        var _a;
+        const shimRoot = root;
+        const config = Object.assign(Object.assign({}, ((_a = shimRoot.__capgoPasskeyShimConfig) !== null && _a !== void 0 ? _a : {})), (options !== null && options !== void 0 ? options : {}));
+        shimRoot.__capgoPasskeyShimConfig = config;
+        if (shimRoot.__capgoPasskeyShimInstalled && !config.force) {
+            return;
+        }
+        const originalCredentials = shimRoot.navigator.credentials;
+        const patchedCredentials = {
+            create: async (request) => {
+                var _a;
+                const currentConfig = (_a = shimRoot.__capgoPasskeyShimConfig) !== null && _a !== void 0 ? _a : {};
+                if (!(request === null || request === void 0 ? void 0 : request.publicKey)) {
+                    if (originalCredentials === null || originalCredentials === void 0 ? void 0 : originalCredentials.create) {
+                        return originalCredentials.create.call(originalCredentials, request);
+                    }
+                    throw createPasskeyDomException('NotSupportedError', 'Only public-key credential creation is supported.');
+                }
+                abortIfNeeded(request.signal);
+                const response = (await plugin.createCredential({
+                    origin: currentConfig.origin,
+                    publicKey: webAuthnCreationOptionsToJSON(request.publicKey, currentConfig.origin),
+                }));
+                return credentialFromJSON(response);
+            },
+            get: async (request) => {
+                var _a;
+                const currentConfig = (_a = shimRoot.__capgoPasskeyShimConfig) !== null && _a !== void 0 ? _a : {};
+                if (!(request === null || request === void 0 ? void 0 : request.publicKey)) {
+                    if (originalCredentials === null || originalCredentials === void 0 ? void 0 : originalCredentials.get) {
+                        return originalCredentials.get.call(originalCredentials, request);
+                    }
+                    throw createPasskeyDomException('NotSupportedError', 'Only public-key credential requests are supported.');
+                }
+                abortIfNeeded(request.signal);
+                if (request.mediation === 'conditional') {
+                    throw createPasskeyDomException('NotSupportedError', 'Conditional mediation is not available through the Capacitor passkey shim.');
+                }
+                const response = (await plugin.getCredential({
+                    mediation: request.mediation,
+                    origin: currentConfig.origin,
+                    publicKey: webAuthnRequestOptionsToJSON(request.publicKey, currentConfig.origin),
+                }));
+                return credentialFromJSON(response);
+            },
+            preventSilentAccess: async () => {
+                if (originalCredentials === null || originalCredentials === void 0 ? void 0 : originalCredentials.preventSilentAccess) {
+                    await originalCredentials.preventSilentAccess.call(originalCredentials);
+                }
+            },
+            store: async (credential) => {
+                if ((originalCredentials === null || originalCredentials === void 0 ? void 0 : originalCredentials.store) && credential) {
+                    await originalCredentials.store.call(originalCredentials, credential);
+                }
+            },
+        };
+        try {
+            Object.defineProperty(shimRoot.navigator, 'credentials', {
+                configurable: true,
+                value: patchedCredentials,
+                writable: false,
+            });
+        }
+        catch (_b) {
+            shimRoot.navigator.credentials = patchedCredentials;
+        }
+        installPublicKeyCredentialStatics(shimRoot, plugin);
+        shimRoot.__capgoPasskeyShimInstalled = true;
+    }
+    function installPublicKeyCredentialStatics(root, plugin) {
+        var _a;
+        const nativePublicKeyCredential = (_a = root.PublicKeyCredential) !== null && _a !== void 0 ? _a : class {
+        };
+        const supportRequest = async () => {
+            try {
+                return await plugin.isSupported();
+            }
+            catch (error) {
+                throw normalizePluginError(error);
+            }
+        };
+        defineStatic(nativePublicKeyCredential, 'isUserVerifyingPlatformAuthenticatorAvailable', async () => {
+            const support = await supportRequest();
+            return support.available;
+        });
+        defineStatic(nativePublicKeyCredential, 'isConditionalMediationAvailable', async () => {
+            const support = await supportRequest();
+            return support.conditionalMediation;
+        });
+        defineStatic(nativePublicKeyCredential, 'parseCreationOptionsFromJSON', parseCreationOptionsFromJSON);
+        defineStatic(nativePublicKeyCredential, 'parseRequestOptionsFromJSON', parseRequestOptionsFromJSON);
+        root.PublicKeyCredential = nativePublicKeyCredential;
+    }
+    function defineStatic(target, key, value) {
+        try {
+            Object.defineProperty(target, key, {
+                configurable: true,
+                value,
+                writable: true,
+            });
+        }
+        catch (_a) {
+            Reflect.set(target, key, value);
+        }
+    }
+
+    const NativeCapacitorPasskey = core.registerPlugin('CapacitorPasskey', {
+        web: () => Promise.resolve().then(function () { return web; }).then((module) => new module.CapacitorPasskeyWeb()),
+    });
+    let configurationPromise;
+    let cachedConfiguration;
+    function mergeShimOptions(configuration, options) {
+        var _a;
+        const origin = (_a = options === null || options === void 0 ? void 0 : options.origin) !== null && _a !== void 0 ? _a : configuration === null || configuration === void 0 ? void 0 : configuration.origin;
+        const force = options === null || options === void 0 ? void 0 : options.force;
+        if (!origin && force === undefined) {
+            return undefined;
+        }
+        return {
+            force,
+            origin,
+        };
+    }
+    function mergeRuntimeConfiguration(configuration, options) {
+        var _a;
+        const origin = (_a = options === null || options === void 0 ? void 0 : options.origin) !== null && _a !== void 0 ? _a : configuration.origin;
+        const domains = new Set(configuration.domains);
+        if (origin) {
+            try {
+                domains.add(new URL(origin).hostname);
+            }
+            catch (_b) {
+                // Ignore invalid override values here and let native APIs validate later.
+            }
+        }
+        return Object.assign(Object.assign({}, configuration), { domains: [...domains], origin });
+    }
+    async function loadConfiguration() {
+        try {
+            const configuration = await NativeCapacitorPasskey.getConfiguration();
+            cachedConfiguration = configuration;
+            return configuration;
+        }
+        catch (error) {
+            configurationPromise = undefined;
+            throw error;
+        }
+    }
+    const CapacitorPasskey = {
+        async autoShimWebAuthn(options) {
+            const configuration = await CapacitorPasskey.getConfiguration();
+            if (!configuration.autoShim && !(options === null || options === void 0 ? void 0 : options.force)) {
+                return configuration;
+            }
+            const effectiveConfiguration = mergeRuntimeConfiguration(configuration, options);
+            cachedConfiguration = effectiveConfiguration;
+            installWebAuthnShim({
+                options: mergeShimOptions(effectiveConfiguration, options),
+                plugin: CapacitorPasskey,
+            });
+            return effectiveConfiguration;
+        },
+        async createCredential(options) {
+            return NativeCapacitorPasskey.createCredential(createNativeRequest(options));
+        },
+        async getConfiguration() {
+            if (!configurationPromise) {
+                configurationPromise = loadConfiguration();
+            }
+            return configurationPromise;
+        },
+        async getCredential(options) {
+            return NativeCapacitorPasskey.getCredential(createNativeRequest(options));
+        },
+        async getPluginVersion() {
+            return NativeCapacitorPasskey.getPluginVersion();
+        },
+        async isSupported() {
+            return NativeCapacitorPasskey.isSupported();
+        },
+        shimWebAuthn(options) {
+            installWebAuthnShim({
+                options: mergeShimOptions(cachedConfiguration, options),
+                plugin: CapacitorPasskey,
+            });
+        },
+    };
+
+    class CapacitorPasskeyWeb extends core.WebPlugin {
+        async createCredential(options) {
+            const credentials = this.ensureCredentials();
+            const parsed = JSON.parse(options.requestJson);
+            const credential = await credentials.create({
+                publicKey: browserCreationOptionsFromJSON(parsed),
+            });
+            return browserRegistrationToJSON(credential);
+        }
+        async getCredential(options) {
+            const credentials = this.ensureCredentials();
+            const parsed = JSON.parse(options.requestJson);
+            const credential = await credentials.get({
+                publicKey: browserRequestOptionsFromJSON(parsed),
+            });
+            return browserAuthenticationToJSON(credential);
+        }
+        async getConfiguration() {
+            const origin = this.currentOrigin();
+            const domains = origin ? [new URL(origin).hostname] : [];
+            return {
+                autoShim: true,
+                domains,
+                origin,
+                platform: 'web',
+            };
+        }
+        async isSupported() {
+            var _a, _b, _c, _d;
+            const available = typeof globalThis.PublicKeyCredential !== 'undefined' &&
+                typeof ((_b = (_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.create) === 'function' &&
+                typeof ((_d = (_c = globalThis.navigator) === null || _c === void 0 ? void 0 : _c.credentials) === null || _d === void 0 ? void 0 : _d.get) === 'function';
+            let conditionalMediation = false;
+            if (available && typeof globalThis.PublicKeyCredential.isConditionalMediationAvailable === 'function') {
+                conditionalMediation = await globalThis.PublicKeyCredential.isConditionalMediationAvailable();
+            }
+            return {
+                available,
+                conditionalMediation,
+                platform: 'web',
+            };
+        }
+        async getPluginVersion() {
+            return {
+                version: 'web',
+            };
+        }
+        ensureCredentials() {
+            var _a, _b, _c, _d;
+            if (typeof globalThis.PublicKeyCredential === 'undefined' ||
+                typeof ((_b = (_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.credentials) === null || _b === void 0 ? void 0 : _b.create) !== 'function' ||
+                typeof ((_d = (_c = globalThis.navigator) === null || _c === void 0 ? void 0 : _c.credentials) === null || _d === void 0 ? void 0 : _d.get) !== 'function') {
+                throw createPasskeyDomException('NotSupportedError', 'WebAuthn is not available in this browser.');
+            }
+            return globalThis.navigator.credentials;
+        }
+        currentOrigin() {
+            if (typeof globalThis.location === 'undefined') {
+                return undefined;
+            }
+            if (globalThis.location.protocol !== 'http:' && globalThis.location.protocol !== 'https:') {
+                return undefined;
+            }
+            return globalThis.location.origin;
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        CapacitorPasskeyWeb: CapacitorPasskeyWeb
+    });
+
+    exports.CapacitorPasskey = CapacitorPasskey;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map