@solibo/solibo-sdk 1.0.23 → 1.0.25-SNAPSHOT

package/cryptography-kotlin-cryptography-core.js

@@ -15,54 +15,206 @@
 }(function (_, kotlin_kotlin, kotlin_dev_whyoleg_cryptography_cryptography_random) {
   'use strict';
   //region block: imports
-  var protoOf = kotlin_kotlin.$_$.t;
-  var initMetadataForCompanion = kotlin_kotlin.$_$.q;
-  var initMetadataForClass = kotlin_kotlin.$_$.p;
-  var Unit_instance = kotlin_kotlin.$_$.f;
-  var initMetadataForObject = kotlin_kotlin.$_$.r;
-  var VOID = kotlin_kotlin.$_$.a;
-  var equals = kotlin_kotlin.$_$.n;
-  var FunctionAdapter = kotlin_kotlin.$_$.l;
-  var isInterface = kotlin_kotlin.$_$.s;
-  var Comparator = kotlin_kotlin.$_$.w;
-  var hashCode = kotlin_kotlin.$_$.o;
-  var compareValues = kotlin_kotlin.$_$.k;
-  var sortedWith = kotlin_kotlin.$_$.j;
-  var collectionSizeOrDefault = kotlin_kotlin.$_$.h;
-  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.b;
-  var toString = kotlin_kotlin.$_$.u;
-  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.e;
-  var first = kotlin_kotlin.$_$.i;
+  var protoOf = kotlin_kotlin.$_$.fd;
+  var initMetadataForInterface = kotlin_kotlin.$_$.jc;
+  var initMetadataForClass = kotlin_kotlin.$_$.fc;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.gc;
+  var toString = kotlin_kotlin.$_$.id;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.u1;
+  var Unit_instance = kotlin_kotlin.$_$.p5;
+  var initMetadataForObject = kotlin_kotlin.$_$.lc;
+  var VOID = kotlin_kotlin.$_$.c;
+  var equals = kotlin_kotlin.$_$.yb;
+  var FunctionAdapter = kotlin_kotlin.$_$.lb;
+  var isInterface = kotlin_kotlin.$_$.uc;
+  var Comparator = kotlin_kotlin.$_$.qh;
+  var hashCode = kotlin_kotlin.$_$.ec;
+  var compareValues = kotlin_kotlin.$_$.v9;
+  var sortedWith = kotlin_kotlin.$_$.a9;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.l6;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.j;
+  var first = kotlin_kotlin.$_$.p7;
   var Default_getInstance = kotlin_dev_whyoleg_cryptography_cryptography_random.$_$.a;
-  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.c;
-  var lazy = kotlin_kotlin.$_$.z;
-  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.d;
-  var THROW_CCE = kotlin_kotlin.$_$.x;
-  var KtMap = kotlin_kotlin.$_$.g;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.t;
+  var lazy = kotlin_kotlin.$_$.cj;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.q1;
+  var THROW_CCE = kotlin_kotlin.$_$.di;
+  var KtMap = kotlin_kotlin.$_$.y5;
+  var Enum = kotlin_kotlin.$_$.th;
+  var closeFinally = kotlin_kotlin.$_$.si;
+  var AutoCloseable = kotlin_kotlin.$_$.mh;
   //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.a7t(format, bytes);
+  }
+  initMetadataForInterface(KeyDecoder, 'KeyDecoder', VOID, VOID, VOID, [2]);
+  function hash(data, $completion) {
+    return this.d7t(data);
+  }
+  function hashBlocking(data) {
+    var tmp0 = this.b7t();
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.use' call
+      var exception = null;
+      try {
+        tmp0.e7t(data);
+        tmp$ret$1 = tmp0.f7t();
+        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.i7t(data);
+  }
+  function generateSignatureBlocking(data) {
+    var tmp0 = this.g7t();
+    var tmp$ret$1;
+    $l$block: {
+      // Inline function 'kotlin.use' call
+      var exception = null;
+      try {
+        tmp0.e7t(data);
+        tmp$ret$1 = tmp0.j7t();
+        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.k7t(source, startIndex, endIndex);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.k7t.call(this, source, startIndex, endIndex);
+    }
+    return tmp;
+  }
+  initMetadataForInterface(UpdateFunction, 'UpdateFunction', VOID, VOID, [AutoCloseable]);
   //endregion
+  function CryptographyAlgorithm() {
+  }
+  function CryptographyAlgorithmId(name) {
+    this.h7s_1 = name;
+  }
   function Companion() {
   }
+  protoOf(Companion).i7s = function () {
+    return CryptographySystem_getInstance().k7s();
+  };
   var Companion_instance;
   function Companion_getInstance() {
     return Companion_instance;
   }
   function CryptographyProvider() {
   }
+  protoOf(CryptographyProvider).m7s = function (identifier) {
+    var tmp0_elvis_lhs = this.l7s(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.d5_1 = new CryptographySystemImpl();
+    this.j7s_1 = new CryptographySystemImpl();
     loadProviders(this);
   }
-  protoOf(CryptographySystem).e5 = function (provider, priority) {
-    return this.d5_1.e5(provider, priority);
+  protoOf(CryptographySystem).k7s = function () {
+    return this.j7s_1.k7s();
+  };
+  protoOf(CryptographySystem).t7s = function (provider, priority) {
+    return this.j7s_1.t7s(provider, priority);
   };
   var CryptographySystem_instance;
   function CryptographySystem_getInstance() {
@@ -72,26 +224,44 @@
   }
   function CompositeProvider(providers) {
     CryptographyProvider.call(this);
-    this.l5_1 = providers;
+    this.u7s_1 = providers;
   }
+  protoOf(CompositeProvider).l7s = function (identifier) {
+    var tmp0 = this.u7s_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.l7s(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.m5_1 = function_0;
+    this.v7s_1 = function_0;
   }
-  protoOf(sam$kotlin_Comparator$0).n5 = function (a, b) {
-    return this.m5_1(a, b);
+  protoOf(sam$kotlin_Comparator$0).be = function (a, b) {
+    return this.v7s_1(a, b);
   };
   protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
-    return this.n5(a, b);
+    return this.be(a, b);
   };
-  protoOf(sam$kotlin_Comparator$0).x = function () {
-    return this.m5_1;
+  protoOf(sam$kotlin_Comparator$0).k3 = function () {
+    return this.v7s_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.x(), other.x());
+        tmp_0 = equals(this.k3(), other.k3());
       } else {
         tmp_0 = false;
       }
@@ -102,18 +272,18 @@
     return tmp;
   };
   protoOf(sam$kotlin_Comparator$0).hashCode = function () {
-    return hashCode(this.x());
+    return hashCode(this.k3());
   };
   function CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda(a, b) {
     // Inline function 'kotlin.comparisons.compareValuesBy' call
-    var tmp = a.l();
-    var tmp$ret$1 = b.l();
+    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.f5_1.p();
+      var this_0 = this$0.n7s_1.l1();
       // Inline function 'kotlin.comparisons.compareBy' call
       var tmp = CryptographySystemImpl$lazyRegisteredProviders$lambda$lambda;
       var tmp$ret$0 = new sam$kotlin_Comparator$0(tmp);
@@ -121,24 +291,24 @@
       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.c();
-      while (_iterator__ex2g4s.d()) {
-        var item = _iterator__ex2g4s.e();
-        var tmp$ret$2 = item.m().m();
-        destination.i(tmp$ret$2);
+      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.h5_1;
+      var tmp0_elvis_lhs = this$0.p7s_1;
       var tmp;
       if (tmp0_elvis_lhs == null) {
         // Inline function 'kotlin.let' call
-        var it = this$0.g5_1.m();
+        var it = this$0.o7s_1.n1();
         var tmp_0;
-        switch (it.f()) {
+        switch (it.g1()) {
           case 0:
             var message = 'No providers registered. Please provide a dependency or register provider explicitly';
             throw IllegalStateException_init_$Create$(toString(message));
@@ -158,24 +328,27 @@
   }
   function CryptographySystemImpl$lazyDefaultRandom$lambda(this$0) {
     return function () {
-      var tmp0_elvis_lhs = this$0.j5_1;
+      var tmp0_elvis_lhs = this$0.r7s_1;
       return tmp0_elvis_lhs == null ? Default_getInstance() : tmp0_elvis_lhs;
     };
   }
   function CryptographySystemImpl() {
     var tmp = this;
     // Inline function 'kotlin.collections.mutableMapOf' call
-    tmp.f5_1 = LinkedHashMap_init_$Create$();
+    tmp.n7s_1 = LinkedHashMap_init_$Create$();
     var tmp_0 = this;
-    tmp_0.g5_1 = lazy(CryptographySystemImpl$lazyRegisteredProviders$lambda(this));
-    this.h5_1 = null;
+    tmp_0.o7s_1 = lazy(CryptographySystemImpl$lazyRegisteredProviders$lambda(this));
+    this.p7s_1 = null;
     var tmp_1 = this;
-    tmp_1.i5_1 = lazy(CryptographySystemImpl$lazyDefaultProvider$lambda(this));
-    this.j5_1 = null;
+    tmp_1.q7s_1 = lazy(CryptographySystemImpl$lazyDefaultProvider$lambda(this));
+    this.r7s_1 = null;
     var tmp_2 = this;
-    tmp_2.k5_1 = lazy(CryptographySystemImpl$lazyDefaultRandom$lambda(this));
+    tmp_2.s7s_1 = lazy(CryptographySystemImpl$lazyDefaultRandom$lambda(this));
   }
-  protoOf(CryptographySystemImpl).e5 = function (provider, priority) {
+  protoOf(CryptographySystemImpl).k7s = function () {
+    return this.q7s_1.n1();
+  };
+  protoOf(CryptographySystemImpl).t7s = function (provider, priority) {
     // Inline function 'kotlin.require' call
     if (!(priority >= 0)) {
       var message = 'Priority must be greater or equal to 0';
@@ -183,29 +356,753 @@
     }
     // Inline function 'kotlin.collections.contains' call
     // Inline function 'kotlin.collections.containsKey' call
-    var this_0 = this.f5_1;
+    var this_0 = this.n7s_1;
     // Inline function 'kotlin.require' call
-    if (!!(isInterface(this_0, KtMap) ? this_0 : THROW_CCE()).n(priority)) {
+    if (!!(isInterface(this_0, KtMap) ? this_0 : THROW_CCE()).b3(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.g5_1.s4()) {
+    if (!!this.o7s_1.op()) {
       var message_1 = 'Cannot register provider after `getRegisteredProviders` was called';
       throw IllegalStateException_init_$Create$(toString(message_1));
     }
     // Inline function 'kotlin.collections.set' call
-    this.f5_1.n1(priority, provider);
+    this.n7s_1.w2(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).w7s = function () {
+    return _Curve___init__impl__ygix12('P-256');
+  };
+  protoOf(Companion_3).x7s = function () {
+    return _Curve___init__impl__ygix12('P-384');
+  };
+  protoOf(Companion_3).y7s = 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
   _.$_$ = _.$_$ || {};
-  _.$_$.a = CryptographyProvider;
-  _.$_$.b = CryptographySystem_getInstance;
+  _.$_$.a = Format;
+  _.$_$.b = Format_1;
+  _.$_$.c = Format_0;
+  _.$_$.d = Format_2;
+  _.$_$.e = Format_4;
+  _.$_$.f = Format_3;
+  _.$_$.g = KeyDecoder;
+  _.$_$.h = Hasher;
+  _.$_$.i = SignatureGenerator;
+  _.$_$.j = CryptographyAlgorithm;
+  _.$_$.k = CryptographyProvider;
+  _.$_$.l = Format_RAW_getInstance;
+  _.$_$.m = _Curve___get_name__impl__klrusc;
+  _.$_$.n = Companion_getInstance_0;
+  _.$_$.o = Companion_getInstance_1;
+  _.$_$.p = Companion_getInstance_2;
+  _.$_$.q = Companion_instance_3;
+  _.$_$.r = Generic_getInstance;
+  _.$_$.s = SEC1_getInstance;
+  _.$_$.t = JWK_getInstance_0;
+  _.$_$.u = Generic_getInstance_0;
+  _.$_$.v = SEC1_getInstance_0;
+  _.$_$.w = RAW_getInstance;
+  _.$_$.x = DER_getInstance;
+  _.$_$.y = JWK_getInstance;
+  _.$_$.z = PEM_getInstance;
+  _.$_$.a1 = Compressed_getInstance;
+  _.$_$.b1 = Uncompressed_getInstance;
+  _.$_$.c1 = Companion_getInstance_4;
+  _.$_$.d1 = Companion_getInstance_5;
+  _.$_$.e1 = Companion_getInstance_6;
+  _.$_$.f1 = Companion_getInstance_7;
+  _.$_$.g1 = Companion_getInstance_8;
+  _.$_$.h1 = Companion_getInstance_9;
+  _.$_$.i1 = Companion_getInstance_11;
+  _.$_$.j1 = Companion_getInstance_10;
+  _.$_$.k1 = Generic_getInstance_3;
+  _.$_$.l1 = PKCS1_getInstance_1;
+  _.$_$.m1 = JWK_getInstance_2;
+  _.$_$.n1 = Generic_getInstance_4;
+  _.$_$.o1 = PKCS1_getInstance_2;
+  _.$_$.p1 = Generic_getInstance_1;
+  _.$_$.q1 = PKCS1_getInstance;
+  _.$_$.r1 = JWK_getInstance_1;
+  _.$_$.s1 = Generic_getInstance_2;
+  _.$_$.t1 = PKCS1_getInstance_0;
+  _.$_$.u1 = SHA1_getInstance;
+  _.$_$.v1 = SHA256_getInstance;
+  _.$_$.w1 = SHA384_getInstance;
+  _.$_$.x1 = SHA512_getInstance;
+  _.$_$.y1 = Companion_instance;
+  _.$_$.z1 = CryptographySystem_getInstance;
   //endregion
   return _;
 }));