@solibo/solibo-sdk 1.0.36 → 1.0.37

package/cryptography-kotlin-cryptography-provider-webcrypto.mjs

@@ -0,0 +1,1195 @@
+import {
+  CryptographyProviderwgv0x40nzvjc as CryptographyProvider,
+  Companion_getInstancebyslzqcunhpa as Companion_getInstance,
+  Companion_getInstance27u04a1q2cj1l as Companion_getInstance_0,
+  Companion_getInstance1b33mcojr5zhq as Companion_getInstance_1,
+  Companion_getInstance3av3p4gc6a7jn as Companion_getInstance_2,
+  Companion_getInstance3ark4b05maj30 as Companion_getInstance_3,
+  Companion_getInstancei93icbc9wljv as Companion_getInstance_4,
+  Companion_getInstance1xf5ipdr52o1p as Companion_getInstance_5,
+  Companion_getInstance1x88e8a93nrjt as Companion_getInstance_6,
+  Companion_getInstance29kae6fn9dtdp as Companion_getInstance_7,
+  Companion_getInstance14mxn5i96muxk as Companion_getInstance_8,
+  Companion_getInstance1ols9hsmvo0w0 as Companion_getInstance_9,
+  SHA512_getInstance2nwy6uke6ngga as SHA512_getInstance,
+  SHA384_getInstance3dym6gio4iqu3 as SHA384_getInstance,
+  SHA256_getInstanceth9eotqeth9c as SHA256_getInstance,
+  SHA1_getInstance3jravpw4war2y as SHA1_getInstance,
+  CryptographyAlgorithmhhdrgo7p9qei as CryptographyAlgorithm,
+  Format3dwngdi37q0un as Format,
+  Hashera1nteuzom60c as Hasher,
+  DER_getInstancetcz4fdgsag6y as DER_getInstance,
+  PEM_getInstance2z3eojfgxggki as PEM_getInstance,
+  Uncompressed_getInstance30v9709kpt3rd as Uncompressed_getInstance,
+  Compressed_getInstance2bou73k6m6h1m as Compressed_getInstance,
+  JWK_getInstance2g6m6ouqgdqfw as JWK_getInstance,
+  Format1u440c2w9z1t5 as Format_0,
+  RAW_getInstance1owkiklujln96 as RAW_getInstance,
+  Generic_getInstance2fofokuhcjf0m as Generic_getInstance,
+  Generic_getInstance2z3qu9f7wt665 as Generic_getInstance_0,
+  SEC1_getInstance1h1itfa9pvqru as SEC1_getInstance,
+  SEC1_getInstance19ihk9fm1tmnu as SEC1_getInstance_0,
+  JWK_getInstance1yvqt4fvwl3gg as JWK_getInstance_0,
+  Format2r6rz6bygg1d5 as Format_1,
+  Companion_instance2xzuy5itlbd7r as Companion_instance,
+  _Curve___get_name__impl__klrusc2ntyd3phrcyut as _Curve___get_name__impl__klrusc,
+  Format1jug7lc3rg0qd as Format_2,
+  Generic_getInstanced4eii9e2nhqx as Generic_getInstance_1,
+  Generic_getInstance1ub4kp2qez9cr as Generic_getInstance_2,
+  PKCS1_getInstance22spptdubofqd as PKCS1_getInstance,
+  PKCS1_getInstance5evnhy9k9oay as PKCS1_getInstance_0,
+  JWK_getInstance2h7f972qw3rxx as JWK_getInstance_1,
+  Format2v29dvc3oaj5k as Format_3,
+  Generic_getInstanceuanw2vo9armh as Generic_getInstance_3,
+  Generic_getInstance7jxucsv5q1mh as Generic_getInstance_4,
+  PKCS1_getInstance868e3tfzube as PKCS1_getInstance_1,
+  PKCS1_getInstance3a4r0yeoubefu as PKCS1_getInstance_2,
+  JWK_getInstance1fp08shy8nryg as JWK_getInstance_2,
+  Format1i0i1l8xjk06m as Format_4,
+  KeyDecoder1aj9ibfkm03tn as KeyDecoder,
+  SignatureGenerator3tx2fdhty5h2c as SignatureGenerator,
+  CryptographySystem_getInstance1v1h7y5ver0lp as CryptographySystem_getInstance,
+} from './cryptography-kotlin-cryptography-core.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  isInterface3d6p8outrmvmk as isInterface,
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  VOID3gxj6tk5isa35 as VOID,
+  lazy2hsh8ze7j6ikd as lazy,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  decodeToString1x4faah2liw2p as decodeToString,
+  intercepted2ogpsikxxj4u0 as intercepted,
+  SafeContinuation_init_$Create$1psyp4r0sb3mp as SafeContinuation_init_$Create$,
+  Companion_instance25ullnynvxd0w as Companion_instance_0,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from './kotlin-kotlin-stdlib.mjs';
+import { Companion_getInstance3pdkh2psd8hnn as Companion_getInstance_10 } from './cryptography-kotlin-cryptography-serialization-pem.mjs';
+import {
+  unwrapPem161z0z59ia531 as unwrapPem,
+  convertEcPrivateKeyFromSec1ToPkcs81ruidkpvnvcm1 as convertEcPrivateKeyFromSec1ToPkcs8,
+  wrapPrivateKeyInfo2mp8aghrbbbyt as wrapPrivateKeyInfo,
+  wrapSubjectPublicKeyInfo1w2wxg0b5ey1b as wrapSubjectPublicKeyInfo,
+} from './cryptography-kotlin-cryptography-provider-base.mjs';
+import {
+  Companion_instance3nsfjzff13l9z as Companion_instance_1,
+  Default_getInstance3bn6zrp4tkdoy as Default_getInstance,
+} from './cryptography-kotlin-cryptography-serialization-asn1.mjs';
+import {
+  get_secp521r13hkek2jcv829c as get_secp521r1,
+  get_secp384r13mvgyp383nadu as get_secp384r1,
+  get_secp256r12zskpql6xanyk as get_secp256r1,
+  _EcParameters___init__impl__i4ww9zuq3d437583rt as _EcParameters___init__impl__i4ww9z,
+  EcKeyAlgorithmIdentifierwk35bb676c3o as EcKeyAlgorithmIdentifier,
+  Companion_instancee26uvkz58yu2 as Companion_instance_2,
+  EcPrivateKey2terz948ch7xt as EcPrivateKey,
+  RsaKeyAlgorithmIdentifier_instance1snja7vvnuucb as RsaKeyAlgorithmIdentifier_instance,
+} from './cryptography-kotlin-cryptography-serialization-asn1-modules.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForObject(WebCryptoCryptographyProvider, 'WebCryptoCryptographyProvider', VOID, CryptographyProvider);
+initMetadataForClass(WebCryptoEncodableKey, 'WebCryptoEncodableKey', VOID, VOID, VOID, [1]);
+initMetadataForClass(AesKey, 'AesKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForClass(WebCryptoAes, 'WebCryptoAes', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForClass(WebCryptoKeyProcessor, 'WebCryptoKeyProcessor');
+initMetadataForObject(AesKeyProcessor, 'AesKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForClass(AesCbcKey, 'AesCbcKey', VOID, AesKey, VOID, [1]);
+initMetadataForObject(WebCryptoAesCbc, 'WebCryptoAesCbc', VOID, WebCryptoAes, [WebCryptoAes, CryptographyAlgorithm]);
+initMetadataForClass(AesCtrKey, 'AesCtrKey', VOID, AesKey, VOID, [1]);
+initMetadataForObject(WebCryptoAesCtr, 'WebCryptoAesCtr', VOID, WebCryptoAes, [WebCryptoAes, CryptographyAlgorithm]);
+initMetadataForClass(AesGcmKey, 'AesGcmKey', VOID, AesKey, VOID, [1]);
+initMetadataForObject(WebCryptoAesGcm, 'WebCryptoAesGcm', VOID, WebCryptoAes, [WebCryptoAes, CryptographyAlgorithm]);
+initMetadataForCompanion(Companion);
+initMetadataForClass(WebCryptoDigest, 'WebCryptoDigest', VOID, VOID, [CryptographyAlgorithm, Hasher], [1]);
+initMetadataForClass(EcPublicKey, 'EcPublicKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForClass(EcPrivateKey_0, 'EcPrivateKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForClass(WebCryptoEc, 'WebCryptoEc', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForObject(EcPublicKeyProcessor, 'EcPublicKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForObject(EcPrivateKeyProcessor, 'EcPrivateKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForClass(EcdhKeyPair, 'EcdhKeyPair');
+initMetadataForClass(EcdhPublicKey, 'EcdhPublicKey', VOID, EcPublicKey, VOID, [1]);
+initMetadataForClass(EcdhPrivateKey, 'EcdhPrivateKey', VOID, EcPrivateKey_0, VOID, [1]);
+initMetadataForObject(WebCryptoEcdh, 'WebCryptoEcdh', VOID, WebCryptoEc, [WebCryptoEc, CryptographyAlgorithm]);
+initMetadataForClass(EcdsaKeyPair, 'EcdsaKeyPair');
+initMetadataForClass(EcdsaPublicKey, 'EcdsaPublicKey', VOID, EcPublicKey, VOID, [1]);
+initMetadataForClass(EcdsaPrivateKey, 'EcdsaPrivateKey', VOID, EcPrivateKey_0, VOID, [1]);
+initMetadataForObject(WebCryptoEcdsa, 'WebCryptoEcdsa', VOID, WebCryptoEc, [WebCryptoEc, CryptographyAlgorithm]);
+initMetadataForObject(WebCryptoHkdf, 'WebCryptoHkdf', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForClass(HmacKey, 'HmacKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForObject(WebCryptoHmac, 'WebCryptoHmac', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForObject(HmacKeyProcessor, 'HmacKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForObject(WebCryptoPbkdf2, 'WebCryptoPbkdf2', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForClass(RsaPublicKey, 'RsaPublicKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForClass(RsaPrivateKey, 'RsaPrivateKey', VOID, WebCryptoEncodableKey, VOID, [1]);
+initMetadataForClass(WebCryptoRsa, 'WebCryptoRsa', VOID, VOID, [CryptographyAlgorithm]);
+initMetadataForObject(RsaPublicKeyProcessor, 'RsaPublicKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForObject(RsaPrivateKeyProcessor, 'RsaPrivateKeyProcessor', VOID, WebCryptoKeyProcessor);
+initMetadataForClass(RsaOaepKeyPair, 'RsaOaepKeyPair');
+initMetadataForClass(RsaOaepPublicKey, 'RsaOaepPublicKey', VOID, RsaPublicKey, VOID, [1]);
+initMetadataForClass(RsaOaepPrivateKey, 'RsaOaepPrivateKey', VOID, RsaPrivateKey, VOID, [1]);
+initMetadataForObject(WebCryptoRsaOaep, 'WebCryptoRsaOaep', VOID, WebCryptoRsa, [WebCryptoRsa, CryptographyAlgorithm]);
+initMetadataForClass(RsaPkcs1KeyPair, 'RsaPkcs1KeyPair');
+initMetadataForClass(RsaPkcs1PublicKey, 'RsaPkcs1PublicKey', VOID, RsaPublicKey, VOID, [1]);
+initMetadataForClass(RsaPkcs1PrivateKey, 'RsaPkcs1PrivateKey', VOID, RsaPrivateKey, VOID, [1]);
+initMetadataForObject(WebCryptoRsaPkcs1, 'WebCryptoRsaPkcs1', VOID, WebCryptoRsa, [WebCryptoRsa, CryptographyAlgorithm]);
+initMetadataForClass(RsaPssKeyPair, 'RsaPssKeyPair');
+initMetadataForClass(RsaPssPublicKey, 'RsaPssPublicKey', VOID, RsaPublicKey, VOID, [1]);
+initMetadataForClass(RsaPssPrivateKey, 'RsaPssPrivateKey', VOID, RsaPrivateKey, VOID, [1]);
+initMetadataForObject(WebCryptoRsaPss, 'WebCryptoRsaPss', VOID, WebCryptoRsa, [WebCryptoRsa, CryptographyAlgorithm]);
+initMetadataForCoroutine($decodeFromByteArrayCOROUTINE$, CoroutineImpl);
+initMetadataForClass(WebCryptoKeyDecoder, 'WebCryptoKeyDecoder', VOID, VOID, [KeyDecoder], [2]);
+initMetadataForClass(WebCryptoKeyWrapper, 'WebCryptoKeyWrapper');
+initMetadataForClass(WebCryptoSignatureGenerator, 'WebCryptoSignatureGenerator', VOID, VOID, [SignatureGenerator], [1]);
+initMetadataForCoroutine($digestCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($signCOROUTINE$, CoroutineImpl);
+initMetadataForObject(WebCrypto, 'WebCrypto', VOID, VOID, VOID, [2, 3, 4, 5]);
+//endregion
+function get_defaultProvider() {
+  _init_properties_WebCryptoCryptographyProvider_kt__i22tls();
+  return defaultProvider;
+}
+var defaultProvider;
+var WebCrypto$delegate;
+function WebCryptoCryptographyProvider() {
+  WebCryptoCryptographyProvider_instance = this;
+  CryptographyProvider.call(this);
+}
+protoOf(WebCryptoCryptographyProvider).ko6 = function (identifier) {
+  var tmp = equals(identifier, SHA1_getInstance()) ? Companion_getInstance_11().bob_1 : equals(identifier, SHA256_getInstance()) ? Companion_getInstance_11().cob_1 : equals(identifier, SHA384_getInstance()) ? Companion_getInstance_11().dob_1 : equals(identifier, SHA512_getInstance()) ? Companion_getInstance_11().eob_1 : equals(identifier, Companion_getInstance_9()) ? WebCryptoHmac_getInstance() : equals(identifier, Companion_getInstance_8()) ? WebCryptoAesCbc_getInstance() : equals(identifier, Companion_getInstance_7()) ? WebCryptoAesCtr_getInstance() : equals(identifier, Companion_getInstance_6()) ? WebCryptoAesGcm_getInstance() : equals(identifier, Companion_getInstance_5()) ? WebCryptoRsaOaep_getInstance() : equals(identifier, Companion_getInstance_4()) ? WebCryptoRsaPss_getInstance() : equals(identifier, Companion_getInstance_3()) ? WebCryptoRsaPkcs1_getInstance() : equals(identifier, Companion_getInstance_2()) ? WebCryptoEcdsa_getInstance() : equals(identifier, Companion_getInstance_1()) ? WebCryptoEcdh_getInstance() : equals(identifier, Companion_getInstance_0()) ? WebCryptoPbkdf2_instance : equals(identifier, Companion_getInstance()) ? WebCryptoHkdf_instance : null;
+  return (tmp == null ? true : isInterface(tmp, CryptographyAlgorithm)) ? tmp : THROW_CCE();
+};
+var WebCryptoCryptographyProvider_instance;
+function WebCryptoCryptographyProvider_getInstance() {
+  if (WebCryptoCryptographyProvider_instance == null)
+    new WebCryptoCryptographyProvider();
+  return WebCryptoCryptographyProvider_instance;
+}
+function defaultProvider$lambda() {
+  _init_properties_WebCryptoCryptographyProvider_kt__i22tls();
+  return WebCryptoCryptographyProvider_getInstance();
+}
+var properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u;
+function _init_properties_WebCryptoCryptographyProvider_kt__i22tls() {
+  if (!properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u) {
+    properties_initialized_WebCryptoCryptographyProvider_kt_n89q9u = true;
+    defaultProvider = lazy(defaultProvider$lambda);
+    WebCrypto$delegate = get_defaultProvider();
+  }
+}
+function AesKey(key) {
+  WebCryptoEncodableKey.call(this, key, AesKeyProcessor_getInstance());
+  this.hob_1 = key;
+}
+function WebCryptoAes(algorithmName, keyWrapper) {
+  this.iob_1 = algorithmName;
+  this.job_1 = keyWrapper;
+}
+function AesKeyProcessor() {
+  AesKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(AesKeyProcessor).kob = function (format) {
+  var tmp;
+  switch (format.a1_1) {
+    case 0:
+      tmp = 'raw';
+      break;
+    case 1:
+      tmp = 'jwk';
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+};
+protoOf(AesKeyProcessor).lob = function (format) {
+  return this.kob(format instanceof Format ? format : THROW_CCE());
+};
+protoOf(AesKeyProcessor).mob = function (algorithm, format, key) {
+  return key;
+};
+protoOf(AesKeyProcessor).nob = function (algorithm, format, key) {
+  return this.mob(algorithm, format instanceof Format ? format : THROW_CCE(), key);
+};
+var AesKeyProcessor_instance;
+function AesKeyProcessor_getInstance() {
+  if (AesKeyProcessor_instance == null)
+    new AesKeyProcessor();
+  return AesKeyProcessor_instance;
+}
+function AesCbcKey(key) {
+  AesKey.call(this, key);
+}
+function WebCryptoAesCbc$AesCbcKey$_init_$ref_lop2vf() {
+  var l = function (p0) {
+    return new AesCbcKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoAesCbc() {
+  WebCryptoAesCbc_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['encrypt', 'decrypt'];
+  WebCryptoAes.call(this, 'AES-CBC', new WebCryptoKeyWrapper(tmp, WebCryptoAesCbc$AesCbcKey$_init_$ref_lop2vf()));
+}
+var WebCryptoAesCbc_instance;
+function WebCryptoAesCbc_getInstance() {
+  if (WebCryptoAesCbc_instance == null)
+    new WebCryptoAesCbc();
+  return WebCryptoAesCbc_instance;
+}
+function AesCtrKey(key) {
+  AesKey.call(this, key);
+}
+function WebCryptoAesCtr$AesCtrKey$_init_$ref_5qzjvv() {
+  var l = function (p0) {
+    return new AesCtrKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoAesCtr() {
+  WebCryptoAesCtr_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['encrypt', 'decrypt'];
+  WebCryptoAes.call(this, 'AES-CTR', new WebCryptoKeyWrapper(tmp, WebCryptoAesCtr$AesCtrKey$_init_$ref_5qzjvv()));
+}
+var WebCryptoAesCtr_instance;
+function WebCryptoAesCtr_getInstance() {
+  if (WebCryptoAesCtr_instance == null)
+    new WebCryptoAesCtr();
+  return WebCryptoAesCtr_instance;
+}
+function AesGcmKey(key) {
+  AesKey.call(this, key);
+}
+function WebCryptoAesGcm$AesGcmKey$_init_$ref_c6pr3f() {
+  var l = function (p0) {
+    return new AesGcmKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoAesGcm() {
+  WebCryptoAesGcm_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['encrypt', 'decrypt'];
+  WebCryptoAes.call(this, 'AES-GCM', new WebCryptoKeyWrapper(tmp, WebCryptoAesGcm$AesGcmKey$_init_$ref_c6pr3f()));
+}
+var WebCryptoAesGcm_instance;
+function WebCryptoAesGcm_getInstance() {
+  if (WebCryptoAesGcm_instance == null)
+    new WebCryptoAesGcm();
+  return WebCryptoAesGcm_instance;
+}
+function Companion() {
+  Companion_instance_3 = this;
+  this.bob_1 = new WebCryptoDigest('SHA-1', SHA1_getInstance());
+  this.cob_1 = new WebCryptoDigest('SHA-256', SHA256_getInstance());
+  this.dob_1 = new WebCryptoDigest('SHA-384', SHA384_getInstance());
+  this.eob_1 = new WebCryptoDigest('SHA-512', SHA512_getInstance());
+}
+var Companion_instance_3;
+function Companion_getInstance_11() {
+  if (Companion_instance_3 == null)
+    new Companion();
+  return Companion_instance_3;
+}
+function WebCryptoDigest(algorithm, id) {
+  Companion_getInstance_11();
+  this.oob_1 = algorithm;
+  this.pob_1 = id;
+}
+protoOf(WebCryptoDigest).qob = function () {
+  return this;
+};
+protoOf(WebCryptoDigest).bo7 = function (data, $completion) {
+  return WebCrypto_getInstance().sob(this.oob_1, data, $completion);
+};
+protoOf(WebCryptoDigest).ao7 = function () {
+  nonBlocking();
+};
+protoOf(WebCryptoDigest).co7 = function (data) {
+  nonBlocking();
+};
+function EcPublicKey(publicKey) {
+  WebCryptoEncodableKey.call(this, publicKey, EcPublicKeyProcessor_getInstance());
+  this.vob_1 = publicKey;
+}
+function EcPrivateKey_0(privateKey) {
+  WebCryptoEncodableKey.call(this, privateKey, EcPrivateKeyProcessor_getInstance());
+  this.yob_1 = privateKey;
+}
+function WebCryptoEc$keyPairWrapper$lambda($keyPairWrapper, this$0) {
+  return function (it) {
+    return $keyPairWrapper(this$0.coc_1.aoc_1(it.publicKey), this$0.doc_1.aoc_1(it.privateKey));
+  };
+}
+function WebCryptoEc(algorithmName, publicKeyWrapper, privateKeyWrapper, keyPairWrapper) {
+  this.boc_1 = algorithmName;
+  this.coc_1 = publicKeyWrapper;
+  this.doc_1 = privateKeyWrapper;
+  var tmp = this;
+  var tmp0 = this.coc_1.zob_1;
+  // Inline function 'kotlin.collections.plus' call
+  var elements = this.doc_1.zob_1;
+  // Inline function 'kotlin.js.asDynamic' call
+  tmp.eoc_1 = tmp0.concat(elements);
+  var tmp_0 = this;
+  tmp_0.foc_1 = WebCryptoEc$keyPairWrapper$lambda(keyPairWrapper, this);
+}
+function EcPublicKeyProcessor() {
+  EcPublicKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(EcPublicKeyProcessor).goc = function (format) {
+  var tmp;
+  if (equals(format, JWK_getInstance())) {
+    tmp = 'jwk';
+  } else if (equals(format, Uncompressed_getInstance()) || equals(format, Compressed_getInstance())) {
+    tmp = 'raw';
+  } else if (equals(format, DER_getInstance()) || equals(format, PEM_getInstance())) {
+    tmp = 'spki';
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(EcPublicKeyProcessor).lob = function (format) {
+  return this.goc(format instanceof Format_0 ? format : THROW_CCE());
+};
+protoOf(EcPublicKeyProcessor).hoc = function (algorithm, format, key) {
+  var tmp;
+  if (equals(format, JWK_getInstance())) {
+    tmp = key;
+  } else if (equals(format, Uncompressed_getInstance()) || equals(format, Compressed_getInstance())) {
+    tmp = key;
+  } else if (equals(format, DER_getInstance())) {
+    tmp = key;
+  } else if (equals(format, PEM_getInstance())) {
+    tmp = unwrapPem(Companion_getInstance_10().woa_1, key);
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(EcPublicKeyProcessor).nob = function (algorithm, format, key) {
+  return this.hoc(algorithm, format instanceof Format_0 ? format : THROW_CCE(), key);
+};
+var EcPublicKeyProcessor_instance;
+function EcPublicKeyProcessor_getInstance() {
+  if (EcPublicKeyProcessor_instance == null)
+    new EcPublicKeyProcessor();
+  return EcPublicKeyProcessor_instance;
+}
+function EcPrivateKeyProcessor() {
+  EcPrivateKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(EcPrivateKeyProcessor).ioc = function (format) {
+  var tmp;
+  if (equals(format, JWK_getInstance_0())) {
+    tmp = 'jwk';
+  } else if (equals(format, RAW_getInstance()) || equals(format, Generic_getInstance()) || (equals(format, Generic_getInstance_0()) || (equals(format, SEC1_getInstance()) || equals(format, SEC1_getInstance_0())))) {
+    tmp = 'pkcs8';
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(EcPrivateKeyProcessor).lob = function (format) {
+  return this.ioc(format instanceof Format_1 ? format : THROW_CCE());
+};
+protoOf(EcPrivateKeyProcessor).joc = function (algorithm, format, key) {
+  var tmp;
+  if (equals(format, JWK_getInstance_0())) {
+    tmp = key;
+  } else if (equals(format, RAW_getInstance())) {
+    var namedCurve = get_ecKeyAlgorithmNamedCurve(algorithm);
+    var tmp_0;
+    if (namedCurve === _Curve___get_name__impl__klrusc(Companion_instance.vo6())) {
+      tmp_0 = get_secp256r1(Companion_instance_1);
+    } else if (namedCurve === _Curve___get_name__impl__klrusc(Companion_instance.wo6())) {
+      tmp_0 = get_secp384r1(Companion_instance_1);
+    } else if (namedCurve === _Curve___get_name__impl__klrusc(Companion_instance.xo6())) {
+      tmp_0 = get_secp521r1(Companion_instance_1);
+    } else {
+      var message = 'Unknown curve: ' + namedCurve;
+      throw IllegalStateException_init_$Create$(toString(message));
+    }
+    var curveId = tmp_0;
+    tmp = wrapPrivateKeyInfo(0, new EcKeyAlgorithmIdentifier(_EcParameters___init__impl__i4ww9z(curveId)), Default_getInstance().yt(Companion_instance_2.g63(), new EcPrivateKey(1, key)));
+  } else if (equals(format, Generic_getInstance())) {
+    tmp = key;
+  } else if (equals(format, Generic_getInstance_0())) {
+    tmp = unwrapPem(Companion_getInstance_10().xoa_1, key);
+  } else if (equals(format, SEC1_getInstance())) {
+    tmp = convertEcPrivateKeyFromSec1ToPkcs8(key);
+  } else if (equals(format, SEC1_getInstance_0())) {
+    tmp = convertEcPrivateKeyFromSec1ToPkcs8(unwrapPem(Companion_getInstance_10().aob_1, key));
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(EcPrivateKeyProcessor).nob = function (algorithm, format, key) {
+  return this.joc(algorithm, format instanceof Format_1 ? format : THROW_CCE(), key);
+};
+var EcPrivateKeyProcessor_instance;
+function EcPrivateKeyProcessor_getInstance() {
+  if (EcPrivateKeyProcessor_instance == null)
+    new EcPrivateKeyProcessor();
+  return EcPrivateKeyProcessor_instance;
+}
+function EcdhKeyPair(publicKey, privateKey) {
+  this.koc_1 = publicKey;
+  this.loc_1 = privateKey;
+}
+function EcdhPublicKey(publicKey) {
+  EcPublicKey.call(this, publicKey);
+}
+function EcdhPrivateKey(privateKey) {
+  EcPrivateKey_0.call(this, privateKey);
+}
+function WebCryptoEcdh$EcdhPublicKey$_init_$ref_x8kjxe() {
+  var l = function (p0) {
+    return new EcdhPublicKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdh$EcdhPrivateKey$_init_$ref_1xgfie() {
+  var l = function (p0) {
+    return new EcdhPrivateKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdh$EcdhKeyPair$_init_$ref_fqllqz() {
+  var l = function (p0, p1) {
+    return new EcdhKeyPair(p0, p1);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdh() {
+  WebCryptoEcdh_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = [];
+  var tmp_0 = new WebCryptoKeyWrapper(tmp, WebCryptoEcdh$EcdhPublicKey$_init_$ref_x8kjxe());
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_1 = ['deriveBits'];
+  var tmp_2 = new WebCryptoKeyWrapper(tmp_1, WebCryptoEcdh$EcdhPrivateKey$_init_$ref_1xgfie());
+  WebCryptoEc.call(this, 'ECDH', tmp_0, tmp_2, WebCryptoEcdh$EcdhKeyPair$_init_$ref_fqllqz());
+}
+var WebCryptoEcdh_instance;
+function WebCryptoEcdh_getInstance() {
+  if (WebCryptoEcdh_instance == null)
+    new WebCryptoEcdh();
+  return WebCryptoEcdh_instance;
+}
+function EcdsaKeyPair(publicKey, privateKey) {
+  this.moc_1 = publicKey;
+  this.noc_1 = privateKey;
+}
+function EcdsaPublicKey(publicKey) {
+  EcPublicKey.call(this, publicKey);
+}
+function EcdsaPrivateKey(privateKey) {
+  EcPrivateKey_0.call(this, privateKey);
+}
+function WebCryptoEcdsa$EcdsaPublicKey$_init_$ref_5egfgi() {
+  var l = function (p0) {
+    return new EcdsaPublicKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdsa$EcdsaPrivateKey$_init_$ref_8mqrbu() {
+  var l = function (p0) {
+    return new EcdsaPrivateKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdsa$EcdsaKeyPair$_init_$ref_l5vyez() {
+  var l = function (p0, p1) {
+    return new EcdsaKeyPair(p0, p1);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoEcdsa() {
+  WebCryptoEcdsa_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['verify'];
+  var tmp_0 = new WebCryptoKeyWrapper(tmp, WebCryptoEcdsa$EcdsaPublicKey$_init_$ref_5egfgi());
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_1 = ['sign'];
+  var tmp_2 = new WebCryptoKeyWrapper(tmp_1, WebCryptoEcdsa$EcdsaPrivateKey$_init_$ref_8mqrbu());
+  WebCryptoEc.call(this, 'ECDSA', tmp_0, tmp_2, WebCryptoEcdsa$EcdsaKeyPair$_init_$ref_l5vyez());
+}
+var WebCryptoEcdsa_instance;
+function WebCryptoEcdsa_getInstance() {
+  if (WebCryptoEcdsa_instance == null)
+    new WebCryptoEcdsa();
+  return WebCryptoEcdsa_instance;
+}
+function WebCryptoHkdf() {
+}
+var WebCryptoHkdf_instance;
+function WebCryptoHkdf_getInstance() {
+  return WebCryptoHkdf_instance;
+}
+function HmacKey(key) {
+  WebCryptoEncodableKey.call(this, key, HmacKeyProcessor_getInstance());
+  this.qoc_1 = key;
+}
+protoOf(HmacKey).roc = function () {
+  return new WebCryptoSignatureGenerator(Algorithm('HMAC'), this.qoc_1);
+};
+function WebCryptoHmac$HmacKey$_init_$ref_enwl2t() {
+  var l = function (p0) {
+    return new HmacKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoHmac() {
+  WebCryptoHmac_instance = this;
+  var tmp = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_0 = ['sign', 'verify'];
+  tmp.soc_1 = new WebCryptoKeyWrapper(tmp_0, WebCryptoHmac$HmacKey$_init_$ref_enwl2t());
+}
+protoOf(WebCryptoHmac).toc = function (digest) {
+  return new WebCryptoKeyDecoder(HmacKeyAlgorithm(hashAlgorithmName(digest), null), HmacKeyProcessor_getInstance(), this.soc_1);
+};
+var WebCryptoHmac_instance;
+function WebCryptoHmac_getInstance() {
+  if (WebCryptoHmac_instance == null)
+    new WebCryptoHmac();
+  return WebCryptoHmac_instance;
+}
+function HmacKeyProcessor() {
+  HmacKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(HmacKeyProcessor).uoc = function (format) {
+  var tmp;
+  switch (format.a1_1) {
+    case 0:
+      tmp = 'raw';
+      break;
+    case 1:
+      tmp = 'jwk';
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+};
+protoOf(HmacKeyProcessor).lob = function (format) {
+  return this.uoc(format instanceof Format_2 ? format : THROW_CCE());
+};
+protoOf(HmacKeyProcessor).voc = function (algorithm, format, key) {
+  return key;
+};
+protoOf(HmacKeyProcessor).nob = function (algorithm, format, key) {
+  return this.voc(algorithm, format instanceof Format_2 ? format : THROW_CCE(), key);
+};
+var HmacKeyProcessor_instance;
+function HmacKeyProcessor_getInstance() {
+  if (HmacKeyProcessor_instance == null)
+    new HmacKeyProcessor();
+  return HmacKeyProcessor_instance;
+}
+function WebCryptoPbkdf2() {
+}
+var WebCryptoPbkdf2_instance;
+function WebCryptoPbkdf2_getInstance() {
+  return WebCryptoPbkdf2_instance;
+}
+function RsaPublicKey(publicKey) {
+  WebCryptoEncodableKey.call(this, publicKey, RsaPublicKeyProcessor_getInstance());
+  this.yoc_1 = publicKey;
+}
+function RsaPrivateKey(privateKey) {
+  WebCryptoEncodableKey.call(this, privateKey, RsaPrivateKeyProcessor_getInstance());
+  this.bod_1 = privateKey;
+}
+function WebCryptoRsa$keyPairWrapper$lambda($keyPairWrapper, this$0) {
+  return function (it) {
+    return $keyPairWrapper(this$0.dod_1.aoc_1(it.publicKey), this$0.eod_1.aoc_1(it.privateKey));
+  };
+}
+function WebCryptoRsa(algorithmName, publicKeyWrapper, privateKeyWrapper, keyPairWrapper) {
+  this.cod_1 = algorithmName;
+  this.dod_1 = publicKeyWrapper;
+  this.eod_1 = privateKeyWrapper;
+  var tmp = this;
+  var tmp0 = this.dod_1.zob_1;
+  // Inline function 'kotlin.collections.plus' call
+  var elements = this.eod_1.zob_1;
+  // Inline function 'kotlin.js.asDynamic' call
+  tmp.fod_1 = tmp0.concat(elements);
+  var tmp_0 = this;
+  tmp_0.god_1 = WebCryptoRsa$keyPairWrapper$lambda(keyPairWrapper, this);
+}
+function RsaPublicKeyProcessor() {
+  RsaPublicKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(RsaPublicKeyProcessor).hod = function (format) {
+  var tmp;
+  if (equals(format, JWK_getInstance_1())) {
+    tmp = 'jwk';
+  } else if (equals(format, Generic_getInstance_1()) || equals(format, Generic_getInstance_2()) || (equals(format, PKCS1_getInstance()) || equals(format, PKCS1_getInstance_0()))) {
+    tmp = 'spki';
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(RsaPublicKeyProcessor).lob = function (format) {
+  return this.hod(format instanceof Format_3 ? format : THROW_CCE());
+};
+protoOf(RsaPublicKeyProcessor).iod = function (algorithm, format, key) {
+  var tmp;
+  if (equals(format, JWK_getInstance_1())) {
+    tmp = key;
+  } else if (equals(format, Generic_getInstance_1())) {
+    tmp = key;
+  } else if (equals(format, Generic_getInstance_2())) {
+    tmp = unwrapPem(Companion_getInstance_10().woa_1, key);
+  } else if (equals(format, PKCS1_getInstance())) {
+    tmp = wrapSubjectPublicKeyInfo(RsaKeyAlgorithmIdentifier_instance, key);
+  } else if (equals(format, PKCS1_getInstance_0())) {
+    tmp = wrapSubjectPublicKeyInfo(RsaKeyAlgorithmIdentifier_instance, unwrapPem(Companion_getInstance_10().yoa_1, key));
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(RsaPublicKeyProcessor).nob = function (algorithm, format, key) {
+  return this.iod(algorithm, format instanceof Format_3 ? format : THROW_CCE(), key);
+};
+var RsaPublicKeyProcessor_instance;
+function RsaPublicKeyProcessor_getInstance() {
+  if (RsaPublicKeyProcessor_instance == null)
+    new RsaPublicKeyProcessor();
+  return RsaPublicKeyProcessor_instance;
+}
+function RsaPrivateKeyProcessor() {
+  RsaPrivateKeyProcessor_instance = this;
+  WebCryptoKeyProcessor.call(this);
+}
+protoOf(RsaPrivateKeyProcessor).jod = function (format) {
+  var tmp;
+  if (equals(format, JWK_getInstance_2())) {
+    tmp = 'jwk';
+  } else if (equals(format, Generic_getInstance_3()) || equals(format, Generic_getInstance_4()) || (equals(format, PKCS1_getInstance_1()) || equals(format, PKCS1_getInstance_2()))) {
+    tmp = 'pkcs8';
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(RsaPrivateKeyProcessor).lob = function (format) {
+  return this.jod(format instanceof Format_4 ? format : THROW_CCE());
+};
+protoOf(RsaPrivateKeyProcessor).kod = function (algorithm, format, key) {
+  var tmp;
+  if (equals(format, JWK_getInstance_2())) {
+    tmp = key;
+  } else if (equals(format, Generic_getInstance_3())) {
+    tmp = key;
+  } else if (equals(format, Generic_getInstance_4())) {
+    tmp = unwrapPem(Companion_getInstance_10().xoa_1, key);
+  } else if (equals(format, PKCS1_getInstance_1())) {
+    tmp = wrapPrivateKeyInfo(0, RsaKeyAlgorithmIdentifier_instance, key);
+  } else if (equals(format, PKCS1_getInstance_2())) {
+    tmp = wrapPrivateKeyInfo(0, RsaKeyAlgorithmIdentifier_instance, unwrapPem(Companion_getInstance_10().zoa_1, key));
+  } else {
+    noWhenBranchMatchedException();
+  }
+  return tmp;
+};
+protoOf(RsaPrivateKeyProcessor).nob = function (algorithm, format, key) {
+  return this.kod(algorithm, format instanceof Format_4 ? format : THROW_CCE(), key);
+};
+var RsaPrivateKeyProcessor_instance;
+function RsaPrivateKeyProcessor_getInstance() {
+  if (RsaPrivateKeyProcessor_instance == null)
+    new RsaPrivateKeyProcessor();
+  return RsaPrivateKeyProcessor_instance;
+}
+function RsaOaepKeyPair(publicKey, privateKey) {
+  this.lod_1 = publicKey;
+  this.mod_1 = privateKey;
+}
+function RsaOaepPublicKey(publicKey) {
+  RsaPublicKey.call(this, publicKey);
+}
+function RsaOaepPrivateKey(privateKey) {
+  RsaPrivateKey.call(this, privateKey);
+}
+function WebCryptoRsaOaep$RsaOaepPublicKey$_init_$ref_2xzkj4() {
+  var l = function (p0) {
+    return new RsaOaepPublicKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaOaep$RsaOaepPrivateKey$_init_$ref_ds5c3s() {
+  var l = function (p0) {
+    return new RsaOaepPrivateKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaOaep$RsaOaepKeyPair$_init_$ref_whtofn() {
+  var l = function (p0, p1) {
+    return new RsaOaepKeyPair(p0, p1);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaOaep() {
+  WebCryptoRsaOaep_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['encrypt'];
+  var tmp_0 = new WebCryptoKeyWrapper(tmp, WebCryptoRsaOaep$RsaOaepPublicKey$_init_$ref_2xzkj4());
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_1 = ['decrypt'];
+  var tmp_2 = new WebCryptoKeyWrapper(tmp_1, WebCryptoRsaOaep$RsaOaepPrivateKey$_init_$ref_ds5c3s());
+  WebCryptoRsa.call(this, 'RSA-OAEP', tmp_0, tmp_2, WebCryptoRsaOaep$RsaOaepKeyPair$_init_$ref_whtofn());
+}
+var WebCryptoRsaOaep_instance;
+function WebCryptoRsaOaep_getInstance() {
+  if (WebCryptoRsaOaep_instance == null)
+    new WebCryptoRsaOaep();
+  return WebCryptoRsaOaep_instance;
+}
+function RsaPkcs1KeyPair(publicKey, privateKey) {
+  this.nod_1 = publicKey;
+  this.ood_1 = privateKey;
+}
+function RsaPkcs1PublicKey(publicKey) {
+  RsaPublicKey.call(this, publicKey);
+}
+function RsaPkcs1PrivateKey(privateKey) {
+  RsaPrivateKey.call(this, privateKey);
+}
+function WebCryptoRsaPkcs1$RsaPkcs1PublicKey$_init_$ref_kiwvhe() {
+  var l = function (p0) {
+    return new RsaPkcs1PublicKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPkcs1$RsaPkcs1PrivateKey$_init_$ref_y0qpl2() {
+  var l = function (p0) {
+    return new RsaPkcs1PrivateKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPkcs1$RsaPkcs1KeyPair$_init_$ref_s062w5() {
+  var l = function (p0, p1) {
+    return new RsaPkcs1KeyPair(p0, p1);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPkcs1() {
+  WebCryptoRsaPkcs1_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['verify'];
+  var tmp_0 = new WebCryptoKeyWrapper(tmp, WebCryptoRsaPkcs1$RsaPkcs1PublicKey$_init_$ref_kiwvhe());
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_1 = ['sign'];
+  var tmp_2 = new WebCryptoKeyWrapper(tmp_1, WebCryptoRsaPkcs1$RsaPkcs1PrivateKey$_init_$ref_y0qpl2());
+  WebCryptoRsa.call(this, 'RSASSA-PKCS1-v1_5', tmp_0, tmp_2, WebCryptoRsaPkcs1$RsaPkcs1KeyPair$_init_$ref_s062w5());
+}
+var WebCryptoRsaPkcs1_instance;
+function WebCryptoRsaPkcs1_getInstance() {
+  if (WebCryptoRsaPkcs1_instance == null)
+    new WebCryptoRsaPkcs1();
+  return WebCryptoRsaPkcs1_instance;
+}
+function RsaPssKeyPair(publicKey, privateKey) {
+  this.pod_1 = publicKey;
+  this.qod_1 = privateKey;
+}
+function RsaPssPublicKey(publicKey) {
+  RsaPublicKey.call(this, publicKey);
+}
+function RsaPssPrivateKey(privateKey) {
+  RsaPrivateKey.call(this, privateKey);
+}
+function WebCryptoRsaPss$RsaPssPublicKey$_init_$ref_o813fm() {
+  var l = function (p0) {
+    return new RsaPssPublicKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPss$RsaPssPrivateKey$_init_$ref_6l5g3q() {
+  var l = function (p0) {
+    return new RsaPssPrivateKey(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPss$RsaPssKeyPair$_init_$ref_3h8asb() {
+  var l = function (p0, p1) {
+    return new RsaPssKeyPair(p0, p1);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function WebCryptoRsaPss() {
+  WebCryptoRsaPss_instance = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp = ['verify'];
+  var tmp_0 = new WebCryptoKeyWrapper(tmp, WebCryptoRsaPss$RsaPssPublicKey$_init_$ref_o813fm());
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_1 = ['sign'];
+  var tmp_2 = new WebCryptoKeyWrapper(tmp_1, WebCryptoRsaPss$RsaPssPrivateKey$_init_$ref_6l5g3q());
+  WebCryptoRsa.call(this, 'RSA-PSS', tmp_0, tmp_2, WebCryptoRsaPss$RsaPssKeyPair$_init_$ref_3h8asb());
+}
+var WebCryptoRsaPss_instance;
+function WebCryptoRsaPss_getInstance() {
+  if (WebCryptoRsaPss_instance == null)
+    new WebCryptoRsaPss();
+  return WebCryptoRsaPss_instance;
+}
+function hashAlgorithmName(_this__u8e3s4) {
+  var tmp;
+  if (equals(_this__u8e3s4, SHA1_getInstance())) {
+    tmp = 'SHA-1';
+  } else if (equals(_this__u8e3s4, SHA256_getInstance())) {
+    tmp = 'SHA-256';
+  } else if (equals(_this__u8e3s4, SHA384_getInstance())) {
+    tmp = 'SHA-384';
+  } else if (equals(_this__u8e3s4, SHA512_getInstance())) {
+    tmp = 'SHA-512';
+  } else {
+    throw IllegalStateException_init_$Create$('Unsupported hash algorithm: ' + _this__u8e3s4.go6_1);
+  }
+  return tmp;
+}
+function nonBlocking() {
+  throw IllegalStateException_init_$Create$('Only non-blocking(suspend) calls are supported in WebCrypto');
+}
+function WebCryptoEncodableKey(key, keyProcessor) {
+  this.rod_1 = key;
+  this.sod_1 = keyProcessor;
+}
+function $decodeFromByteArrayCOROUTINE$(_this__u8e3s4, format, bytes, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.boe_1 = _this__u8e3s4;
+  this.coe_1 = format;
+  this.doe_1 = bytes;
+}
+protoOf($decodeFromByteArrayCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.eoe_1 = this.boe_1.hoe_1.aoc_1;
+          this.i9_1 = 1;
+          suspendResult = WebCrypto_getInstance().ioe(this.boe_1.goe_1.lob(this.coe_1), this.boe_1.goe_1.nob(this.boe_1.foe_1, this.coe_1, this.doe_1), this.boe_1.foe_1, true, this.boe_1.hoe_1.zob_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          return this.eoe_1(ARGUMENT);
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function WebCryptoKeyDecoder(algorithm, keyProcessor, keyWrapper) {
+  this.foe_1 = algorithm;
+  this.goe_1 = keyProcessor;
+  this.hoe_1 = keyWrapper;
+}
+protoOf(WebCryptoKeyDecoder).yo6 = function (format, bytes, $completion) {
+  var tmp = new $decodeFromByteArrayCOROUTINE$(this, format, bytes, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(WebCryptoKeyDecoder).zo6 = function (format, bytes) {
+  nonBlocking();
+};
+function WebCryptoKeyProcessor() {
+}
+function WebCryptoKeyWrapper(usages, wrap) {
+  this.zob_1 = usages;
+  this.aoc_1 = wrap;
+}
+function WebCryptoSignatureGenerator(algorithm, key) {
+  this.joe_1 = algorithm;
+  this.koe_1 = key;
+}
+protoOf(WebCryptoSignatureGenerator).go7 = function (data, $completion) {
+  return WebCrypto_getInstance().loe(this.joe_1, this.koe_1, data, $completion);
+};
+protoOf(WebCryptoSignatureGenerator).fo7 = function () {
+  nonBlocking();
+};
+protoOf(WebCryptoSignatureGenerator).ho7 = function (data) {
+  nonBlocking();
+};
+function get_initHook() {
+  return initHook_0;
+}
+var initHook_0;
+function initHook$init$() {
+  CryptographySystem_getInstance().so6(get_defaultProvider(), 100);
+  return Unit_instance;
+}
+function get_ecKeyAlgorithmNamedCurve(_this__u8e3s4) {
+  return ecKeyAlgorithmNamedCurve(_this__u8e3s4);
+}
+function Algorithm(name) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  return {name: name};
+}
+function HmacKeyAlgorithm(hash, length) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  return length == null ? {name: 'HMAC', hash: hash} : {name: 'HMAC', hash: hash, length: length};
+}
+function ecKeyAlgorithmNamedCurve(algorithm) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  return algorithm.namedCurve;
+}
+function getSubtleCrypto() {
+  var tmp0_safe_receiver = getCrypto();
+  var tmp0 = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.subtle;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.requireNotNull' call
+    if (tmp0 == null) {
+      var message = 'WebCrypto API is not available. Check Secure Contexts definition (https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts) or report an issue';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    } else {
+      tmp$ret$1 = tmp0;
+      break $l$block;
+    }
+  }
+  return tmp$ret$1;
+}
+function getCrypto() {
+  return globalThis ? globalThis.crypto : window.crypto || window.msCrypto;
+}
+function $digestCOROUTINE$(_this__u8e3s4, algorithmName, data, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.uoe_1 = _this__u8e3s4;
+  this.voe_1 = algorithmName;
+  this.woe_1 = data;
+}
+protoOf($digestCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.i9_1 = 1;
+          suspendResult = await_0(this.uoe_1.rob_1.digest(this.voe_1, this.woe_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          return toByteArray(ARGUMENT);
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function $signCOROUTINE$(_this__u8e3s4, algorithm, key, data, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.fof_1 = _this__u8e3s4;
+  this.gof_1 = algorithm;
+  this.hof_1 = key;
+  this.iof_1 = data;
+}
+protoOf($signCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.i9_1 = 1;
+          suspendResult = await_0(this.fof_1.rob_1.sign(this.gof_1, this.hof_1, this.iof_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          return toByteArray(ARGUMENT);
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function WebCrypto() {
+  WebCrypto_instance = this;
+  this.rob_1 = getSubtleCrypto();
+}
+protoOf(WebCrypto).sob = function (algorithmName, data, $completion) {
+  var tmp = new $digestCOROUTINE$(this, algorithmName, data, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(WebCrypto).loe = function (algorithm, key, data, $completion) {
+  var tmp = new $signCOROUTINE$(this, algorithm, key, data, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(WebCrypto).ioe = function (format, keyData, algorithm, extractable, keyUsages, $completion) {
+  var key = format === 'jwk' ? JSON.parse(decodeToString(keyData)) : keyData;
+  return await_0(this.rob_1.importKey(format, key, algorithm, extractable, keyUsages), $completion);
+};
+var WebCrypto_instance;
+function WebCrypto_getInstance() {
+  if (WebCrypto_instance == null)
+    new WebCrypto();
+  return WebCrypto_instance;
+}
+function toByteArray(_this__u8e3s4) {
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return new Int8Array(_this__u8e3s4);
+}
+function await_0(_this__u8e3s4, $completion) {
+  var safe = SafeContinuation_init_$Create$(intercepted($completion));
+  var tmp = await$lambda(safe);
+  _this__u8e3s4.then(tmp, await$lambda_0(safe));
+  return safe.aa();
+}
+function await$lambda($continuation) {
+  return function (it) {
+    // Inline function 'kotlin.coroutines.resume' call
+    var this_0 = $continuation;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(it);
+    this_0.t9(tmp$ret$0);
+    return null;
+  };
+}
+function await$lambda_0($continuation) {
+  return function (it) {
+    // Inline function 'kotlin.coroutines.resumeWithException' call
+    var this_0 = $continuation;
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(it));
+    this_0.t9(tmp$ret$0);
+    return null;
+  };
+}
+//region block: init
+WebCryptoHkdf_instance = new WebCryptoHkdf();
+WebCryptoPbkdf2_instance = new WebCryptoPbkdf2();
+//endregion
+//region block: eager init
+initHook_0 = initHook$init$();
+//endregion
+//region block: exports
+var initHook = {get: get_initHook};
+export {
+  initHook as initHook,
+};
+//endregion
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-provider-webcrypto.mjs.map