@solibo/solibo-sdk 1.0.35 → 1.0.37

package/cryptography-kotlin-cryptography-core.mjs

@@ -0,0 +1,1095 @@
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  VOID3gxj6tk5isa35 as VOID,
+  equals2au1ep9vhcato as equals,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  isInterface3d6p8outrmvmk as isInterface,
+  Comparator2b3maoeh98xtg as Comparator,
+  hashCodeq5arwsb9dgti as hashCode,
+  compareValues1n2ayl87ihzfk as compareValues,
+  sortedWith2csnbbb21k0lg as sortedWith,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3ivpeip4ouddx as ArrayList_init_$Create$,
+  first58ocm7j58k3q as first,
+  LinkedHashMap_init_$Create$3t495nfs82xn as LinkedHashMap_init_$Create$,
+  lazy2hsh8ze7j6ikd as lazy,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  KtMap140uvy3s5zad8 as KtMap,
+  Enum3alwj03lh1n41 as Enum,
+  closeFinally1sadm0w9gt3u4 as closeFinally,
+  AutoCloseable1l5p57f9lp7kv as AutoCloseable,
+} from './kotlin-kotlin-stdlib.mjs';
+import { Default_getInstancez3yttwaaaao5 as Default_getInstance } from './cryptography-kotlin-cryptography-random.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForInterface(CryptographyAlgorithm, 'CryptographyAlgorithm');
+initMetadataForClass(CryptographyAlgorithmId, 'CryptographyAlgorithmId');
+initMetadataForCompanion(Companion);
+initMetadataForClass(CryptographyProvider, 'CryptographyProvider');
+initMetadataForObject(CryptographySystem, 'CryptographySystem');
+initMetadataForClass(CompositeProvider, 'CompositeProvider', VOID, CryptographyProvider);
+initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+initMetadataForClass(CryptographySystemImpl, 'CryptographySystemImpl', CryptographySystemImpl);
+initMetadataForClass(Format, 'Format', VOID, Enum);
+initMetadataForCompanion(Companion_0, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_1, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_2, CryptographyAlgorithmId);
+initMetadataForObject(SHA1, 'SHA1', VOID, CryptographyAlgorithmId);
+initMetadataForObject(SHA256, 'SHA256', VOID, CryptographyAlgorithmId);
+initMetadataForObject(SHA384, 'SHA384', VOID, CryptographyAlgorithmId);
+initMetadataForObject(SHA512, 'SHA512', VOID, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_3);
+initMetadataForClass(Format_0, 'Format');
+initMetadataForClass(RAW, 'RAW', VOID, Format_0);
+initMetadataForObject(Uncompressed, 'Uncompressed', VOID, RAW);
+initMetadataForObject(Compressed, 'Compressed', VOID, RAW);
+initMetadataForObject(JWK, 'JWK', VOID, Format_0);
+initMetadataForObject(DER, 'DER', VOID, Format_0);
+initMetadataForObject(PEM, 'PEM', VOID, Format_0);
+initMetadataForClass(Format_1, 'Format');
+initMetadataForClass(DER_0, 'DER', VOID, Format_1);
+initMetadataForObject(Generic, 'Generic', VOID, DER_0);
+initMetadataForObject(SEC1, 'SEC1', VOID, DER_0);
+initMetadataForClass(PEM_0, 'PEM', VOID, Format_1);
+initMetadataForObject(Generic_0, 'Generic', VOID, PEM_0);
+initMetadataForObject(SEC1_0, 'SEC1', VOID, PEM_0);
+initMetadataForObject(JWK_0, 'JWK', VOID, Format_1);
+initMetadataForObject(RAW_0, 'RAW', VOID, Format_1);
+initMetadataForCompanion(Companion_4, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_5, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_6, CryptographyAlgorithmId);
+initMetadataForClass(Format_2, 'Format', VOID, Enum);
+initMetadataForCompanion(Companion_7, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_8, CryptographyAlgorithmId);
+initMetadataForClass(Format_3, 'Format');
+initMetadataForClass(DER_1, 'DER', VOID, Format_3);
+initMetadataForObject(Generic_1, 'Generic', VOID, DER_1);
+initMetadataForObject(PKCS1, 'PKCS1', VOID, DER_1);
+initMetadataForClass(PEM_1, 'PEM', VOID, Format_3);
+initMetadataForObject(Generic_2, 'Generic', VOID, PEM_1);
+initMetadataForObject(PKCS1_0, 'PKCS1', VOID, PEM_1);
+initMetadataForObject(JWK_1, 'JWK', VOID, Format_3);
+initMetadataForClass(Format_4, 'Format');
+initMetadataForClass(DER_2, 'DER', VOID, Format_4);
+initMetadataForObject(Generic_3, 'Generic', VOID, DER_2);
+initMetadataForObject(PKCS1_1, 'PKCS1', VOID, DER_2);
+initMetadataForClass(PEM_2, 'PEM', VOID, Format_4);
+initMetadataForObject(Generic_4, 'Generic', VOID, PEM_2);
+initMetadataForObject(PKCS1_2, 'PKCS1', VOID, PEM_2);
+initMetadataForObject(JWK_2, 'JWK', VOID, Format_4);
+initMetadataForCompanion(Companion_9, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_10, CryptographyAlgorithmId);
+initMetadataForCompanion(Companion_11, CryptographyAlgorithmId);
+function decodeFromByteArray(format, bytes, $completion) {
+  return this.zo6(format, bytes);
+}
+initMetadataForInterface(KeyDecoder, 'KeyDecoder', VOID, VOID, VOID, [2]);
+function hash(data, $completion) {
+  return this.co7(data);
+}
+function hashBlocking(data) {
+  var tmp0 = this.ao7();
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.use' call
+    var exception = null;
+    try {
+      tmp0.do7(data);
+      tmp$ret$1 = tmp0.eo7();
+      break $l$block;
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        exception = e;
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      closeFinally(tmp0, exception);
+    }
+  }
+  return tmp$ret$1;
+}
+initMetadataForInterface(Hasher, 'Hasher', VOID, VOID, VOID, [1]);
+function generateSignature(data, $completion) {
+  return this.ho7(data);
+}
+function generateSignatureBlocking(data) {
+  var tmp0 = this.fo7();
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.use' call
+    var exception = null;
+    try {
+      tmp0.do7(data);
+      tmp$ret$1 = tmp0.io7();
+      break $l$block;
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var e = $p;
+        exception = e;
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      closeFinally(tmp0, exception);
+    }
+  }
+  return tmp$ret$1;
+}
+initMetadataForInterface(SignatureGenerator, 'SignatureGenerator', VOID, VOID, VOID, [1]);
+function update$default(source, startIndex, endIndex, $super) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? source.length : endIndex;
+  var tmp;
+  if ($super === VOID) {
+    this.jo7(source, startIndex, endIndex);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.jo7.call(this, source, startIndex, endIndex);
+  }
+  return tmp;
+}
+initMetadataForInterface(UpdateFunction, 'UpdateFunction', VOID, VOID, [AutoCloseable]);
+//endregion
+function CryptographyAlgorithm() {
+}
+function CryptographyAlgorithmId(name) {
+  this.go6_1 = name;
+}
+function Companion() {
+}
+protoOf(Companion).ho6 = function () {
+  return CryptographySystem_getInstance().jo6();
+};
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function CryptographyProvider() {
+}
+protoOf(CryptographyProvider).lo6 = function (identifier) {
+  var tmp0_elvis_lhs = this.ko6(identifier);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalStateException_init_$Create$('Algorithm not found: ' + toString(identifier));
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+};
+function CryptographySystem() {
+  CryptographySystem_instance = this;
+  this.io6_1 = new CryptographySystemImpl();
+  loadProviders(this);
+}
+protoOf(CryptographySystem).jo6 = function () {
+  return this.io6_1.jo6();
+};
+protoOf(CryptographySystem).so6 = function (provider, priority) {
+  return this.io6_1.so6(provider, priority);
+};
+var CryptographySystem_instance;
+function CryptographySystem_getInstance() {
+  if (CryptographySystem_instance == null)
+    new CryptographySystem();
+  return CryptographySystem_instance;
+}
+function CompositeProvider(providers) {
+  CryptographyProvider.call(this);
+  this.to6_1 = providers;
+}
+protoOf(CompositeProvider).ko6 = function (identifier) {
+  var tmp0 = this.to6_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.collections.firstNotNullOfOrNull' call
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var result = element.ko6(identifier);
+      if (!(result == null)) {
+        tmp$ret$1 = result;
+        break $l$block;
+      }
+    }
+    tmp$ret$1 = null;
+  }
+  return tmp$ret$1;
+};
+function sam$kotlin_Comparator$0(function_0) {
+  this.uo6_1 = function_0;
+}
+protoOf(sam$kotlin_Comparator$0).le = function (a, b) {
+  return this.uo6_1(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+  return this.le(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).q3 = function () {
+  return this.uo6_1;
+};
+protoOf(sam$kotlin_Comparator$0).equals = function (other) {
+  var tmp;
+  if (!(other == null) ? isInterface(other, Comparator) : false) {
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+      tmp_0 = equals(this.q3(), other.q3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+  return hashCode(this.q3());
+};
+function CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = a.m1();
+  var tmp$ret$1 = b.m1();
+  return compareValues(tmp, tmp$ret$1);
+}
+function CryptographySystemImpl$lazyRegisteredProviders$lambda(this$0) {
+  return function () {
+    // Inline function 'kotlin.collections.sortedBy' call
+    var this_0 = this$0.mo6_1.l1();
+    // Inline function 'kotlin.comparisons.compareBy' call
+    var tmp = CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda;
+    var tmp$ret$0 = new sam$kotlin_Comparator$0(tmp);
+    // Inline function 'kotlin.collections.map' call
+    var this_1 = sortedWith(this_0, tmp$ret$0);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+    var _iterator__ex2g4s = this_1.t();
+    while (_iterator__ex2g4s.u()) {
+      var item = _iterator__ex2g4s.v();
+      var tmp$ret$2 = item.n1().n1();
+      destination.e1(tmp$ret$2);
+    }
+    return destination;
+  };
+}
+function CryptographySystemImpl$lazyDefaultProvider$lambda(this$0) {
+  return function () {
+    var tmp0_elvis_lhs = this$0.oo6_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.let' call
+      var it = this$0.no6_1.n1();
+      var tmp_0;
+      switch (it.g1()) {
+        case 0:
+          var message = 'No providers registered. Please provide a dependency or register provider explicitly';
+          throw IllegalStateException_init_$Create$(toString(message));
+        case 1:
+          tmp_0 = first(it);
+          break;
+        default:
+          tmp_0 = new CompositeProvider(it);
+          break;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+}
+function CryptographySystemImpl$lazyDefaultRandom$lambda(this$0) {
+  return function () {
+    var tmp0_elvis_lhs = this$0.qo6_1;
+    return tmp0_elvis_lhs == null ? Default_getInstance() : tmp0_elvis_lhs;
+  };
+}
+function CryptographySystemImpl() {
+  var tmp = this;
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  tmp.mo6_1 = LinkedHashMap_init_$Create$();
+  var tmp_0 = this;
+  tmp_0.no6_1 = lazy(CryptographySystemImpl$lazyRegisteredProviders$lambda(this));
+  this.oo6_1 = null;
+  var tmp_1 = this;
+  tmp_1.po6_1 = lazy(CryptographySystemImpl$lazyDefaultProvider$lambda(this));
+  this.qo6_1 = null;
+  var tmp_2 = this;
+  tmp_2.ro6_1 = lazy(CryptographySystemImpl$lazyDefaultRandom$lambda(this));
+}
+protoOf(CryptographySystemImpl).jo6 = function () {
+  return this.po6_1.n1();
+};
+protoOf(CryptographySystemImpl).so6 = function (provider, priority) {
+  // Inline function 'kotlin.require' call
+  if (!(priority >= 0)) {
+    var message = 'Priority must be greater or equal to 0';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.collections.contains' call
+  // Inline function 'kotlin.collections.containsKey' call
+  var this_0 = this.mo6_1;
+  // Inline function 'kotlin.require' call
+  if (!!(isInterface(this_0, KtMap) ? this_0 : THROW_CCE()).x2(priority)) {
+    var message_0 = 'Provider with priority ' + priority + ' already registered. Every registered provider should have unique priority.';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.check' call
+  if (!!this.no6_1.dq()) {
+    var message_1 = 'Cannot register provider after `getRegisteredProviders` was called';
+    throw IllegalStateException_init_$Create$(toString(message_1));
+  }
+  // Inline function 'kotlin.collections.set' call
+  this.mo6_1.c3(priority, provider);
+};
+function Format() {
+}
+function Companion_0() {
+  Companion_instance_0 = this;
+  CryptographyAlgorithmId.call(this, 'AES-CBC');
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  if (Companion_instance_0 == null)
+    new Companion_0();
+  return Companion_instance_0;
+}
+function Companion_1() {
+  Companion_instance_1 = this;
+  CryptographyAlgorithmId.call(this, 'AES-CTR');
+}
+var Companion_instance_1;
+function Companion_getInstance_1() {
+  if (Companion_instance_1 == null)
+    new Companion_1();
+  return Companion_instance_1;
+}
+function Companion_2() {
+  Companion_instance_2 = this;
+  CryptographyAlgorithmId.call(this, 'AES-GCM');
+}
+var Companion_instance_2;
+function Companion_getInstance_2() {
+  if (Companion_instance_2 == null)
+    new Companion_2();
+  return Companion_instance_2;
+}
+function SHA1() {
+  SHA1_instance = this;
+  CryptographyAlgorithmId.call(this, 'SHA-1');
+}
+var SHA1_instance;
+function SHA1_getInstance() {
+  if (SHA1_instance == null)
+    new SHA1();
+  return SHA1_instance;
+}
+function SHA256() {
+  SHA256_instance = this;
+  CryptographyAlgorithmId.call(this, 'SHA-256');
+}
+var SHA256_instance;
+function SHA256_getInstance() {
+  if (SHA256_instance == null)
+    new SHA256();
+  return SHA256_instance;
+}
+function SHA384() {
+  SHA384_instance = this;
+  CryptographyAlgorithmId.call(this, 'SHA-384');
+}
+var SHA384_instance;
+function SHA384_getInstance() {
+  if (SHA384_instance == null)
+    new SHA384();
+  return SHA384_instance;
+}
+function SHA512() {
+  SHA512_instance = this;
+  CryptographyAlgorithmId.call(this, 'SHA-512');
+}
+var SHA512_instance;
+function SHA512_getInstance() {
+  if (SHA512_instance == null)
+    new SHA512();
+  return SHA512_instance;
+}
+function _Curve___init__impl__ygix12(name) {
+  return name;
+}
+function _Curve___get_name__impl__klrusc($this) {
+  return $this;
+}
+function Companion_3() {
+}
+protoOf(Companion_3).vo6 = function () {
+  return _Curve___init__impl__ygix12('P-256');
+};
+protoOf(Companion_3).wo6 = function () {
+  return _Curve___init__impl__ygix12('P-384');
+};
+protoOf(Companion_3).xo6 = function () {
+  return _Curve___init__impl__ygix12('P-521');
+};
+var Companion_instance_3;
+function Companion_getInstance_3() {
+  return Companion_instance_3;
+}
+function Uncompressed() {
+  Uncompressed_instance = this;
+  RAW.call(this);
+}
+protoOf(Uncompressed).m = function () {
+  return 'RAW';
+};
+var Uncompressed_instance;
+function Uncompressed_getInstance() {
+  if (Uncompressed_instance == null)
+    new Uncompressed();
+  return Uncompressed_instance;
+}
+function Compressed() {
+  Compressed_instance = this;
+  RAW.call(this);
+}
+protoOf(Compressed).m = function () {
+  return 'RAW/COMPRESSED';
+};
+protoOf(Compressed).hashCode = function () {
+  return -876424098;
+};
+protoOf(Compressed).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof Compressed))
+    return false;
+  other instanceof Compressed || THROW_CCE();
+  return true;
+};
+var Compressed_instance;
+function Compressed_getInstance() {
+  if (Compressed_instance == null)
+    new Compressed();
+  return Compressed_instance;
+}
+function JWK() {
+  JWK_instance = this;
+  Format_0.call(this);
+}
+protoOf(JWK).m = function () {
+  return 'JWK';
+};
+protoOf(JWK).hashCode = function () {
+  return -164862489;
+};
+protoOf(JWK).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof JWK))
+    return false;
+  other instanceof JWK || THROW_CCE();
+  return true;
+};
+var JWK_instance;
+function JWK_getInstance() {
+  if (JWK_instance == null)
+    new JWK();
+  return JWK_instance;
+}
+function RAW() {
+  Uncompressed_getInstance();
+  Format_0.call(this);
+}
+function DER() {
+  DER_instance = this;
+  Format_0.call(this);
+}
+protoOf(DER).m = function () {
+  return 'DER';
+};
+protoOf(DER).hashCode = function () {
+  return -164868806;
+};
+protoOf(DER).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof DER))
+    return false;
+  other instanceof DER || THROW_CCE();
+  return true;
+};
+var DER_instance;
+function DER_getInstance() {
+  if (DER_instance == null)
+    new DER();
+  return DER_instance;
+}
+function PEM() {
+  PEM_instance = this;
+  Format_0.call(this);
+}
+protoOf(PEM).m = function () {
+  return 'PEM';
+};
+protoOf(PEM).hashCode = function () {
+  return -164857279;
+};
+protoOf(PEM).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof PEM))
+    return false;
+  other instanceof PEM || THROW_CCE();
+  return true;
+};
+var PEM_instance;
+function PEM_getInstance() {
+  if (PEM_instance == null)
+    new PEM();
+  return PEM_instance;
+}
+function Format_0() {
+}
+protoOf(Format_0).toString = function () {
+  return this.m();
+};
+function Generic() {
+  Generic_instance = this;
+  DER_0.call(this);
+}
+protoOf(Generic).m = function () {
+  return 'DER';
+};
+var Generic_instance;
+function Generic_getInstance() {
+  if (Generic_instance == null)
+    new Generic();
+  return Generic_instance;
+}
+function SEC1() {
+  SEC1_instance = this;
+  DER_0.call(this);
+}
+protoOf(SEC1).m = function () {
+  return 'DER/SEC1';
+};
+protoOf(SEC1).hashCode = function () {
+  return -137777718;
+};
+protoOf(SEC1).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof SEC1))
+    return false;
+  other instanceof SEC1 || THROW_CCE();
+  return true;
+};
+var SEC1_instance;
+function SEC1_getInstance() {
+  if (SEC1_instance == null)
+    new SEC1();
+  return SEC1_instance;
+}
+function Generic_0() {
+  Generic_instance_0 = this;
+  PEM_0.call(this);
+}
+protoOf(Generic_0).m = function () {
+  return 'PEM';
+};
+var Generic_instance_0;
+function Generic_getInstance_0() {
+  if (Generic_instance_0 == null)
+    new Generic_0();
+  return Generic_instance_0;
+}
+function SEC1_0() {
+  SEC1_instance_0 = this;
+  PEM_0.call(this);
+}
+protoOf(SEC1_0).m = function () {
+  return 'PEM/SEC1';
+};
+protoOf(SEC1_0).hashCode = function () {
+  return -842035933;
+};
+protoOf(SEC1_0).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof SEC1_0))
+    return false;
+  other instanceof SEC1_0 || THROW_CCE();
+  return true;
+};
+var SEC1_instance_0;
+function SEC1_getInstance_0() {
+  if (SEC1_instance_0 == null)
+    new SEC1_0();
+  return SEC1_instance_0;
+}
+function JWK_0() {
+  JWK_instance_0 = this;
+  Format_1.call(this);
+}
+protoOf(JWK_0).m = function () {
+  return 'JWK';
+};
+protoOf(JWK_0).hashCode = function () {
+  return 1029262513;
+};
+protoOf(JWK_0).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof JWK_0))
+    return false;
+  other instanceof JWK_0 || THROW_CCE();
+  return true;
+};
+var JWK_instance_0;
+function JWK_getInstance_0() {
+  if (JWK_instance_0 == null)
+    new JWK_0();
+  return JWK_instance_0;
+}
+function RAW_0() {
+  RAW_instance = this;
+  Format_1.call(this);
+}
+protoOf(RAW_0).m = function () {
+  return 'RAW';
+};
+protoOf(RAW_0).hashCode = function () {
+  return 1029269531;
+};
+protoOf(RAW_0).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof RAW_0))
+    return false;
+  other instanceof RAW_0 || THROW_CCE();
+  return true;
+};
+var RAW_instance;
+function RAW_getInstance() {
+  if (RAW_instance == null)
+    new RAW_0();
+  return RAW_instance;
+}
+function DER_0() {
+  Generic_getInstance();
+  Format_1.call(this);
+}
+function PEM_0() {
+  Generic_getInstance_0();
+  Format_1.call(this);
+}
+function Format_1() {
+}
+protoOf(Format_1).toString = function () {
+  return this.m();
+};
+function Companion_4() {
+  Companion_instance_4 = this;
+  CryptographyAlgorithmId.call(this, 'ECDH');
+}
+var Companion_instance_4;
+function Companion_getInstance_4() {
+  if (Companion_instance_4 == null)
+    new Companion_4();
+  return Companion_instance_4;
+}
+function Companion_5() {
+  Companion_instance_5 = this;
+  CryptographyAlgorithmId.call(this, 'ECDSA');
+}
+var Companion_instance_5;
+function Companion_getInstance_5() {
+  if (Companion_instance_5 == null)
+    new Companion_5();
+  return Companion_instance_5;
+}
+function Companion_6() {
+  Companion_instance_6 = this;
+  CryptographyAlgorithmId.call(this, 'HKDF');
+}
+var Companion_instance_6;
+function Companion_getInstance_6() {
+  if (Companion_instance_6 == null)
+    new Companion_6();
+  return Companion_instance_6;
+}
+var Format_RAW_instance;
+var Format_JWK_instance;
+var Format_entriesInitialized;
+function Format_initEntries() {
+  if (Format_entriesInitialized)
+    return Unit_instance;
+  Format_entriesInitialized = true;
+  Format_RAW_instance = new Format_2('RAW', 0);
+  Format_JWK_instance = new Format_2('JWK', 1);
+}
+function Format_2(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function Format_RAW_getInstance() {
+  Format_initEntries();
+  return Format_RAW_instance;
+}
+function Companion_7() {
+  Companion_instance_7 = this;
+  CryptographyAlgorithmId.call(this, 'HMAC');
+}
+var Companion_instance_7;
+function Companion_getInstance_7() {
+  if (Companion_instance_7 == null)
+    new Companion_7();
+  return Companion_instance_7;
+}
+function Companion_8() {
+  Companion_instance_8 = this;
+  CryptographyAlgorithmId.call(this, 'PBKDF2');
+}
+var Companion_instance_8;
+function Companion_getInstance_8() {
+  if (Companion_instance_8 == null)
+    new Companion_8();
+  return Companion_instance_8;
+}
+function Generic_1() {
+  Generic_instance_1 = this;
+  DER_1.call(this);
+}
+protoOf(Generic_1).m = function () {
+  return 'DER';
+};
+var Generic_instance_1;
+function Generic_getInstance_1() {
+  if (Generic_instance_1 == null)
+    new Generic_1();
+  return Generic_instance_1;
+}
+function PKCS1() {
+  PKCS1_instance = this;
+  DER_1.call(this);
+}
+protoOf(PKCS1).m = function () {
+  return 'DER/PKCS#1';
+};
+protoOf(PKCS1).hashCode = function () {
+  return 1950278528;
+};
+protoOf(PKCS1).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof PKCS1))
+    return false;
+  other instanceof PKCS1 || THROW_CCE();
+  return true;
+};
+var PKCS1_instance;
+function PKCS1_getInstance() {
+  if (PKCS1_instance == null)
+    new PKCS1();
+  return PKCS1_instance;
+}
+function Generic_2() {
+  Generic_instance_2 = this;
+  PEM_1.call(this);
+}
+protoOf(Generic_2).m = function () {
+  return 'PEM';
+};
+var Generic_instance_2;
+function Generic_getInstance_2() {
+  if (Generic_instance_2 == null)
+    new Generic_2();
+  return Generic_instance_2;
+}
+function PKCS1_0() {
+  PKCS1_instance_0 = this;
+  PEM_1.call(this);
+}
+protoOf(PKCS1_0).m = function () {
+  return 'PEM/PKCS#1';
+};
+protoOf(PKCS1_0).hashCode = function () {
+  return 1593110343;
+};
+protoOf(PKCS1_0).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof PKCS1_0))
+    return false;
+  other instanceof PKCS1_0 || THROW_CCE();
+  return true;
+};
+var PKCS1_instance_0;
+function PKCS1_getInstance_0() {
+  if (PKCS1_instance_0 == null)
+    new PKCS1_0();
+  return PKCS1_instance_0;
+}
+function JWK_1() {
+  JWK_instance_1 = this;
+  Format_3.call(this);
+}
+protoOf(JWK_1).m = function () {
+  return 'JWK';
+};
+protoOf(JWK_1).hashCode = function () {
+  return -1819476043;
+};
+protoOf(JWK_1).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof JWK_1))
+    return false;
+  other instanceof JWK_1 || THROW_CCE();
+  return true;
+};
+var JWK_instance_1;
+function JWK_getInstance_1() {
+  if (JWK_instance_1 == null)
+    new JWK_1();
+  return JWK_instance_1;
+}
+function DER_1() {
+  Generic_getInstance_1();
+  Format_3.call(this);
+}
+function PEM_1() {
+  Generic_getInstance_2();
+  Format_3.call(this);
+}
+function Format_3() {
+}
+protoOf(Format_3).toString = function () {
+  return this.m();
+};
+function Generic_3() {
+  Generic_instance_3 = this;
+  DER_2.call(this);
+}
+protoOf(Generic_3).m = function () {
+  return 'DER';
+};
+var Generic_instance_3;
+function Generic_getInstance_3() {
+  if (Generic_instance_3 == null)
+    new Generic_3();
+  return Generic_instance_3;
+}
+function PKCS1_1() {
+  PKCS1_instance_1 = this;
+  DER_2.call(this);
+}
+protoOf(PKCS1_1).m = function () {
+  return 'DER/PKCS#1';
+};
+protoOf(PKCS1_1).hashCode = function () {
+  return -1024989714;
+};
+protoOf(PKCS1_1).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof PKCS1_1))
+    return false;
+  other instanceof PKCS1_1 || THROW_CCE();
+  return true;
+};
+var PKCS1_instance_1;
+function PKCS1_getInstance_1() {
+  if (PKCS1_instance_1 == null)
+    new PKCS1_1();
+  return PKCS1_instance_1;
+}
+function Generic_4() {
+  Generic_instance_4 = this;
+  PEM_2.call(this);
+}
+protoOf(Generic_4).m = function () {
+  return 'PEM';
+};
+var Generic_instance_4;
+function Generic_getInstance_4() {
+  if (Generic_instance_4 == null)
+    new Generic_4();
+  return Generic_instance_4;
+}
+function PKCS1_2() {
+  PKCS1_instance_2 = this;
+  PEM_2.call(this);
+}
+protoOf(PKCS1_2).m = function () {
+  return 'PEM/PKCS#1';
+};
+protoOf(PKCS1_2).hashCode = function () {
+  return -1382157899;
+};
+protoOf(PKCS1_2).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof PKCS1_2))
+    return false;
+  other instanceof PKCS1_2 || THROW_CCE();
+  return true;
+};
+var PKCS1_instance_2;
+function PKCS1_getInstance_2() {
+  if (PKCS1_instance_2 == null)
+    new PKCS1_2();
+  return PKCS1_instance_2;
+}
+function JWK_2() {
+  JWK_instance_2 = this;
+  Format_4.call(this);
+}
+protoOf(JWK_2).m = function () {
+  return 'JWK';
+};
+protoOf(JWK_2).hashCode = function () {
+  return 1275849891;
+};
+protoOf(JWK_2).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof JWK_2))
+    return false;
+  other instanceof JWK_2 || THROW_CCE();
+  return true;
+};
+var JWK_instance_2;
+function JWK_getInstance_2() {
+  if (JWK_instance_2 == null)
+    new JWK_2();
+  return JWK_instance_2;
+}
+function DER_2() {
+  Generic_getInstance_3();
+  Format_4.call(this);
+}
+function PEM_2() {
+  Generic_getInstance_4();
+  Format_4.call(this);
+}
+function Format_4() {
+}
+protoOf(Format_4).toString = function () {
+  return this.m();
+};
+function Companion_9() {
+  Companion_instance_9 = this;
+  CryptographyAlgorithmId.call(this, 'RSA-OAEP');
+}
+var Companion_instance_9;
+function Companion_getInstance_9() {
+  if (Companion_instance_9 == null)
+    new Companion_9();
+  return Companion_instance_9;
+}
+function Companion_10() {
+  Companion_instance_10 = this;
+  CryptographyAlgorithmId.call(this, 'RSA-PSS');
+}
+var Companion_instance_10;
+function Companion_getInstance_10() {
+  if (Companion_instance_10 == null)
+    new Companion_10();
+  return Companion_instance_10;
+}
+function Companion_11() {
+  Companion_instance_11 = this;
+  CryptographyAlgorithmId.call(this, 'RSA-PKCS1-V1.5');
+}
+var Companion_instance_11;
+function Companion_getInstance_11() {
+  if (Companion_instance_11 == null)
+    new Companion_11();
+  return Companion_instance_11;
+}
+function KeyDecoder() {
+}
+function Hasher() {
+}
+function SignatureGenerator() {
+}
+function UpdateFunction() {
+}
+function loadProviders(_this__u8e3s4) {
+}
+//region block: init
+Companion_instance = new Companion();
+Companion_instance_3 = new Companion_3();
+//endregion
+//region block: exports
+export {
+  Format as Format3dwngdi37q0un,
+  Format_1 as Format2r6rz6bygg1d5,
+  Format_0 as Format1u440c2w9z1t5,
+  Format_2 as Format1jug7lc3rg0qd,
+  Format_4 as Format1i0i1l8xjk06m,
+  Format_3 as Format2v29dvc3oaj5k,
+  KeyDecoder as KeyDecoder1aj9ibfkm03tn,
+  Hasher as Hashera1nteuzom60c,
+  SignatureGenerator as SignatureGenerator3tx2fdhty5h2c,
+  CryptographyAlgorithm as CryptographyAlgorithmhhdrgo7p9qei,
+  CryptographyProvider as CryptographyProviderwgv0x40nzvjc,
+  Format_RAW_getInstance as Format_RAW_getInstance2jjm94e3kdzdw,
+  _Curve___get_name__impl__klrusc as _Curve___get_name__impl__klrusc2ntyd3phrcyut,
+  Companion_getInstance_0 as Companion_getInstance14mxn5i96muxk,
+  Companion_getInstance_1 as Companion_getInstance29kae6fn9dtdp,
+  Companion_getInstance_2 as Companion_getInstance1x88e8a93nrjt,
+  Companion_instance_3 as Companion_instance2xzuy5itlbd7r,
+  Generic_getInstance as Generic_getInstance2fofokuhcjf0m,
+  SEC1_getInstance as SEC1_getInstance1h1itfa9pvqru,
+  JWK_getInstance_0 as JWK_getInstance1yvqt4fvwl3gg,
+  Generic_getInstance_0 as Generic_getInstance2z3qu9f7wt665,
+  SEC1_getInstance_0 as SEC1_getInstance19ihk9fm1tmnu,
+  RAW_getInstance as RAW_getInstance1owkiklujln96,
+  DER_getInstance as DER_getInstancetcz4fdgsag6y,
+  JWK_getInstance as JWK_getInstance2g6m6ouqgdqfw,
+  PEM_getInstance as PEM_getInstance2z3eojfgxggki,
+  Compressed_getInstance as Compressed_getInstance2bou73k6m6h1m,
+  Uncompressed_getInstance as Uncompressed_getInstance30v9709kpt3rd,
+  Companion_getInstance_4 as Companion_getInstance1b33mcojr5zhq,
+  Companion_getInstance_5 as Companion_getInstance3av3p4gc6a7jn,
+  Companion_getInstance_6 as Companion_getInstancebyslzqcunhpa,
+  Companion_getInstance_7 as Companion_getInstance1ols9hsmvo0w0,
+  Companion_getInstance_8 as Companion_getInstance27u04a1q2cj1l,
+  Companion_getInstance_9 as Companion_getInstance1xf5ipdr52o1p,
+  Companion_getInstance_11 as Companion_getInstance3ark4b05maj30,
+  Companion_getInstance_10 as Companion_getInstancei93icbc9wljv,
+  Generic_getInstance_3 as Generic_getInstanceuanw2vo9armh,
+  PKCS1_getInstance_1 as PKCS1_getInstance868e3tfzube,
+  JWK_getInstance_2 as JWK_getInstance1fp08shy8nryg,
+  Generic_getInstance_4 as Generic_getInstance7jxucsv5q1mh,
+  PKCS1_getInstance_2 as PKCS1_getInstance3a4r0yeoubefu,
+  Generic_getInstance_1 as Generic_getInstanced4eii9e2nhqx,
+  PKCS1_getInstance as PKCS1_getInstance22spptdubofqd,
+  JWK_getInstance_1 as JWK_getInstance2h7f972qw3rxx,
+  Generic_getInstance_2 as Generic_getInstance1ub4kp2qez9cr,
+  PKCS1_getInstance_0 as PKCS1_getInstance5evnhy9k9oay,
+  SHA1_getInstance as SHA1_getInstance3jravpw4war2y,
+  SHA256_getInstance as SHA256_getInstanceth9eotqeth9c,
+  SHA384_getInstance as SHA384_getInstance3dym6gio4iqu3,
+  SHA512_getInstance as SHA512_getInstance2nwy6uke6ngga,
+  Companion_instance as Companion_instance3b23289n99om0,
+  CryptographySystem_getInstance as CryptographySystem_getInstance1v1h7y5ver0lp,
+};
+//endregion
+
+//# sourceMappingURL=cryptography-kotlin-cryptography-core.mjs.map