@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/dist/commonjs/subtle.js

@@ -0,0 +1,1811 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Subtle = void 0;
+exports.isCryptoKeyPair = isCryptoKeyPair;
+exports.subtle = void 0;
+var _safeBuffer = require("safe-buffer");
+var _utils = require("./utils");
+var _keys = require("./keys");
+var _conversion = require("./utils/conversion");
+var _argon = require("./argon2");
+var _errors = require("./utils/errors");
+var _hashnames = require("./utils/hashnames");
+var _validation = require("./utils/validation");
+var _hash = require("./hash");
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _pbkdf = require("./pbkdf2");
+var _ec = require("./ec");
+var _rsa = require("./rsa");
+var _random = require("./random");
+var _hmac = require("./hmac");
+var _timingSafeEqual = require("./utils/timingSafeEqual");
+var _signVerify = require("./keys/signVerify");
+var _ed = require("./ed");
+var _mldsa = require("./mldsa");
+var _mlkem = require("./mlkem");
+var _hkdf = require("./hkdf");
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// Temporary enums that need to be defined
+var KWebCryptoKeyFormat = /*#__PURE__*/function (KWebCryptoKeyFormat) {
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatRaw"] = 0] = "kWebCryptoKeyFormatRaw";
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatSPKI"] = 1] = "kWebCryptoKeyFormatSPKI";
+  KWebCryptoKeyFormat[KWebCryptoKeyFormat["kWebCryptoKeyFormatPKCS8"] = 2] = "kWebCryptoKeyFormatPKCS8";
+  return KWebCryptoKeyFormat;
+}(KWebCryptoKeyFormat || {});
+var CipherOrWrapMode = /*#__PURE__*/function (CipherOrWrapMode) {
+  CipherOrWrapMode[CipherOrWrapMode["kWebCryptoCipherEncrypt"] = 0] = "kWebCryptoCipherEncrypt";
+  CipherOrWrapMode[CipherOrWrapMode["kWebCryptoCipherDecrypt"] = 1] = "kWebCryptoCipherDecrypt";
+  return CipherOrWrapMode;
+}(CipherOrWrapMode || {}); // Placeholder functions that need to be implemented
+function hasAnyNotIn(usages, allowed) {
+  return usages.some(usage => !allowed.includes(usage));
+}
+function normalizeAlgorithm(algorithm, _operation) {
+  if (typeof algorithm === 'string') {
+    return {
+      name: algorithm
+    };
+  }
+  return algorithm;
+}
+function getAlgorithmName(name, length) {
+  switch (name) {
+    case 'AES-CBC':
+      return `A${length}CBC`;
+    case 'AES-CTR':
+      return `A${length}CTR`;
+    case 'AES-GCM':
+      return `A${length}GCM`;
+    case 'AES-KW':
+      return `A${length}KW`;
+    case 'AES-OCB':
+      return `A${length}OCB`;
+    case 'ChaCha20-Poly1305':
+      return 'C20P';
+    default:
+      return `${name}${length}`;
+  }
+}
+
+// Placeholder implementations for missing functions
+function ecExportKey(key, format) {
+  const keyObject = key.keyObject;
+  if (format === KWebCryptoKeyFormat.kWebCryptoKeyFormatRaw) {
+    return (0, _conversion.bufferLikeToArrayBuffer)(keyObject.handle.exportKey());
+  } else if (format === KWebCryptoKeyFormat.kWebCryptoKeyFormatSPKI) {
+    const exported = keyObject.export({
+      format: 'der',
+      type: 'spki'
+    });
+    return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+  } else if (format === KWebCryptoKeyFormat.kWebCryptoKeyFormatPKCS8) {
+    const exported = keyObject.export({
+      format: 'der',
+      type: 'pkcs8'
+    });
+    return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+  } else {
+    throw new Error(`Unsupported EC export format: ${format}`);
+  }
+}
+function rsaExportKey(key, format) {
+  const keyObject = key.keyObject;
+  if (format === KWebCryptoKeyFormat.kWebCryptoKeyFormatSPKI) {
+    // Export public key in SPKI format
+    const exported = keyObject.export({
+      format: 'der',
+      type: 'spki'
+    });
+    return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+  } else if (format === KWebCryptoKeyFormat.kWebCryptoKeyFormatPKCS8) {
+    // Export private key in PKCS8 format
+    const exported = keyObject.export({
+      format: 'der',
+      type: 'pkcs8'
+    });
+    return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+  } else {
+    throw new Error(`Unsupported RSA export format: ${format}`);
+  }
+}
+async function rsaCipher(mode, key, data, algorithm) {
+  const rsaParams = algorithm;
+
+  // Validate key type matches operation
+  const expectedType = mode === CipherOrWrapMode.kWebCryptoCipherEncrypt ? 'public' : 'private';
+  if (key.type !== expectedType) {
+    throw (0, _errors.lazyDOMException)('The requested operation is not valid for the provided key', 'InvalidAccessError');
+  }
+
+  // Get hash algorithm from key
+  const hashAlgorithm = (0, _hashnames.normalizeHashName)(key.algorithm.hash);
+
+  // Prepare label (optional)
+  const label = rsaParams.label ? (0, _conversion.bufferLikeToArrayBuffer)(rsaParams.label) : undefined;
+
+  // Create RSA cipher instance
+  const rsaCipherModule = _reactNativeNitroModules.NitroModules.createHybridObject('RsaCipher');
+
+  // RSA-OAEP padding constant = 4
+  const RSA_PKCS1_OAEP_PADDING = 4;
+  if (mode === CipherOrWrapMode.kWebCryptoCipherEncrypt) {
+    // Encrypt with public key
+    return rsaCipherModule.encrypt(key.keyObject.handle, data, RSA_PKCS1_OAEP_PADDING, hashAlgorithm, label);
+  } else {
+    // Decrypt with private key
+    return rsaCipherModule.decrypt(key.keyObject.handle, data, RSA_PKCS1_OAEP_PADDING, hashAlgorithm, label);
+  }
+}
+async function aesCipher(mode, key, data, algorithm) {
+  const {
+    name
+  } = algorithm;
+  switch (name) {
+    case 'AES-CTR':
+      return aesCtrCipher(mode, key, data, algorithm);
+    case 'AES-CBC':
+      return aesCbcCipher(mode, key, data, algorithm);
+    case 'AES-GCM':
+      return aesGcmCipher(mode, key, data, algorithm);
+    case 'AES-OCB':
+      return aesOcbCipher(mode, key, data, algorithm);
+    default:
+      throw (0, _errors.lazyDOMException)(`Unsupported AES algorithm: ${name}`, 'NotSupportedError');
+  }
+}
+async function aesCtrCipher(mode, key, data, algorithm) {
+  // Validate counter and length
+  if (!algorithm.counter || algorithm.counter.byteLength !== 16) {
+    throw (0, _errors.lazyDOMException)('AES-CTR algorithm.counter must be 16 bytes', 'OperationError');
+  }
+  if (algorithm.length < 1 || algorithm.length > 128) {
+    throw (0, _errors.lazyDOMException)('AES-CTR algorithm.length must be between 1 and 128', 'OperationError');
+  }
+
+  // Get cipher type based on key length
+  const keyLength = key.algorithm.length;
+  const cipherType = `aes-${keyLength}-ctr`;
+
+  // Create cipher
+  const factory = _reactNativeNitroModules.NitroModules.createHybridObject('CipherFactory');
+  const cipher = factory.createCipher({
+    isCipher: mode === CipherOrWrapMode.kWebCryptoCipherEncrypt,
+    cipherType,
+    cipherKey: (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.export()),
+    iv: (0, _conversion.bufferLikeToArrayBuffer)(algorithm.counter)
+  });
+
+  // Process data
+  const updated = cipher.update(data);
+  const final = cipher.final();
+
+  // Concatenate results
+  const result = new Uint8Array(updated.byteLength + final.byteLength);
+  result.set(new Uint8Array(updated), 0);
+  result.set(new Uint8Array(final), updated.byteLength);
+  return result.buffer;
+}
+async function aesCbcCipher(mode, key, data, algorithm) {
+  // Validate IV
+  const iv = (0, _conversion.bufferLikeToArrayBuffer)(algorithm.iv);
+  if (iv.byteLength !== 16) {
+    throw (0, _errors.lazyDOMException)('algorithm.iv must contain exactly 16 bytes', 'OperationError');
+  }
+
+  // Get cipher type based on key length
+  const keyLength = key.algorithm.length;
+  const cipherType = `aes-${keyLength}-cbc`;
+
+  // Create cipher
+  const factory = _reactNativeNitroModules.NitroModules.createHybridObject('CipherFactory');
+  const cipher = factory.createCipher({
+    isCipher: mode === CipherOrWrapMode.kWebCryptoCipherEncrypt,
+    cipherType,
+    cipherKey: (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.export()),
+    iv
+  });
+
+  // Process data
+  const updated = cipher.update(data);
+  const final = cipher.final();
+
+  // Concatenate results
+  const result = new Uint8Array(updated.byteLength + final.byteLength);
+  result.set(new Uint8Array(updated), 0);
+  result.set(new Uint8Array(final), updated.byteLength);
+  return result.buffer;
+}
+async function aesAeadCipher(mode, key, data, config, additionalData, tagLength = 128) {
+  if (!config.validTagLengths.includes(tagLength)) {
+    throw (0, _errors.lazyDOMException)(`${tagLength} is not a valid ${config.algorithmName} tag length`, 'OperationError');
+  }
+  const tagByteLength = tagLength / 8;
+  const keyLength = key.algorithm.length;
+  const cipherType = `aes-${keyLength}-${config.cipherSuffix}`;
+  const factory = _reactNativeNitroModules.NitroModules.createHybridObject('CipherFactory');
+  const cipher = factory.createCipher({
+    isCipher: mode === CipherOrWrapMode.kWebCryptoCipherEncrypt,
+    cipherType,
+    cipherKey: (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.export()),
+    iv: config.iv,
+    authTagLen: tagByteLength
+  });
+  let processData;
+  if (mode === CipherOrWrapMode.kWebCryptoCipherDecrypt) {
+    const dataView = new Uint8Array(data);
+    if (dataView.byteLength < tagByteLength) {
+      throw (0, _errors.lazyDOMException)('The provided data is too small.', 'OperationError');
+    }
+    const ciphertextLength = dataView.byteLength - tagByteLength;
+    processData = dataView.slice(0, ciphertextLength).buffer;
+    const authTag = dataView.slice(ciphertextLength).buffer;
+    cipher.setAuthTag(authTag);
+  } else {
+    processData = data;
+  }
+  if (additionalData) {
+    cipher.setAAD((0, _conversion.bufferLikeToArrayBuffer)(additionalData));
+  }
+  const updated = cipher.update(processData);
+  const final = cipher.final();
+  if (mode === CipherOrWrapMode.kWebCryptoCipherEncrypt) {
+    const tag = cipher.getAuthTag();
+    const result = new Uint8Array(updated.byteLength + final.byteLength + tag.byteLength);
+    result.set(new Uint8Array(updated), 0);
+    result.set(new Uint8Array(final), updated.byteLength);
+    result.set(new Uint8Array(tag), updated.byteLength + final.byteLength);
+    return result.buffer;
+  } else {
+    const result = new Uint8Array(updated.byteLength + final.byteLength);
+    result.set(new Uint8Array(updated), 0);
+    result.set(new Uint8Array(final), updated.byteLength);
+    return result.buffer;
+  }
+}
+async function aesGcmCipher(mode, key, data, algorithm) {
+  return aesAeadCipher(mode, key, data, {
+    algorithmName: 'AES-GCM',
+    validTagLengths: [32, 64, 96, 104, 112, 120, 128],
+    cipherSuffix: 'gcm',
+    iv: (0, _conversion.bufferLikeToArrayBuffer)(algorithm.iv)
+  }, algorithm.additionalData, algorithm.tagLength);
+}
+async function aesOcbCipher(mode, key, data, algorithm) {
+  const ivBuffer = (0, _conversion.bufferLikeToArrayBuffer)(algorithm.iv);
+  if (ivBuffer.byteLength < 1 || ivBuffer.byteLength > 15) {
+    throw (0, _errors.lazyDOMException)('AES-OCB algorithm.iv must be between 1 and 15 bytes', 'OperationError');
+  }
+  return aesAeadCipher(mode, key, data, {
+    algorithmName: 'AES-OCB',
+    validTagLengths: [64, 96, 128],
+    cipherSuffix: 'ocb',
+    iv: ivBuffer
+  }, algorithm.additionalData, algorithm.tagLength);
+}
+async function aesKwCipher(mode, key, data) {
+  const isWrap = mode === CipherOrWrapMode.kWebCryptoCipherEncrypt;
+
+  // AES-KW requires input to be a multiple of 8 bytes (64 bits)
+  if (data.byteLength % 8 !== 0) {
+    throw (0, _errors.lazyDOMException)(`AES-KW input length must be a multiple of 8 bytes, got ${data.byteLength}`, 'OperationError');
+  }
+
+  // AES-KW requires at least 16 bytes of input (128 bits)
+  if (isWrap && data.byteLength < 16) {
+    throw (0, _errors.lazyDOMException)(`AES-KW input must be at least 16 bytes, got ${data.byteLength}`, 'OperationError');
+  }
+
+  // Get cipher type based on key length
+  const keyLength = key.algorithm.length;
+  // Use aes*-wrap for both operations (matching Node.js)
+  const cipherType = `aes${keyLength}-wrap`;
+
+  // Export key material
+  const exportedKey = key.keyObject.export();
+  const cipherKey = (0, _conversion.bufferLikeToArrayBuffer)(exportedKey);
+
+  // AES-KW uses a default IV as specified in RFC 3394
+  const defaultWrapIV = new Uint8Array([0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6]);
+  const factory = _reactNativeNitroModules.NitroModules.createHybridObject('CipherFactory');
+  const cipher = factory.createCipher({
+    isCipher: isWrap,
+    cipherType,
+    cipherKey,
+    iv: defaultWrapIV.buffer // RFC 3394 default IV for AES-KW
+  });
+
+  // Process data
+  const updated = cipher.update(data);
+  const final = cipher.final();
+
+  // Concatenate results
+  const result = new Uint8Array(updated.byteLength + final.byteLength);
+  result.set(new Uint8Array(updated), 0);
+  result.set(new Uint8Array(final), updated.byteLength);
+  return result.buffer;
+}
+async function chaCha20Poly1305Cipher(mode, key, data, algorithm) {
+  const {
+    iv,
+    additionalData,
+    tagLength = 128
+  } = algorithm;
+
+  // Validate IV (must be 12 bytes for ChaCha20-Poly1305)
+  const ivBuffer = (0, _conversion.bufferLikeToArrayBuffer)(iv);
+  if (!ivBuffer || ivBuffer.byteLength !== 12) {
+    throw (0, _errors.lazyDOMException)('ChaCha20-Poly1305 IV must be exactly 12 bytes', 'OperationError');
+  }
+
+  // Validate tag length (only 128-bit supported)
+  if (tagLength !== 128) {
+    throw (0, _errors.lazyDOMException)('ChaCha20-Poly1305 only supports 128-bit auth tags', 'NotSupportedError');
+  }
+  const tagByteLength = 16; // 128 bits = 16 bytes
+
+  // Create cipher using existing ChaCha20-Poly1305 implementation
+  const factory = _reactNativeNitroModules.NitroModules.createHybridObject('CipherFactory');
+  const cipher = factory.createCipher({
+    isCipher: mode === CipherOrWrapMode.kWebCryptoCipherEncrypt,
+    cipherType: 'chacha20-poly1305',
+    cipherKey: (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.export()),
+    iv: ivBuffer,
+    authTagLen: tagByteLength
+  });
+  let processData;
+  let authTag;
+  if (mode === CipherOrWrapMode.kWebCryptoCipherDecrypt) {
+    // For decryption, extract auth tag from end of data
+    const dataView = new Uint8Array(data);
+    if (dataView.byteLength < tagByteLength) {
+      throw (0, _errors.lazyDOMException)('The provided data is too small.', 'OperationError');
+    }
+
+    // Split data and tag
+    const ciphertextLength = dataView.byteLength - tagByteLength;
+    processData = dataView.slice(0, ciphertextLength).buffer;
+    authTag = dataView.slice(ciphertextLength).buffer;
+
+    // Set auth tag for verification
+    cipher.setAuthTag(authTag);
+  } else {
+    processData = data;
+  }
+
+  // Set additional authenticated data if provided
+  if (additionalData) {
+    cipher.setAAD((0, _conversion.bufferLikeToArrayBuffer)(additionalData));
+  }
+
+  // Process data
+  const updated = cipher.update(processData);
+  const final = cipher.final();
+  if (mode === CipherOrWrapMode.kWebCryptoCipherEncrypt) {
+    // For encryption, append auth tag to result
+    const tag = cipher.getAuthTag();
+    const result = new Uint8Array(updated.byteLength + final.byteLength + tag.byteLength);
+    result.set(new Uint8Array(updated), 0);
+    result.set(new Uint8Array(final), updated.byteLength);
+    result.set(new Uint8Array(tag), updated.byteLength + final.byteLength);
+    return result.buffer;
+  } else {
+    // For decryption, just concatenate plaintext
+    const result = new Uint8Array(updated.byteLength + final.byteLength);
+    result.set(new Uint8Array(updated), 0);
+    result.set(new Uint8Array(final), updated.byteLength);
+    return result.buffer;
+  }
+}
+async function aesGenerateKey(algorithm, extractable, keyUsages) {
+  const {
+    length
+  } = algorithm;
+  const name = algorithm.name;
+  if (!name) {
+    throw (0, _errors.lazyDOMException)('Algorithm name is required', 'OperationError');
+  }
+
+  // Validate key length
+  if (![128, 192, 256].includes(length)) {
+    throw (0, _errors.lazyDOMException)(`Invalid AES key length: ${length}. Must be 128, 192, or 256.`, 'OperationError');
+  }
+
+  // Validate usages
+  const validUsages = ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'];
+  if (hasAnyNotIn(keyUsages, validUsages)) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name}`, 'SyntaxError');
+  }
+
+  // Generate random key bytes
+  const keyBytes = new Uint8Array(length / 8);
+  (0, _random.getRandomValues)(keyBytes);
+
+  // Create secret key
+  const keyObject = (0, _keys.createSecretKey)(keyBytes);
+
+  // Construct algorithm object with guaranteed name
+  const keyAlgorithm = {
+    name,
+    length
+  };
+  return new _keys.CryptoKey(keyObject, keyAlgorithm, keyUsages, extractable);
+}
+async function hmacGenerateKey(algorithm, extractable, keyUsages) {
+  // Validate usages
+  if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+    throw (0, _errors.lazyDOMException)('Unsupported key usage for HMAC key', 'SyntaxError');
+  }
+
+  // Get hash algorithm
+  const hash = algorithm.hash;
+  if (!hash) {
+    throw (0, _errors.lazyDOMException)('HMAC algorithm requires a hash parameter', 'TypeError');
+  }
+  const hashName = (0, _hashnames.normalizeHashName)(hash);
+
+  // Determine key length
+  let length = algorithm.length;
+  if (length === undefined) {
+    // Use hash output length as default key length
+    switch (hashName) {
+      case 'SHA-1':
+        length = 160;
+        break;
+      case 'SHA-256':
+        length = 256;
+        break;
+      case 'SHA-384':
+        length = 384;
+        break;
+      case 'SHA-512':
+        length = 512;
+        break;
+      default:
+        length = 256;
+      // Default to 256 bits
+    }
+  }
+  if (length === 0) {
+    throw (0, _errors.lazyDOMException)('Zero-length key is not supported', 'OperationError');
+  }
+
+  // Generate random key bytes
+  const keyBytes = new Uint8Array(Math.ceil(length / 8));
+  (0, _random.getRandomValues)(keyBytes);
+
+  // Create secret key
+  const keyObject = (0, _keys.createSecretKey)(keyBytes);
+
+  // Construct algorithm object with hash normalized to { name: string } format per WebCrypto spec
+  const webCryptoHashName = (0, _hashnames.normalizeHashName)(hash, _hashnames.HashContext.WebCrypto);
+  const keyAlgorithm = {
+    name: 'HMAC',
+    hash: {
+      name: webCryptoHashName
+    },
+    length
+  };
+  return new _keys.CryptoKey(keyObject, keyAlgorithm, keyUsages, extractable);
+}
+async function kmacGenerateKey(algorithm, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+  if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name} key`, 'SyntaxError');
+  }
+  const defaultLength = name === 'KMAC128' ? 128 : 256;
+  const length = algorithm.length ?? defaultLength;
+  if (length === 0) {
+    throw (0, _errors.lazyDOMException)('Zero-length key is not supported', 'OperationError');
+  }
+  const keyBytes = new Uint8Array(Math.ceil(length / 8));
+  (0, _random.getRandomValues)(keyBytes);
+  const keyObject = (0, _keys.createSecretKey)(keyBytes);
+  const keyAlgorithm = {
+    name: name,
+    length
+  };
+  return new _keys.CryptoKey(keyObject, keyAlgorithm, keyUsages, extractable);
+}
+function kmacSignVerify(key, data, algorithm, signature) {
+  const {
+    name
+  } = algorithm;
+  const defaultLength = name === 'KMAC128' ? 256 : 512;
+  const outputLengthBits = algorithm.length ?? defaultLength;
+  if (outputLengthBits % 8 !== 0) {
+    throw (0, _errors.lazyDOMException)('KMAC output length must be a multiple of 8', 'OperationError');
+  }
+  const outputLengthBytes = outputLengthBits / 8;
+  const keyData = key.keyObject.export();
+  const kmac = _reactNativeNitroModules.NitroModules.createHybridObject('Kmac');
+  let customizationBuffer;
+  if (algorithm.customization !== undefined) {
+    customizationBuffer = (0, _conversion.bufferLikeToArrayBuffer)(algorithm.customization);
+  }
+  kmac.createKmac(name, (0, _conversion.bufferLikeToArrayBuffer)(keyData), outputLengthBytes, customizationBuffer);
+  kmac.update((0, _conversion.bufferLikeToArrayBuffer)(data));
+  const computed = kmac.digest();
+  if (signature === undefined) {
+    return computed;
+  }
+  const sigBuffer = (0, _conversion.bufferLikeToArrayBuffer)(signature);
+  if (computed.byteLength !== sigBuffer.byteLength) {
+    return false;
+  }
+  return (0, _timingSafeEqual.timingSafeEqual)(new Uint8Array(computed), new Uint8Array(sigBuffer));
+}
+async function kmacImportKey(algorithm, format, data, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+  if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name} key`, 'SyntaxError');
+  }
+  let keyObject;
+  if (format === 'jwk') {
+    const jwk = data;
+    if (!jwk || typeof jwk !== 'object') {
+      throw (0, _errors.lazyDOMException)('Invalid keyData', 'DataError');
+    }
+    if (jwk.kty !== 'oct') {
+      throw (0, _errors.lazyDOMException)('Invalid JWK format for KMAC key', 'DataError');
+    }
+    const expectedAlg = name === 'KMAC128' ? 'K128' : 'K256';
+    if (jwk.alg !== undefined && jwk.alg !== expectedAlg) {
+      throw (0, _errors.lazyDOMException)('JWK "alg" does not match the requested algorithm', 'DataError');
+    }
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwk, undefined);
+    if (keyType === undefined || keyType !== 0) {
+      throw (0, _errors.lazyDOMException)('Failed to import KMAC JWK', 'DataError');
+    }
+    keyObject = new _keys.SecretKeyObject(handle);
+  } else if (format === 'raw' || format === 'raw-secret') {
+    keyObject = (0, _keys.createSecretKey)(data);
+  } else {
+    throw (0, _errors.lazyDOMException)(`Unable to import ${name} key with format ${format}`, 'NotSupportedError');
+  }
+  const exported = keyObject.export();
+  const keyLength = exported.byteLength * 8;
+  if (keyLength === 0) {
+    throw (0, _errors.lazyDOMException)('Zero-length key is not supported', 'DataError');
+  }
+  if (algorithm.length !== undefined && algorithm.length !== keyLength) {
+    throw (0, _errors.lazyDOMException)('Invalid key length', 'DataError');
+  }
+  const keyAlgorithm = {
+    name: name,
+    length: keyLength
+  };
+  return new _keys.CryptoKey(keyObject, keyAlgorithm, keyUsages, extractable);
+}
+function rsaImportKey(format, data, algorithm, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+
+  // Validate usages
+  let checkSet;
+  switch (name) {
+    case 'RSASSA-PKCS1-v1_5':
+    case 'RSA-PSS':
+      checkSet = ['sign', 'verify'];
+      break;
+    case 'RSA-OAEP':
+      checkSet = ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'];
+      break;
+    default:
+      throw new Error(`Unsupported RSA algorithm: ${name}`);
+  }
+  if (hasAnyNotIn(keyUsages, checkSet)) {
+    throw new Error(`Unsupported key usage for ${name}`);
+  }
+  let keyObject;
+  if (format === 'jwk') {
+    const jwk = data;
+
+    // Validate JWK
+    if (jwk.kty !== 'RSA') {
+      throw new Error('Invalid JWK format for RSA key');
+    }
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwk, undefined);
+    if (keyType === undefined) {
+      throw new Error('Failed to import RSA JWK');
+    }
+
+    // Create the appropriate KeyObject based on type
+    if (keyType === 1) {
+      keyObject = new _keys.PublicKeyObject(handle);
+    } else if (keyType === 2) {
+      keyObject = new _keys.PrivateKeyObject(handle);
+    } else {
+      throw new Error('Unexpected key type from RSA JWK import');
+    }
+  } else if (format === 'spki') {
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    keyObject = _keys.KeyObject.createKeyObject('public', keyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  } else if (format === 'pkcs8') {
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    keyObject = _keys.KeyObject.createKeyObject('private', keyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  } else {
+    throw new Error(`Unsupported format for RSA import: ${format}`);
+  }
+
+  // Get the modulus length from the key and add it to the algorithm
+  const keyDetails = keyObject.asymmetricKeyDetails;
+
+  // Convert publicExponent number to big-endian byte array
+  let publicExponentBytes;
+  if (keyDetails !== null && keyDetails !== void 0 && keyDetails.publicExponent) {
+    const exp = keyDetails.publicExponent;
+    // Convert number to big-endian bytes
+    const bytes = [];
+    let value = exp;
+    while (value > 0) {
+      bytes.unshift(value & 0xff);
+      value = Math.floor(value / 256);
+    }
+    publicExponentBytes = new Uint8Array(bytes.length > 0 ? bytes : [0]);
+  }
+
+  // Normalize hash to { name: string } format per WebCrypto spec
+  const hashName = (0, _hashnames.normalizeHashName)(algorithm.hash, _hashnames.HashContext.WebCrypto);
+  const normalizedHash = {
+    name: hashName
+  };
+  const algorithmWithDetails = {
+    ...algorithm,
+    modulusLength: keyDetails === null || keyDetails === void 0 ? void 0 : keyDetails.modulusLength,
+    publicExponent: publicExponentBytes,
+    hash: normalizedHash
+  };
+  return new _keys.CryptoKey(keyObject, algorithmWithDetails, keyUsages, extractable);
+}
+async function hmacImportKey(algorithm, format, data, extractable, keyUsages) {
+  // Validate usages
+  if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
+    throw new Error('Unsupported key usage for an HMAC key');
+  }
+  let keyObject;
+  if (format === 'jwk') {
+    const jwk = data;
+
+    // Validate JWK
+    if (!jwk || typeof jwk !== 'object') {
+      throw new Error('Invalid keyData');
+    }
+    if (jwk.kty !== 'oct') {
+      throw new Error('Invalid JWK format for HMAC key');
+    }
+
+    // Validate key length if specified
+    if (algorithm.length !== undefined) {
+      if (!jwk.k) {
+        throw new Error('JWK missing key data');
+      }
+      // Decode to check length
+      const decoded = _safeBuffer.Buffer.from(jwk.k, 'base64');
+      const keyBitLength = decoded.length * 8;
+      if (algorithm.length === 0) {
+        throw new Error('Zero-length key is not supported');
+      }
+      if (algorithm.length !== keyBitLength) {
+        throw new Error('Invalid key length');
+      }
+    }
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwk, undefined);
+    if (keyType === undefined || keyType !== 0) {
+      throw new Error('Failed to import HMAC JWK');
+    }
+    keyObject = new _keys.SecretKeyObject(handle);
+  } else if (format === 'raw') {
+    keyObject = (0, _keys.createSecretKey)(data);
+  } else {
+    throw new Error(`Unable to import HMAC key with format ${format}`);
+  }
+
+  // Normalize hash to { name: string } format per WebCrypto spec
+  const hashName = (0, _hashnames.normalizeHashName)(algorithm.hash, _hashnames.HashContext.WebCrypto);
+  const normalizedAlgorithm = {
+    ...algorithm,
+    name: 'HMAC',
+    hash: {
+      name: hashName
+    }
+  };
+  return new _keys.CryptoKey(keyObject, normalizedAlgorithm, keyUsages, extractable);
+}
+async function aesImportKey(algorithm, format, data, extractable, keyUsages) {
+  const {
+    name,
+    length
+  } = algorithm;
+
+  // Validate usages
+  const validUsages = ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'];
+  if (hasAnyNotIn(keyUsages, validUsages)) {
+    throw new Error(`Unsupported key usage for ${name}`);
+  }
+  let keyObject;
+  let actualLength;
+  if (format === 'jwk') {
+    const jwk = data;
+
+    // Validate JWK
+    if (jwk.kty !== 'oct') {
+      throw new Error('Invalid JWK format for AES key');
+    }
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwk, undefined);
+    if (keyType === undefined || keyType !== 0) {
+      throw new Error('Failed to import AES JWK');
+    }
+    keyObject = new _keys.SecretKeyObject(handle);
+
+    // Get actual key length from imported key
+    const exported = keyObject.export();
+    actualLength = exported.byteLength * 8;
+  } else if (format === 'raw') {
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    actualLength = keyData.byteLength * 8;
+
+    // Validate key length
+    if (![128, 192, 256].includes(actualLength)) {
+      throw new Error('Invalid AES key length');
+    }
+    keyObject = (0, _keys.createSecretKey)(keyData);
+  } else {
+    throw new Error(`Unsupported format for AES import: ${format}`);
+  }
+
+  // Validate length if specified
+  if (length !== undefined && length !== actualLength) {
+    throw new Error(`Key length mismatch: expected ${length}, got ${actualLength}`);
+  }
+  return new _keys.CryptoKey(keyObject, {
+    name,
+    length: actualLength
+  }, keyUsages, extractable);
+}
+function edImportKey(format, data, algorithm, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+
+  // Validate usages
+  const isX = name === 'X25519' || name === 'X448';
+  const allowedUsages = isX ? ['deriveKey', 'deriveBits'] : ['sign', 'verify'];
+  if (hasAnyNotIn(keyUsages, allowedUsages)) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name} key`, 'SyntaxError');
+  }
+  let keyObject;
+  if (format === 'spki') {
+    // Import public key
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    keyObject = _keys.KeyObject.createKeyObject('public', keyData, _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  } else if (format === 'pkcs8') {
+    // Import private key
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    keyObject = _keys.KeyObject.createKeyObject('private', keyData, _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  } else if (format === 'raw') {
+    // Raw format - public key only for Ed keys
+    const keyData = (0, _conversion.bufferLikeToArrayBuffer)(data);
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    // For raw Ed keys, we need to create them differently
+    // Raw public keys are just the key bytes
+    handle.init(1, keyData); // 1 = public key type
+    keyObject = new _keys.PublicKeyObject(handle);
+  } else if (format === 'jwk') {
+    const jwkData = data;
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    const keyType = handle.initJwk(jwkData);
+    if (keyType === undefined) {
+      throw (0, _errors.lazyDOMException)('Invalid JWK data', 'DataError');
+    }
+    if (keyType === _utils.KeyType.PRIVATE) {
+      keyObject = new _keys.PrivateKeyObject(handle);
+    } else {
+      keyObject = new _keys.PublicKeyObject(handle);
+    }
+  } else {
+    throw (0, _errors.lazyDOMException)(`Unsupported format for ${name} import: ${format}`, 'NotSupportedError');
+  }
+  return new _keys.CryptoKey(keyObject, {
+    name
+  }, keyUsages, extractable);
+}
+function pqcImportKeyObject(format, data, name) {
+  if (format === 'spki') {
+    return _keys.KeyObject.createKeyObject('public', (0, _conversion.bufferLikeToArrayBuffer)(data), _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+  } else if (format === 'pkcs8') {
+    return _keys.KeyObject.createKeyObject('private', (0, _conversion.bufferLikeToArrayBuffer)(data), _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+  } else if (format === 'raw') {
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    if (!handle.initPqcRaw(name, (0, _conversion.bufferLikeToArrayBuffer)(data), true)) {
+      throw (0, _errors.lazyDOMException)(`Failed to import ${name} raw public key`, 'DataError');
+    }
+    return new _keys.PublicKeyObject(handle);
+  } else if (format === 'raw-seed') {
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    if (!handle.initPqcRaw(name, (0, _conversion.bufferLikeToArrayBuffer)(data), false)) {
+      throw (0, _errors.lazyDOMException)(`Failed to import ${name} raw seed`, 'DataError');
+    }
+    return new _keys.PrivateKeyObject(handle);
+  }
+  throw (0, _errors.lazyDOMException)(`Unsupported format for ${name} import: ${format}`, 'NotSupportedError');
+}
+function mldsaImportKey(format, data, algorithm, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+  const isPublicFormat = format === 'spki' || format === 'raw';
+  if (hasAnyNotIn(keyUsages, isPublicFormat ? ['verify'] : ['sign'])) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name} key`, 'SyntaxError');
+  }
+  return new _keys.CryptoKey(pqcImportKeyObject(format, data, name), {
+    name
+  }, keyUsages, extractable);
+}
+function mlkemImportKey(format, data, algorithm, extractable, keyUsages) {
+  const {
+    name
+  } = algorithm;
+  const isPublicFormat = format === 'spki' || format === 'raw';
+  const allowedUsages = isPublicFormat ? ['encapsulateBits', 'encapsulateKey'] : ['decapsulateBits', 'decapsulateKey'];
+  if (hasAnyNotIn(keyUsages, allowedUsages)) {
+    throw (0, _errors.lazyDOMException)(`Unsupported key usage for ${name} key`, 'SyntaxError');
+  }
+  return new _keys.CryptoKey(pqcImportKeyObject(format, data, name), {
+    name
+  }, keyUsages, extractable);
+}
+const exportKeySpki = async key => {
+  switch (key.algorithm.name) {
+    case 'RSASSA-PKCS1-v1_5':
+    // Fall through
+    case 'RSA-PSS':
+    // Fall through
+    case 'RSA-OAEP':
+      if (key.type === 'public') {
+        return rsaExportKey(key, KWebCryptoKeyFormat.kWebCryptoKeyFormatSPKI);
+      }
+      break;
+    case 'ECDSA':
+    // Fall through
+    case 'ECDH':
+      if (key.type === 'public') {
+        return ecExportKey(key, KWebCryptoKeyFormat.kWebCryptoKeyFormatSPKI);
+      }
+      break;
+    case 'Ed25519':
+    // Fall through
+    case 'Ed448':
+    // Fall through
+    case 'X25519':
+    // Fall through
+    case 'X448':
+      if (key.type === 'public') {
+        // Export Ed/X key in SPKI DER format
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI));
+      }
+      break;
+    case 'ML-DSA-44':
+    // Fall through
+    case 'ML-DSA-65':
+    // Fall through
+    case 'ML-DSA-87':
+      if (key.type === 'public') {
+        // Export ML-DSA key in SPKI DER format
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI));
+      }
+      break;
+    case 'ML-KEM-512':
+    // Fall through
+    case 'ML-KEM-768':
+    // Fall through
+    case 'ML-KEM-1024':
+      if (key.type === 'public') {
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI));
+      }
+      break;
+  }
+  throw new Error(`Unable to export a spki ${key.algorithm.name} ${key.type} key`);
+};
+const exportKeyPkcs8 = async key => {
+  switch (key.algorithm.name) {
+    case 'RSASSA-PKCS1-v1_5':
+    // Fall through
+    case 'RSA-PSS':
+    // Fall through
+    case 'RSA-OAEP':
+      if (key.type === 'private') {
+        return rsaExportKey(key, KWebCryptoKeyFormat.kWebCryptoKeyFormatPKCS8);
+      }
+      break;
+    case 'ECDSA':
+    // Fall through
+    case 'ECDH':
+      if (key.type === 'private') {
+        return ecExportKey(key, KWebCryptoKeyFormat.kWebCryptoKeyFormatPKCS8);
+      }
+      break;
+    case 'Ed25519':
+    // Fall through
+    case 'Ed448':
+    // Fall through
+    case 'X25519':
+    // Fall through
+    case 'X448':
+      if (key.type === 'private') {
+        // Export Ed/X key in PKCS8 DER format
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.PKCS8));
+      }
+      break;
+    case 'ML-DSA-44':
+    // Fall through
+    case 'ML-DSA-65':
+    // Fall through
+    case 'ML-DSA-87':
+      if (key.type === 'private') {
+        // Export ML-DSA key in PKCS8 DER format
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.PKCS8));
+      }
+      break;
+    case 'ML-KEM-512':
+    // Fall through
+    case 'ML-KEM-768':
+    // Fall through
+    case 'ML-KEM-1024':
+      if (key.type === 'private') {
+        return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.PKCS8));
+      }
+      break;
+  }
+  throw new Error(`Unable to export a pkcs8 ${key.algorithm.name} ${key.type} key`);
+};
+const exportKeyRaw = key => {
+  switch (key.algorithm.name) {
+    case 'ECDSA':
+    // Fall through
+    case 'ECDH':
+      if (key.type === 'public') {
+        return ecExportKey(key, KWebCryptoKeyFormat.kWebCryptoKeyFormatRaw);
+      }
+      break;
+    case 'Ed25519':
+    // Fall through
+    case 'Ed448':
+    // Fall through
+    case 'X25519':
+    // Fall through
+    case 'X448':
+      if (key.type === 'public') {
+        const exported = key.keyObject.handle.exportKey();
+        return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+      }
+      break;
+    case 'ML-KEM-512':
+    // Fall through
+    case 'ML-KEM-768':
+    // Fall through
+    case 'ML-KEM-1024':
+    // Fall through
+    case 'ML-DSA-44':
+    // Fall through
+    case 'ML-DSA-65':
+    // Fall through
+    case 'ML-DSA-87':
+      if (key.type === 'public') {
+        const exported = key.keyObject.handle.exportKey();
+        return (0, _conversion.bufferLikeToArrayBuffer)(exported);
+      }
+      break;
+    case 'AES-CTR':
+    // Fall through
+    case 'AES-CBC':
+    // Fall through
+    case 'AES-GCM':
+    // Fall through
+    case 'AES-KW':
+    // Fall through
+    case 'AES-OCB':
+    // Fall through
+    case 'ChaCha20-Poly1305':
+    // Fall through
+    case 'HMAC':
+    // Fall through
+    case 'KMAC128':
+    // Fall through
+    case 'KMAC256':
+      {
+        const exported = key.keyObject.export();
+        // Convert Buffer to ArrayBuffer
+        return exported.buffer.slice(exported.byteOffset, exported.byteOffset + exported.byteLength);
+      }
+  }
+  throw (0, _errors.lazyDOMException)(`Unable to export a raw ${key.algorithm.name} ${key.type} key`, 'InvalidAccessError');
+};
+const exportKeyJWK = key => {
+  const jwk = key.keyObject.handle.exportJwk({
+    key_ops: key.usages,
+    ext: key.extractable
+  }, true);
+  switch (key.algorithm.name) {
+    case 'RSASSA-PKCS1-v1_5':
+      jwk.alg = (0, _hashnames.normalizeHashName)(key.algorithm.hash, _hashnames.HashContext.JwkRsa);
+      return jwk;
+    case 'RSA-PSS':
+      jwk.alg = (0, _hashnames.normalizeHashName)(key.algorithm.hash, _hashnames.HashContext.JwkRsaPss);
+      return jwk;
+    case 'RSA-OAEP':
+      jwk.alg = (0, _hashnames.normalizeHashName)(key.algorithm.hash, _hashnames.HashContext.JwkRsaOaep);
+      return jwk;
+    case 'HMAC':
+      jwk.alg = (0, _hashnames.normalizeHashName)(key.algorithm.hash, _hashnames.HashContext.JwkHmac);
+      return jwk;
+    case 'KMAC128':
+      jwk.alg = 'K128';
+      return jwk;
+    case 'KMAC256':
+      jwk.alg = 'K256';
+      return jwk;
+    case 'ECDSA':
+    // Fall through
+    case 'ECDH':
+      jwk.crv ||= key.algorithm.namedCurve;
+      return jwk;
+    case 'Ed25519':
+    // Fall through
+    case 'Ed448':
+    // Fall through
+    case 'X25519':
+    // Fall through
+    case 'X448':
+      return jwk;
+    case 'AES-CTR':
+    // Fall through
+    case 'AES-CBC':
+    // Fall through
+    case 'AES-GCM':
+    // Fall through
+    case 'AES-KW':
+    // Fall through
+    case 'AES-OCB':
+    // Fall through
+    case 'ChaCha20-Poly1305':
+      if (key.algorithm.length === undefined) {
+        throw (0, _errors.lazyDOMException)(`Algorithm ${key.algorithm.name} missing required length property`, 'InvalidAccessError');
+      }
+      jwk.alg = getAlgorithmName(key.algorithm.name, key.algorithm.length);
+      return jwk;
+    default:
+    // Fall through
+  }
+  throw (0, _errors.lazyDOMException)(`JWK export not yet supported: ${key.algorithm.name}`, 'NotSupportedError');
+};
+const importGenericSecretKey = async ({
+  name,
+  length
+}, format, keyData, extractable, keyUsages) => {
+  if (extractable) {
+    throw new Error(`${name} keys are not extractable`);
+  }
+  if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
+    throw new Error(`Unsupported key usage for a ${name} key`);
+  }
+  switch (format) {
+    case 'raw':
+      {
+        if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
+          throw new Error(`Unsupported key usage for a ${name} key`);
+        }
+        const checkLength = typeof keyData === 'string' || _safeBuffer.Buffer.isBuffer(keyData) ? keyData.length * 8 : keyData.byteLength * 8;
+        if (length !== undefined && length !== checkLength) {
+          throw new Error('Invalid key length');
+        }
+        const keyObject = (0, _keys.createSecretKey)(keyData);
+        return new _keys.CryptoKey(keyObject, {
+          name
+        }, keyUsages, false);
+      }
+  }
+  throw new Error(`Unable to import ${name} key with format ${format}`);
+};
+const hkdfImportKey = async (format, keyData, algorithm, extractable, keyUsages) => {
+  const {
+    name
+  } = algorithm;
+  if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
+    throw new Error(`Unsupported key usage for a ${name} key`);
+  }
+  switch (format) {
+    case 'raw':
+      {
+        const keyObject = (0, _keys.createSecretKey)(keyData);
+        return new _keys.CryptoKey(keyObject, {
+          name
+        }, keyUsages, extractable);
+      }
+    default:
+      throw new Error(`Unable to import ${name} key with format ${format}`);
+  }
+};
+const checkCryptoKeyPairUsages = pair => {
+  if (pair.privateKey && pair.privateKey instanceof _keys.CryptoKey && pair.privateKey.keyUsages && pair.privateKey.keyUsages.length > 0) {
+    return;
+  }
+  throw (0, _errors.lazyDOMException)('Usages cannot be empty when creating a key.', 'SyntaxError');
+};
+function argon2DeriveBits(algorithm, baseKey, length) {
+  if (length === 0 || length % 8 !== 0) {
+    throw (0, _errors.lazyDOMException)('Invalid Argon2 derived key length', 'OperationError');
+  }
+  if (length < 32) {
+    throw (0, _errors.lazyDOMException)('Argon2 derived key length must be at least 32 bits', 'OperationError');
+  }
+  const {
+    nonce,
+    parallelism,
+    memory,
+    passes,
+    secretValue,
+    associatedData
+  } = algorithm;
+  const tagLength = length / 8;
+  const message = baseKey.keyObject.export();
+  const algName = algorithm.name.toLowerCase();
+  const result = (0, _argon.argon2Sync)(algName, {
+    message,
+    nonce: nonce ?? new Uint8Array(0),
+    parallelism: parallelism ?? 1,
+    tagLength,
+    memory: memory ?? 65536,
+    passes: passes ?? 3,
+    secret: secretValue,
+    associatedData,
+    version: algorithm.version
+  });
+  return (0, _conversion.bufferLikeToArrayBuffer)(result);
+}
+
+// Type guard to check if result is CryptoKeyPair
+function isCryptoKeyPair(result) {
+  return 'publicKey' in result && 'privateKey' in result;
+}
+function hmacSignVerify(key, data, signature) {
+  // Get hash algorithm from key
+  const hashName = (0, _hashnames.normalizeHashName)(key.algorithm.hash);
+
+  // Export the secret key material
+  const keyData = key.keyObject.export();
+
+  // Create HMAC and compute digest
+  const hmac = (0, _hmac.createHmac)(hashName, keyData);
+  hmac.update((0, _conversion.bufferLikeToArrayBuffer)(data));
+  const computed = hmac.digest();
+  if (signature === undefined) {
+    // Sign operation - return the HMAC as ArrayBuffer
+    return computed.buffer.slice(computed.byteOffset, computed.byteOffset + computed.byteLength);
+  }
+  const sigBuffer = (0, _conversion.bufferLikeToArrayBuffer)(signature);
+  const computedBuffer = computed.buffer.slice(computed.byteOffset, computed.byteOffset + computed.byteLength);
+  if (computedBuffer.byteLength !== sigBuffer.byteLength) {
+    return false;
+  }
+  return (0, _timingSafeEqual.timingSafeEqual)(new Uint8Array(computedBuffer), new Uint8Array(sigBuffer));
+}
+function rsaSignVerify(key, data, padding, signature, saltLength) {
+  // Get hash algorithm from key
+  const hashName = (0, _hashnames.normalizeHashName)(key.algorithm.hash);
+
+  // Determine RSA padding constant
+  const RSA_PKCS1_PADDING = 1;
+  const RSA_PKCS1_PSS_PADDING = 6;
+  const paddingValue = padding === 'pss' ? RSA_PKCS1_PSS_PADDING : RSA_PKCS1_PADDING;
+  if (signature === undefined) {
+    // Sign operation
+    const signer = (0, _signVerify.createSign)(hashName);
+    signer.update(data);
+    const sig = signer.sign({
+      key: key,
+      padding: paddingValue,
+      saltLength
+    });
+    return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+  }
+
+  // Verify operation
+  const verifier = (0, _signVerify.createVerify)(hashName);
+  verifier.update(data);
+  return verifier.verify({
+    key: key,
+    padding: paddingValue,
+    saltLength
+  }, signature);
+}
+function edSignVerify(key, data, signature) {
+  const isSign = signature === undefined;
+  const expectedKeyType = isSign ? 'private' : 'public';
+  if (key.type !== expectedKeyType) {
+    throw (0, _errors.lazyDOMException)(`Key must be a ${expectedKeyType} key`, 'InvalidAccessError');
+  }
+
+  // Get curve type from algorithm name (Ed25519 or Ed448)
+  const algorithmName = key.algorithm.name;
+  const curveType = algorithmName.toLowerCase();
+
+  // Create Ed instance with the curve
+  const ed = new _ed.Ed(curveType, {});
+
+  // Export raw key bytes (exportKey with no format returns raw for Ed keys)
+  const rawKey = key.keyObject.handle.exportKey();
+  const dataBuffer = (0, _conversion.bufferLikeToArrayBuffer)(data);
+  if (isSign) {
+    // Sign operation - use raw private key
+    const sig = ed.signSync(dataBuffer, rawKey);
+    return sig;
+  } else {
+    // Verify operation - use raw public key
+    const signatureBuffer = (0, _conversion.bufferLikeToArrayBuffer)(signature);
+    return ed.verifySync(signatureBuffer, dataBuffer, rawKey);
+  }
+}
+function mldsaSignVerify(key, data, signature) {
+  const isSign = signature === undefined;
+  const expectedKeyType = isSign ? 'private' : 'public';
+  if (key.type !== expectedKeyType) {
+    throw (0, _errors.lazyDOMException)(`Key must be a ${expectedKeyType} key`, 'InvalidAccessError');
+  }
+  const dataBuffer = (0, _conversion.bufferLikeToArrayBuffer)(data);
+  if (isSign) {
+    const signer = (0, _signVerify.createSign)('');
+    signer.update(dataBuffer);
+    const sig = signer.sign({
+      key: key
+    });
+    return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+  } else {
+    const signatureBuffer = (0, _conversion.bufferLikeToArrayBuffer)(signature);
+    const verifier = (0, _signVerify.createVerify)('');
+    verifier.update(dataBuffer);
+    return verifier.verify({
+      key: key
+    }, signatureBuffer);
+  }
+}
+const signVerify = (algorithm, key, data, signature) => {
+  const usage = signature === undefined ? 'sign' : 'verify';
+  algorithm = normalizeAlgorithm(algorithm, usage);
+  if (!key.usages.includes(usage) || algorithm.name !== key.algorithm.name) {
+    throw (0, _errors.lazyDOMException)(`Unable to use this key to ${usage}`, 'InvalidAccessError');
+  }
+  switch (algorithm.name) {
+    case 'ECDSA':
+      return (0, _ec.ecdsaSignVerify)(key, data, algorithm, signature);
+    case 'HMAC':
+      return hmacSignVerify(key, data, signature);
+    case 'RSASSA-PKCS1-v1_5':
+      return rsaSignVerify(key, data, 'pkcs1', signature);
+    case 'RSA-PSS':
+      return rsaSignVerify(key, data, 'pss', signature, algorithm.saltLength);
+    case 'Ed25519':
+    case 'Ed448':
+      return edSignVerify(key, data, signature);
+    case 'ML-DSA-44':
+    case 'ML-DSA-65':
+    case 'ML-DSA-87':
+      return mldsaSignVerify(key, data, signature);
+    case 'KMAC128':
+    case 'KMAC256':
+      return kmacSignVerify(key, data, algorithm, signature);
+  }
+  throw (0, _errors.lazyDOMException)(`Unrecognized algorithm name '${algorithm.name}' for '${usage}'`, 'NotSupportedError');
+};
+const cipherOrWrap = async (mode, algorithm, key, data, op) => {
+  if (key.algorithm.name !== algorithm.name || !key.usages.includes(op)) {
+    throw (0, _errors.lazyDOMException)('The requested operation is not valid for the provided key', 'InvalidAccessError');
+  }
+  (0, _validation.validateMaxBufferLength)(data, 'data');
+  switch (algorithm.name) {
+    case 'RSA-OAEP':
+      return rsaCipher(mode, key, data, algorithm);
+    case 'AES-CTR':
+    // Fall through
+    case 'AES-CBC':
+    // Fall through
+    case 'AES-GCM':
+    // Fall through
+    case 'AES-OCB':
+      return aesCipher(mode, key, data, algorithm);
+    case 'AES-KW':
+      return aesKwCipher(mode, key, data);
+    case 'ChaCha20-Poly1305':
+      return chaCha20Poly1305Cipher(mode, key, data, algorithm);
+  }
+};
+const SUPPORTED_ALGORITHMS = {
+  encrypt: new Set(['RSA-OAEP', 'AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-OCB', 'ChaCha20-Poly1305']),
+  decrypt: new Set(['RSA-OAEP', 'AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-OCB', 'ChaCha20-Poly1305']),
+  sign: new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'ECDSA', 'HMAC', 'KMAC128', 'KMAC256', 'Ed25519', 'Ed448', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']),
+  verify: new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'ECDSA', 'HMAC', 'KMAC128', 'KMAC256', 'Ed25519', 'Ed448', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87']),
+  digest: new Set(['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512', 'SHA3-256', 'SHA3-384', 'SHA3-512', 'cSHAKE128', 'cSHAKE256']),
+  generateKey: new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'RSA-OAEP', 'ECDSA', 'ECDH', 'Ed25519', 'Ed448', 'X25519', 'X448', 'AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW', 'AES-OCB', 'ChaCha20-Poly1305', 'HMAC', 'KMAC128', 'KMAC256', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  importKey: new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'RSA-OAEP', 'ECDSA', 'ECDH', 'Ed25519', 'Ed448', 'X25519', 'X448', 'AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW', 'AES-OCB', 'ChaCha20-Poly1305', 'HMAC', 'KMAC128', 'KMAC256', 'HKDF', 'PBKDF2', 'Argon2d', 'Argon2i', 'Argon2id', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  exportKey: new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'RSA-OAEP', 'ECDSA', 'ECDH', 'Ed25519', 'Ed448', 'X25519', 'X448', 'AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW', 'AES-OCB', 'ChaCha20-Poly1305', 'HMAC', 'KMAC128', 'KMAC256', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  deriveBits: new Set(['PBKDF2', 'HKDF', 'ECDH', 'X25519', 'X448', 'Argon2d', 'Argon2i', 'Argon2id']),
+  wrapKey: new Set(['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW', 'AES-OCB', 'ChaCha20-Poly1305', 'RSA-OAEP']),
+  unwrapKey: new Set(['AES-CTR', 'AES-CBC', 'AES-GCM', 'AES-KW', 'AES-OCB', 'ChaCha20-Poly1305', 'RSA-OAEP']),
+  encapsulateBits: new Set(['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  decapsulateBits: new Set(['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  encapsulateKey: new Set(['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']),
+  decapsulateKey: new Set(['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024'])
+};
+const ASYMMETRIC_ALGORITHMS = new Set(['RSASSA-PKCS1-v1_5', 'RSA-PSS', 'RSA-OAEP', 'ECDSA', 'ECDH', 'Ed25519', 'Ed448', 'X25519', 'X448', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87', 'ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024']);
+class Subtle {
+  static supports(operation, algorithm, _lengthOrAdditionalAlgorithm) {
+    let normalizedAlgorithm;
+    try {
+      normalizedAlgorithm = normalizeAlgorithm(algorithm, operation === 'getPublicKey' ? 'exportKey' : operation);
+    } catch {
+      return false;
+    }
+    const name = normalizedAlgorithm.name;
+    if (operation === 'getPublicKey') {
+      return ASYMMETRIC_ALGORITHMS.has(name);
+    }
+    if (operation === 'deriveKey') {
+      var _SUPPORTED_ALGORITHMS;
+      // deriveKey decomposes to deriveBits + importKey of additional algorithm
+      if (!((_SUPPORTED_ALGORITHMS = SUPPORTED_ALGORITHMS.deriveBits) !== null && _SUPPORTED_ALGORITHMS !== void 0 && _SUPPORTED_ALGORITHMS.has(name))) return false;
+      if (_lengthOrAdditionalAlgorithm != null) {
+        try {
+          var _SUPPORTED_ALGORITHMS2;
+          const additionalAlg = normalizeAlgorithm(_lengthOrAdditionalAlgorithm, 'importKey');
+          return ((_SUPPORTED_ALGORITHMS2 = SUPPORTED_ALGORITHMS.importKey) === null || _SUPPORTED_ALGORITHMS2 === void 0 ? void 0 : _SUPPORTED_ALGORITHMS2.has(additionalAlg.name)) ?? false;
+        } catch {
+          return false;
+        }
+      }
+      return true;
+    }
+    const supported = SUPPORTED_ALGORITHMS[operation];
+    if (!supported) return false;
+    return supported.has(name);
+  }
+  async decrypt(algorithm, key, data) {
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'decrypt');
+    return cipherOrWrap(CipherOrWrapMode.kWebCryptoCipherDecrypt, normalizedAlgorithm, key, (0, _conversion.bufferLikeToArrayBuffer)(data), 'decrypt');
+  }
+  async digest(algorithm, data) {
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'digest');
+    return (0, _hash.asyncDigest)(normalizedAlgorithm, data);
+  }
+  async deriveBits(algorithm, baseKey, length) {
+    // Allow either deriveBits OR deriveKey usage (WebCrypto spec allows both)
+    if (!baseKey.keyUsages.includes('deriveBits') && !baseKey.keyUsages.includes('deriveKey')) {
+      throw new Error('baseKey does not have deriveBits or deriveKey usage');
+    }
+    if (baseKey.algorithm.name !== algorithm.name) throw new Error('Key algorithm mismatch');
+    switch (algorithm.name) {
+      case 'PBKDF2':
+        return (0, _pbkdf.pbkdf2DeriveBits)(algorithm, baseKey, length);
+      case 'X25519':
+      // Fall through
+      case 'X448':
+        return (0, _ed.xDeriveBits)(algorithm, baseKey, length);
+      case 'ECDH':
+        return (0, _ec.ecDeriveBits)(algorithm, baseKey, length);
+      case 'HKDF':
+        return (0, _hkdf.hkdfDeriveBits)(algorithm, baseKey, length);
+      case 'Argon2d':
+      case 'Argon2i':
+      case 'Argon2id':
+        return argon2DeriveBits(algorithm, baseKey, length);
+    }
+    throw new Error(`'subtle.deriveBits()' for ${algorithm.name} is not implemented.`);
+  }
+  async deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+    // Validate baseKey usage
+    if (!baseKey.usages.includes('deriveKey') && !baseKey.usages.includes('deriveBits')) {
+      throw (0, _errors.lazyDOMException)('baseKey does not have deriveKey or deriveBits usage', 'InvalidAccessError');
+    }
+
+    // Calculate required key length
+    const length = getKeyLength(derivedKeyAlgorithm);
+
+    // Step 1: Derive bits
+    let derivedBits;
+    if (baseKey.algorithm.name !== algorithm.name) throw new Error('Key algorithm mismatch');
+    switch (algorithm.name) {
+      case 'PBKDF2':
+        derivedBits = await (0, _pbkdf.pbkdf2DeriveBits)(algorithm, baseKey, length);
+        break;
+      case 'X25519':
+      // Fall through
+      case 'X448':
+        derivedBits = await (0, _ed.xDeriveBits)(algorithm, baseKey, length);
+        break;
+      case 'ECDH':
+        derivedBits = await (0, _ec.ecDeriveBits)(algorithm, baseKey, length);
+        break;
+      case 'HKDF':
+        derivedBits = (0, _hkdf.hkdfDeriveBits)(algorithm, baseKey, length);
+        break;
+      case 'Argon2d':
+      case 'Argon2i':
+      case 'Argon2id':
+        derivedBits = argon2DeriveBits(algorithm, baseKey, length);
+        break;
+      default:
+        throw new Error(`'subtle.deriveKey()' for ${algorithm.name} is not implemented.`);
+    }
+
+    // Step 2: Import as key
+    return this.importKey('raw', derivedBits, derivedKeyAlgorithm, extractable, keyUsages);
+  }
+  async encrypt(algorithm, key, data) {
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'encrypt');
+    return cipherOrWrap(CipherOrWrapMode.kWebCryptoCipherEncrypt, normalizedAlgorithm, key, (0, _conversion.bufferLikeToArrayBuffer)(data), 'encrypt');
+  }
+  async exportKey(format, key) {
+    if (!key.extractable) throw new Error('key is not extractable');
+    if (format === 'raw-seed') {
+      const pqcAlgos = ['ML-KEM-512', 'ML-KEM-768', 'ML-KEM-1024', 'ML-DSA-44', 'ML-DSA-65', 'ML-DSA-87'];
+      if (!pqcAlgos.includes(key.algorithm.name)) {
+        throw (0, _errors.lazyDOMException)('raw-seed export only supported for PQC keys', 'NotSupportedError');
+      }
+      if (key.type !== 'private') {
+        throw (0, _errors.lazyDOMException)('raw-seed export requires a private key', 'InvalidAccessError');
+      }
+      return (0, _conversion.bufferLikeToArrayBuffer)(key.keyObject.handle.exportKey());
+    }
+
+    // Note: 'raw-seed' is handled above; do NOT normalize it here
+    if (format === 'raw-secret' || format === 'raw-public') format = 'raw';
+    switch (format) {
+      case 'spki':
+        return await exportKeySpki(key);
+      case 'pkcs8':
+        return await exportKeyPkcs8(key);
+      case 'jwk':
+        return exportKeyJWK(key);
+      case 'raw':
+        return exportKeyRaw(key);
+    }
+  }
+  async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
+    // Validate wrappingKey usage
+    if (!wrappingKey.usages.includes('wrapKey')) {
+      throw (0, _errors.lazyDOMException)('wrappingKey does not have wrapKey usage', 'InvalidAccessError');
+    }
+
+    // Step 1: Export the key
+    const exported = await this.exportKey(format, key);
+
+    // Step 2: Convert to ArrayBuffer if JWK
+    let keyData;
+    if (format === 'jwk') {
+      const jwkString = JSON.stringify(exported);
+      const buffer = _safeBuffer.Buffer.from(jwkString, 'utf8');
+
+      // For AES-KW, pad to multiple of 8 bytes (accounting for null terminator)
+      if (wrapAlgorithm.name === 'AES-KW') {
+        const length = buffer.length;
+        // Add 1 for null terminator, then pad to multiple of 8
+        const paddedLength = Math.ceil((length + 1) / 8) * 8;
+        const paddedBuffer = _safeBuffer.Buffer.alloc(paddedLength);
+        buffer.copy(paddedBuffer);
+        // Null terminator for JSON string (remaining bytes are already zeros from alloc)
+        paddedBuffer.writeUInt8(0, length);
+        keyData = (0, _conversion.bufferLikeToArrayBuffer)(paddedBuffer);
+      } else {
+        keyData = (0, _conversion.bufferLikeToArrayBuffer)(buffer);
+      }
+    } else {
+      keyData = exported;
+    }
+
+    // Step 3: Encrypt the exported key
+    return cipherOrWrap(CipherOrWrapMode.kWebCryptoCipherEncrypt, wrapAlgorithm, wrappingKey, keyData, 'wrapKey');
+  }
+  async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
+    // Validate unwrappingKey usage
+    if (!unwrappingKey.usages.includes('unwrapKey')) {
+      throw (0, _errors.lazyDOMException)('unwrappingKey does not have unwrapKey usage', 'InvalidAccessError');
+    }
+
+    // Step 1: Decrypt the wrapped key
+    const decrypted = await cipherOrWrap(CipherOrWrapMode.kWebCryptoCipherDecrypt, unwrapAlgorithm, unwrappingKey, (0, _conversion.bufferLikeToArrayBuffer)(wrappedKey), 'unwrapKey');
+
+    // Step 2: Convert to appropriate format
+    let keyData;
+    if (format === 'jwk') {
+      const buffer = _safeBuffer.Buffer.from(decrypted);
+      // For AES-KW, the data may be padded - find the null terminator
+      let jwkString;
+      if (unwrapAlgorithm.name === 'AES-KW') {
+        // Find the null terminator (if present) to get the original string
+        const nullIndex = buffer.indexOf(0);
+        if (nullIndex !== -1) {
+          jwkString = buffer.toString('utf8', 0, nullIndex);
+        } else {
+          // No null terminator, try to parse the whole buffer
+          jwkString = buffer.toString('utf8').trim();
+        }
+      } else {
+        jwkString = buffer.toString('utf8');
+      }
+      keyData = JSON.parse(jwkString);
+    } else {
+      keyData = decrypted;
+    }
+
+    // Step 3: Import the key
+    return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages);
+  }
+  async generateKey(algorithm, extractable, keyUsages) {
+    algorithm = normalizeAlgorithm(algorithm, 'generateKey');
+    let result;
+    switch (algorithm.name) {
+      case 'RSASSA-PKCS1-v1_5':
+      // Fall through
+      case 'RSA-PSS':
+      // Fall through
+      case 'RSA-OAEP':
+        result = await (0, _rsa.rsa_generateKeyPair)(algorithm, extractable, keyUsages);
+        break;
+      case 'ECDSA':
+      // Fall through
+      case 'ECDH':
+        result = await (0, _ec.ec_generateKeyPair)(algorithm.name, algorithm.namedCurve, extractable, keyUsages);
+        checkCryptoKeyPairUsages(result);
+        break;
+      case 'AES-CTR':
+      // Fall through
+      case 'AES-CBC':
+      // Fall through
+      case 'AES-GCM':
+      // Fall through
+      case 'AES-KW':
+      // Fall through
+      case 'AES-OCB':
+        result = await aesGenerateKey(algorithm, extractable, keyUsages);
+        break;
+      case 'ChaCha20-Poly1305':
+        {
+          const length = algorithm.length ?? 256;
+          if (length !== 256) {
+            throw (0, _errors.lazyDOMException)('ChaCha20-Poly1305 only supports 256-bit keys', 'NotSupportedError');
+          }
+          result = await aesGenerateKey({
+            name: 'ChaCha20-Poly1305',
+            length: 256
+          }, extractable, keyUsages);
+          break;
+        }
+      case 'HMAC':
+        result = await hmacGenerateKey(algorithm, extractable, keyUsages);
+        break;
+      case 'KMAC128':
+      // Fall through
+      case 'KMAC256':
+        result = await kmacGenerateKey(algorithm, extractable, keyUsages);
+        break;
+      case 'Ed25519':
+      // Fall through
+      case 'Ed448':
+        result = await (0, _ed.ed_generateKeyPairWebCrypto)(algorithm.name.toLowerCase(), extractable, keyUsages);
+        checkCryptoKeyPairUsages(result);
+        break;
+      case 'ML-DSA-44':
+      // Fall through
+      case 'ML-DSA-65':
+      // Fall through
+      case 'ML-DSA-87':
+        result = await (0, _mldsa.mldsa_generateKeyPairWebCrypto)(algorithm.name, extractable, keyUsages);
+        checkCryptoKeyPairUsages(result);
+        break;
+      case 'X25519':
+      // Fall through
+      case 'X448':
+        result = await (0, _ed.x_generateKeyPairWebCrypto)(algorithm.name.toLowerCase(), extractable, keyUsages);
+        checkCryptoKeyPairUsages(result);
+        break;
+      case 'ML-KEM-512':
+      // Fall through
+      case 'ML-KEM-768':
+      // Fall through
+      case 'ML-KEM-1024':
+        result = await (0, _mlkem.mlkem_generateKeyPairWebCrypto)(algorithm.name, extractable, keyUsages);
+        checkCryptoKeyPairUsages(result);
+        break;
+      default:
+        throw new Error(`'subtle.generateKey()' is not implemented for ${algorithm.name}.
+            Unrecognized algorithm name`);
+    }
+    return result;
+  }
+  async getPublicKey(key, keyUsages) {
+    if (key.type === 'secret') {
+      throw (0, _errors.lazyDOMException)('key must be a private key', 'NotSupportedError');
+    }
+    if (key.type !== 'private') {
+      throw (0, _errors.lazyDOMException)('key must be a private key', 'InvalidAccessError');
+    }
+    const publicKeyObject = (0, _keys.createPublicKey)(key.keyObject);
+    return publicKeyObject.toCryptoKey(key.algorithm, true, keyUsages);
+  }
+  async importKey(format, data, algorithm, extractable, keyUsages) {
+    // Note: 'raw-seed' is NOT normalized — PQC import functions handle it directly
+    if (format === 'raw-secret' || format === 'raw-public') format = 'raw';
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'importKey');
+    let result;
+    switch (normalizedAlgorithm.name) {
+      case 'RSASSA-PKCS1-v1_5':
+      // Fall through
+      case 'RSA-PSS':
+      // Fall through
+      case 'RSA-OAEP':
+        result = rsaImportKey(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      case 'ECDSA':
+      // Fall through
+      case 'ECDH':
+        result = (0, _ec.ecImportKey)(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      case 'HMAC':
+        result = await hmacImportKey(normalizedAlgorithm, format, data, extractable, keyUsages);
+        break;
+      case 'KMAC128':
+      // Fall through
+      case 'KMAC256':
+        result = await kmacImportKey(normalizedAlgorithm, format, data, extractable, keyUsages);
+        break;
+      case 'AES-CTR':
+      // Fall through
+      case 'AES-CBC':
+      // Fall through
+      case 'AES-GCM':
+      // Fall through
+      case 'AES-KW':
+      // Fall through
+      case 'AES-OCB':
+      // Fall through
+      case 'ChaCha20-Poly1305':
+        result = await aesImportKey(normalizedAlgorithm, format, data, extractable, keyUsages);
+        break;
+      case 'PBKDF2':
+      case 'Argon2d':
+      case 'Argon2i':
+      case 'Argon2id':
+        result = await importGenericSecretKey(normalizedAlgorithm, format, data, extractable, keyUsages);
+        break;
+      case 'HKDF':
+        result = await hkdfImportKey(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      case 'X25519':
+      // Fall through
+      case 'X448':
+      // Fall through
+      case 'Ed25519':
+      // Fall through
+      case 'Ed448':
+        result = edImportKey(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      case 'ML-DSA-44':
+      // Fall through
+      case 'ML-DSA-65':
+      // Fall through
+      case 'ML-DSA-87':
+        result = mldsaImportKey(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      case 'ML-KEM-512':
+      // Fall through
+      case 'ML-KEM-768':
+      // Fall through
+      case 'ML-KEM-1024':
+        result = mlkemImportKey(format, data, normalizedAlgorithm, extractable, keyUsages);
+        break;
+      default:
+        throw new Error(`"subtle.importKey()" is not implemented for ${normalizedAlgorithm.name}`);
+    }
+    if ((result.type === 'secret' || result.type === 'private') && result.usages.length === 0) {
+      throw new Error(`Usages cannot be empty when importing a ${result.type} key.`);
+    }
+    return result;
+  }
+  async sign(algorithm, key, data) {
+    return signVerify(normalizeAlgorithm(algorithm, 'sign'), key, data);
+  }
+  async verify(algorithm, key, signature, data) {
+    return signVerify(normalizeAlgorithm(algorithm, 'verify'), key, data, signature);
+  }
+  _encapsulateCore(algorithm, key) {
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'encapsulateBits');
+    if (key.algorithm.name !== normalizedAlgorithm.name) {
+      throw (0, _errors.lazyDOMException)('Key algorithm mismatch', 'InvalidAccessError');
+    }
+    const variant = normalizedAlgorithm.name;
+    const mlkem = new _mlkem.MlKem(variant);
+    const keyData = key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+    mlkem.setPublicKey((0, _conversion.bufferLikeToArrayBuffer)(keyData), _utils.KFormatType.DER, _utils.KeyEncoding.SPKI);
+    return mlkem.encapsulateSync();
+  }
+  _decapsulateCore(algorithm, key, ciphertext) {
+    const normalizedAlgorithm = normalizeAlgorithm(algorithm, 'decapsulateBits');
+    if (key.algorithm.name !== normalizedAlgorithm.name) {
+      throw (0, _errors.lazyDOMException)('Key algorithm mismatch', 'InvalidAccessError');
+    }
+    const variant = normalizedAlgorithm.name;
+    const mlkem = new _mlkem.MlKem(variant);
+    const keyData = key.keyObject.handle.exportKey(_utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+    mlkem.setPrivateKey((0, _conversion.bufferLikeToArrayBuffer)(keyData), _utils.KFormatType.DER, _utils.KeyEncoding.PKCS8);
+    return mlkem.decapsulateSync((0, _conversion.bufferLikeToArrayBuffer)(ciphertext));
+  }
+  async encapsulateBits(algorithm, key) {
+    if (!key.usages.includes('encapsulateBits')) {
+      throw (0, _errors.lazyDOMException)('Key does not have encapsulateBits usage', 'InvalidAccessError');
+    }
+    return this._encapsulateCore(algorithm, key);
+  }
+  async encapsulateKey(algorithm, key, sharedKeyAlgorithm, extractable, usages) {
+    if (!key.usages.includes('encapsulateKey')) {
+      throw (0, _errors.lazyDOMException)('Key does not have encapsulateKey usage', 'InvalidAccessError');
+    }
+    const {
+      sharedKey,
+      ciphertext
+    } = this._encapsulateCore(algorithm, key);
+    const importedKey = await this.importKey('raw', sharedKey, sharedKeyAlgorithm, extractable, usages);
+    return {
+      key: importedKey,
+      ciphertext
+    };
+  }
+  async decapsulateBits(algorithm, key, ciphertext) {
+    if (!key.usages.includes('decapsulateBits')) {
+      throw (0, _errors.lazyDOMException)('Key does not have decapsulateBits usage', 'InvalidAccessError');
+    }
+    return this._decapsulateCore(algorithm, key, ciphertext);
+  }
+  async decapsulateKey(algorithm, key, ciphertext, sharedKeyAlgorithm, extractable, usages) {
+    if (!key.usages.includes('decapsulateKey')) {
+      throw (0, _errors.lazyDOMException)('Key does not have decapsulateKey usage', 'InvalidAccessError');
+    }
+    const sharedKey = this._decapsulateCore(algorithm, key, ciphertext);
+    return this.importKey('raw', sharedKey, sharedKeyAlgorithm, extractable, usages);
+  }
+}
+exports.Subtle = Subtle;
+const subtle = exports.subtle = new Subtle();
+function getKeyLength(algorithm) {
+  const name = algorithm.name;
+  switch (name) {
+    case 'AES-CTR':
+    case 'AES-CBC':
+    case 'AES-GCM':
+    case 'AES-KW':
+    case 'AES-OCB':
+    case 'ChaCha20-Poly1305':
+      return algorithm.length || 256;
+    case 'HMAC':
+      {
+        const hmacAlg = algorithm;
+        return hmacAlg.length || 256;
+      }
+    case 'KMAC128':
+      return algorithm.length || 128;
+    case 'KMAC256':
+      return algorithm.length || 256;
+    default:
+      throw (0, _errors.lazyDOMException)(`Cannot determine key length for ${name}`, 'NotSupportedError');
+  }
+}
+//# sourceMappingURL=subtle.js.map