@icure/cardinal-sdk 0.0.0-unspecified

package/kerberus.mjs

@@ -0,0 +1,1089 @@
+import {
+  StringSerializer_getInstance1k1oz5j50sfik as StringSerializer_getInstance,
+  ArrayListSerializer7k5wnrulb3y6 as ArrayListSerializer,
+  PluginGeneratedSerialDescriptorqdzeg5asqhfg as PluginGeneratedSerialDescriptor,
+  UnknownFieldException_init_$Create$1mnsp66c6fnup as UnknownFieldException_init_$Create$,
+  IntSerializer_getInstance9scrtcljaiv6 as IntSerializer_getInstance,
+  typeParametersSerializers2likxjr48tr7y as typeParametersSerializers,
+  GeneratedSerializer1f7t7hssdd2ws as GeneratedSerializer,
+  throwMissingFieldException2cmke0v3ynf14 as throwMissingFieldException,
+} from './kotlinx-serialization-kotlinx-serialization-core.mjs';
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  VOID7hggqo3abtya as VOID,
+  Unit_instance104q5opgivhr8 as Unit_instance,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$1s1wkrw82c0iw as ArrayList_init_$Create$,
+  encodeToByteArray1onwao0uakjfh as encodeToByteArray,
+  primitiveArrayConcatwxgknw08pmlb as primitiveArrayConcat,
+  toLongw1zpgk99d84b as toLong,
+  until1jbpn0z3f8lbg as until,
+  sliceArray2hu2ljigibgmi as sliceArray,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  Long2qws0ah9gnpki as Long,
+  checkIndexOverflow3frtmheghr0th as checkIndexOverflow,
+  toList3jhuyej2anx2q as toList,
+  withIndex37cl61h9v5txo as withIndex,
+  Collection1k04j3hzsbod0 as Collection,
+  isInterface3d6p8outrmvmk as isInterface,
+  toLongkk4waq8msp1k as toLong_0,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  to2cs3ny02qtbcb as to,
+  copyToArray2j022khrow2yi as copyToArray,
+  json3n35pf5np6si4 as json,
+  toList383f556t1dixk as toList_0,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  BigInteger_init_$Create$9syik4tteoxw as BigInteger_init_$Create$,
+  Companion_getInstancemdtedqrycrty as Companion_getInstance,
+  Sign_POSITIVE_getInstanceuovuet5mou3r as Sign_POSITIVE_getInstance,
+} from './KotlinBigInteger-bignum.mjs';
+import {
+  get_defaultCryptoService3se6h24t6bp5v as get_defaultCryptoService,
+  adaptExternalCryptoService1ul8uw60bqm2i as adaptExternalCryptoService,
+} from './kryptom-lib.mjs';
+import {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  GlobalScope_instance3rq364dcgnf9q as GlobalScope_instance,
+  launch1c91vkjzdi9sd as launch,
+} from './kotlinx-coroutines-core.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForObject($serializer, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(Challenge, 'Challenge', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance});
+initMetadataForCompanion(Companion_0);
+initMetadataForCoroutine($scoreCOROUTINE$0, CoroutineImpl);
+initMetadataForCoroutine($calculateCOROUTINE$1, CoroutineImpl);
+initMetadataForCoroutine($resolveCOROUTINE$2, CoroutineImpl);
+initMetadataForCoroutine($validateCOROUTINE$3, CoroutineImpl);
+initMetadataForClass(ChallengePieceResolver, 'ChallengePieceResolver', VOID, VOID, VOID, [1, 2]);
+initMetadataForCoroutine($resolveChallengeCOROUTINE$4, CoroutineImpl);
+initMetadataForCoroutine($validateSolutionCOROUTINE$5, CoroutineImpl);
+initMetadataForCompanion(Companion_1);
+initMetadataForObject($serializer_0, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(ProofOfWork, 'ProofOfWork', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_0});
+initMetadataForCompanion(Companion_2);
+initMetadataForObject($serializer_1, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(Solution, 'Solution', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_1});
+initMetadataForLambda(resolveChallengeJs$lambda$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForLambda(validateSolutionJs$lambda$slambda, CoroutineImpl, VOID, [1]);
+//endregion
+function Companion() {
+  Companion_instance = this;
+  var tmp = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  tmp.p7a_1 = [null, new ArrayListSerializer(StringSerializer_getInstance()), null];
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance == null)
+    new Companion();
+  return Companion_instance;
+}
+function $serializer() {
+  $serializer_instance = this;
+  var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('com.icure.kerberus.Challenge', this, 3);
+  tmp0_serialDesc.z2a('id', false);
+  tmp0_serialDesc.z2a('salts', false);
+  tmp0_serialDesc.z2a('difficultyFactor', false);
+  this.q7a_1 = tmp0_serialDesc;
+}
+protoOf($serializer).r7a = function (encoder, value) {
+  var tmp0_desc = this.q7a_1;
+  var tmp1_output = encoder.m23(tmp0_desc);
+  var tmp2_cached = Companion_getInstance_0().p7a_1;
+  tmp1_output.c25(tmp0_desc, 0, value.s7a_1);
+  tmp1_output.e25(tmp0_desc, 1, tmp2_cached[1], value.t7a_1);
+  tmp1_output.x24(tmp0_desc, 2, value.u7a_1);
+  tmp1_output.n23(tmp0_desc);
+};
+protoOf($serializer).c20 = function (encoder, value) {
+  return this.r7a(encoder, value instanceof Challenge ? value : THROW_CCE());
+};
+protoOf($serializer).d20 = function (decoder) {
+  var tmp0_desc = this.q7a_1;
+  var tmp1_flag = true;
+  var tmp2_index = 0;
+  var tmp3_bitMask0 = 0;
+  var tmp4_local0 = null;
+  var tmp5_local1 = null;
+  var tmp6_local2 = 0;
+  var tmp7_input = decoder.m23(tmp0_desc);
+  var tmp8_cached = Companion_getInstance_0().p7a_1;
+  if (tmp7_input.d24()) {
+    tmp4_local0 = tmp7_input.w23(tmp0_desc, 0);
+    tmp3_bitMask0 = tmp3_bitMask0 | 1;
+    tmp5_local1 = tmp7_input.y23(tmp0_desc, 1, tmp8_cached[1], tmp5_local1);
+    tmp3_bitMask0 = tmp3_bitMask0 | 2;
+    tmp6_local2 = tmp7_input.r23(tmp0_desc, 2);
+    tmp3_bitMask0 = tmp3_bitMask0 | 4;
+  } else
+    while (tmp1_flag) {
+      tmp2_index = tmp7_input.e24(tmp0_desc);
+      switch (tmp2_index) {
+        case -1:
+          tmp1_flag = false;
+          break;
+        case 0:
+          tmp4_local0 = tmp7_input.w23(tmp0_desc, 0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          break;
+        case 1:
+          tmp5_local1 = tmp7_input.y23(tmp0_desc, 1, tmp8_cached[1], tmp5_local1);
+          tmp3_bitMask0 = tmp3_bitMask0 | 2;
+          break;
+        case 2:
+          tmp6_local2 = tmp7_input.r23(tmp0_desc, 2);
+          tmp3_bitMask0 = tmp3_bitMask0 | 4;
+          break;
+        default:
+          throw UnknownFieldException_init_$Create$(tmp2_index);
+      }
+    }
+  tmp7_input.n23(tmp0_desc);
+  return Challenge_init_$Create$(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
+};
+protoOf($serializer).b20 = function () {
+  return this.q7a_1;
+};
+protoOf($serializer).s2b = function () {
+  var tmp0_cached = Companion_getInstance_0().p7a_1;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return [StringSerializer_getInstance(), tmp0_cached[1], IntSerializer_getInstance()];
+};
+var $serializer_instance;
+function $serializer_getInstance() {
+  if ($serializer_instance == null)
+    new $serializer();
+  return $serializer_instance;
+}
+function Challenge_init_$Init$(seen0, id, salts, difficultyFactor, serializationConstructorMarker, $this) {
+  if (!(7 === (7 & seen0))) {
+    throwMissingFieldException(seen0, 7, $serializer_getInstance().q7a_1);
+  }
+  $this.s7a_1 = id;
+  $this.t7a_1 = salts;
+  $this.u7a_1 = difficultyFactor;
+  return $this;
+}
+function Challenge_init_$Create$(seen0, id, salts, difficultyFactor, serializationConstructorMarker) {
+  return Challenge_init_$Init$(seen0, id, salts, difficultyFactor, serializationConstructorMarker, objectCreate(protoOf(Challenge)));
+}
+function Challenge(id, salts, difficultyFactor) {
+  Companion_getInstance_0();
+  this.s7a_1 = id;
+  this.t7a_1 = salts;
+  this.u7a_1 = difficultyFactor;
+}
+function Companion_0() {
+  Companion_instance_0 = this;
+  this.v7a_1 = BigInteger_init_$Create$(2).o76(128).d76(Companion_getInstance().i71_1);
+  this.w7a_1 = this.v7a_1.s76(false);
+}
+protoOf(Companion_0).x7a = function (config, serializedInput, cryptoService) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = config.t7a_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.p();
+  while (_iterator__ex2g4s.q()) {
+    var item = _iterator__ex2g4s.r();
+    var tmp$ret$0 = new ChallengePieceResolver(item, serializedInput, config.u7a_1, cryptoService.l61());
+    destination.k(tmp$ret$0);
+  }
+  return destination;
+};
+var Companion_instance_0;
+function Companion_getInstance_1() {
+  if (Companion_instance_0 == null)
+    new Companion_0();
+  return Companion_instance_0;
+}
+function _get_prefix__wiwq7t($this) {
+  var tmp0 = encodeToByteArray($this.y7a_1);
+  // Inline function 'kotlin.collections.plus' call
+  var elements = encodeToByteArray($this.z7a_1);
+  return primitiveArrayConcat([tmp0, elements]);
+}
+function _get_difficulty__gn5kuo($this) {
+  var maxValue = Companion_getInstance_1().v7a_1;
+  return maxValue.d76(maxValue.j76(Companion_getInstance().w72(toLong($this.a7b_1))));
+}
+function firstBytesAsBigInteger($this, bytes) {
+  var first16Bytes = sliceArray(bytes, until(0, 16));
+  return Companion_getInstance().d75(first16Bytes, Sign_POSITIVE_getInstance());
+}
+function sha256($this, input, $completion) {
+  return $this.b7b_1.k69(input, $completion);
+}
+function score($this, prefixHash, nonce, $completion) {
+  var tmp = new $scoreCOROUTINE$0($this, prefixHash, nonce, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function calculate($this, nonce, $completion) {
+  var tmp = new $calculateCOROUTINE$1($this, nonce, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function $scoreCOROUTINE$0(_this__u8e3s4, prefixHash, nonce, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.k7b_1 = _this__u8e3s4;
+  this.l7b_1 = prefixHash;
+  this.m7b_1 = nonce;
+}
+protoOf($scoreCOROUTINE$0).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          this.n7b_1 = encodeToByteArray(this.m7b_1.toString());
+          var tmp_0 = this;
+          var tmp0 = this.l7b_1;
+          var elements = this.n7b_1;
+          tmp_0.o7b_1 = primitiveArrayConcat([tmp0, elements]);
+          this.j9_1 = 1;
+          suspendResult = sha256(this.k7b_1, this.o7b_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var hash = suspendResult;
+          return firstBytesAsBigInteger(this.k7b_1, hash);
+        case 2:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 2) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $calculateCOROUTINE$1(_this__u8e3s4, nonce, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.x7b_1 = _this__u8e3s4;
+  this.y7b_1 = nonce;
+}
+protoOf($calculateCOROUTINE$1).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          this.j9_1 = 1;
+          suspendResult = sha256(this.x7b_1, _get_prefix__wiwq7t(this.x7b_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.z7b_1 = suspendResult;
+          this.j9_1 = 2;
+          suspendResult = score(this.x7b_1, this.z7b_1, this.y7b_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return suspendResult;
+        case 3:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 3) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $resolveCOROUTINE$2(_this__u8e3s4, onProgress, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.i7c_1 = _this__u8e3s4;
+  this.j7c_1 = onProgress;
+}
+protoOf($resolveCOROUTINE$2).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 5;
+          this.j9_1 = 1;
+          suspendResult = sha256(this.i7c_1, _get_prefix__wiwq7t(this.i7c_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.k7c_1 = suspendResult;
+          this.l7c_1 = _get_difficulty__gn5kuo(this.i7c_1).s76(false) / Companion_getInstance_1().w7a_1;
+          this.m7c_1 = 1.0;
+          this.n7c_1 = new Long(0, 0);
+          this.o7c_1 = Companion_getInstance().h71_1;
+          this.j9_1 = 2;
+          continue $sm;
+        case 2:
+          if (!(this.o7c_1.x73(_get_difficulty__gn5kuo(this.i7c_1)) < 0)) {
+            this.j9_1 = 4;
+            continue $sm;
+          }
+
+          var tmp_0 = this;
+          tmp_0.n7c_1 = this.n7c_1.b3(toLong(1));
+          this.j9_1 = 3;
+          suspendResult = score(this.i7c_1, this.k7c_1, this.n7c_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 3:
+          this.o7c_1 = suspendResult;
+          this.m7c_1 = this.m7c_1 * this.l7c_1;
+          this.j7c_1(1 - this.m7c_1);
+          this.j9_1 = 2;
+          continue $sm;
+        case 4:
+          return new ProofOfWork(this.n7c_1.toString());
+        case 5:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 5) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $validateCOROUTINE$3(_this__u8e3s4, nonce, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.x7c_1 = _this__u8e3s4;
+  this.y7c_1 = nonce;
+}
+protoOf($validateCOROUTINE$3).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          this.j9_1 = 1;
+          suspendResult = calculate(this.x7c_1, this.y7c_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var calculatedResult = suspendResult;
+          return calculatedResult.x73(_get_difficulty__gn5kuo(this.x7c_1)) >= 0;
+        case 2:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 2) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function ChallengePieceResolver(salt, serializedInput, difficultyFactor, digestService) {
+  Companion_getInstance_1();
+  this.y7a_1 = salt;
+  this.z7a_1 = serializedInput;
+  this.a7b_1 = difficultyFactor;
+  this.b7b_1 = digestService;
+}
+protoOf(ChallengePieceResolver).z7c = function (onProgress, $completion) {
+  var tmp = new $resolveCOROUTINE$2(this, onProgress, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(ChallengePieceResolver).a7d = function (nonce, $completion) {
+  var tmp = new $validateCOROUTINE$3(this, nonce, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+function resolveChallenge(config, serializedInput, cryptoService, onProgress, $completion) {
+  cryptoService = cryptoService === VOID ? null : cryptoService;
+  var tmp;
+  if (onProgress === VOID) {
+    tmp = resolveChallenge$lambda;
+  } else {
+    tmp = onProgress;
+  }
+  onProgress = tmp;
+  var tmp_0 = new $resolveChallengeCOROUTINE$4(config, serializedInput, cryptoService, onProgress, $completion);
+  tmp_0.l9_1 = Unit_instance;
+  tmp_0.m9_1 = null;
+  return tmp_0.r9();
+}
+function validateSolution(config, result, serializedInput, cryptoService, $completion) {
+  cryptoService = cryptoService === VOID ? null : cryptoService;
+  var tmp = new $validateSolutionCOROUTINE$5(config, result, serializedInput, cryptoService, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function resolveChallenge$lambda(it) {
+  return Unit_instance;
+}
+function resolveChallenge$lambda_0($index, $challenges, $lastSentProgress, $onProgress) {
+  return function (challengeProgress) {
+    var progress = ($index + challengeProgress) / $challenges.s();
+    var tmp;
+    if (progress - $lastSentProgress._v > 0.01) {
+      $lastSentProgress._v = progress;
+      tmp = $onProgress(progress);
+    }
+    return Unit_instance;
+  };
+}
+function $resolveChallengeCOROUTINE$4(config, serializedInput, cryptoService, onProgress, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.j7d_1 = config;
+  this.k7d_1 = serializedInput;
+  this.l7d_1 = cryptoService;
+  this.m7d_1 = onProgress;
+}
+protoOf($resolveChallengeCOROUTINE$4).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 4;
+          var tmp_0 = this;
+          var tmp_1 = Companion_getInstance_1();
+          var tmp0_elvis_lhs = this.l7d_1;
+          tmp_0.n7d_1 = tmp_1.x7a(this.j7d_1, this.k7d_1, tmp0_elvis_lhs == null ? get_defaultCryptoService() : tmp0_elvis_lhs);
+          this.o7d_1 = {_v: 0.0};
+          this.p7d_1 = this.j7d_1.s7a_1;
+          var tmp_2 = this;
+          tmp_2.q7d_1 = this.n7d_1;
+          this.r7d_1 = this.q7d_1;
+          var tmp_3 = this;
+          tmp_3.s7d_1 = this.r7d_1;
+          var tmp_4 = this;
+          tmp_4.t7d_1 = ArrayList_init_$Create$(collectionSizeOrDefault(this.r7d_1, 10));
+          this.u7d_1 = this.s7d_1;
+          this.v7d_1 = this.t7d_1;
+          this.w7d_1 = 0;
+          this.x7d_1 = this.u7d_1.p();
+          this.j9_1 = 1;
+          continue $sm;
+        case 1:
+          if (!this.x7d_1.q()) {
+            this.j9_1 = 3;
+            continue $sm;
+          }
+
+          this.y7d_1 = this.x7d_1.r();
+          var tmp_5 = this;
+          var _unary__edvuaz = this.w7d_1;
+          this.w7d_1 = _unary__edvuaz + 1 | 0;
+          tmp_5.z7d_1 = checkIndexOverflow(_unary__edvuaz);
+          var tmp_6 = this;
+          tmp_6.a7e_1 = this.y7d_1;
+          this.b7e_1 = this.z7d_1;
+          this.c7e_1 = this.a7e_1;
+          this.j9_1 = 2;
+          suspendResult = this.c7e_1.z7c(resolveChallenge$lambda_0(this.b7e_1, this.n7d_1, this.o7d_1, this.m7d_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          var ARGUMENT = suspendResult;
+          this.v7d_1.k(ARGUMENT);
+          this.j9_1 = 1;
+          continue $sm;
+        case 3:
+          var this_0 = this.v7d_1;
+          var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+          var _iterator__ex2g4s = this_0.p();
+          while (_iterator__ex2g4s.q()) {
+            var item = _iterator__ex2g4s.r();
+            destination.k(item.z7e_1);
+          }
+
+          var ARGUMENT_0 = destination;
+          var ARGUMENT_1 = toList(ARGUMENT_0);
+          var this_1 = new Solution(this.p7d_1, ARGUMENT_1);
+          this.m7d_1(1.0);
+          return this_1;
+        case 4:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 4) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $validateSolutionCOROUTINE$5(config, result, serializedInput, cryptoService, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.l7e_1 = config;
+  this.m7e_1 = result;
+  this.n7e_1 = serializedInput;
+  this.o7e_1 = cryptoService;
+}
+protoOf($validateSolutionCOROUTINE$5).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 7;
+          var tmp_0 = this;
+          var tmp_1 = Companion_getInstance_1();
+          var tmp0_elvis_lhs = this.o7e_1;
+          tmp_0.p7e_1 = tmp_1.x7a(this.l7e_1, this.n7e_1, tmp0_elvis_lhs == null ? get_defaultCryptoService() : tmp0_elvis_lhs);
+          var tmp_2 = this;
+          tmp_2.q7e_1 = withIndex(this.p7e_1);
+          this.j9_1 = 1;
+          continue $sm;
+        case 1:
+          this.s7e_1 = this.q7e_1;
+          var tmp_3;
+          var tmp_4 = this.s7e_1;
+          if (isInterface(tmp_4, Collection)) {
+            tmp_3 = this.s7e_1.h();
+          } else {
+            tmp_3 = false;
+          }
+
+          if (tmp_3) {
+            this.r7e_1 = true;
+            this.j9_1 = 8;
+            continue $sm;
+          } else {
+            this.j9_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          this.t7e_1 = this.s7e_1.p();
+          this.j9_1 = 3;
+          continue $sm;
+        case 3:
+          if (!this.t7e_1.q()) {
+            this.j9_1 = 6;
+            continue $sm;
+          }
+
+          this.u7e_1 = this.t7e_1.r();
+          var tmp_5 = this;
+          tmp_5.v7e_1 = this.u7e_1;
+          this.w7e_1 = this.v7e_1;
+          this.x7e_1 = this.w7e_1.nb();
+          this.y7e_1 = this.w7e_1.ob();
+          this.j9_1 = 4;
+          suspendResult = this.y7e_1.a7d(toLong_0(this.m7e_1.b7f_1.u(this.x7e_1)), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 4:
+          var ARGUMENT = suspendResult;
+          if (!ARGUMENT) {
+            this.r7e_1 = false;
+            this.j9_1 = 8;
+            continue $sm;
+          } else {
+            this.j9_1 = 5;
+            continue $sm;
+          }
+
+        case 5:
+          this.j9_1 = 3;
+          continue $sm;
+        case 6:
+          this.r7e_1 = true;
+          if (false) {
+            this.j9_1 = 1;
+            continue $sm;
+          }
+
+          this.j9_1 = 8;
+          continue $sm;
+        case 7:
+          throw this.m9_1;
+        case 8:
+          return this.r7e_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 7) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function Companion_1() {
+}
+var Companion_instance_1;
+function Companion_getInstance_2() {
+  return Companion_instance_1;
+}
+function $serializer_0() {
+  $serializer_instance_0 = this;
+  var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('com.icure.kerberus.ProofOfWork', this, 1);
+  tmp0_serialDesc.z2a('nonce', false);
+  this.c7f_1 = tmp0_serialDesc;
+}
+protoOf($serializer_0).d7f = function (encoder, value) {
+  var tmp0_desc = this.c7f_1;
+  var tmp1_output = encoder.m23(tmp0_desc);
+  tmp1_output.c25(tmp0_desc, 0, value.z7e_1);
+  tmp1_output.n23(tmp0_desc);
+};
+protoOf($serializer_0).c20 = function (encoder, value) {
+  return this.d7f(encoder, value instanceof ProofOfWork ? value : THROW_CCE());
+};
+protoOf($serializer_0).d20 = function (decoder) {
+  var tmp0_desc = this.c7f_1;
+  var tmp1_flag = true;
+  var tmp2_index = 0;
+  var tmp3_bitMask0 = 0;
+  var tmp4_local0 = null;
+  var tmp5_input = decoder.m23(tmp0_desc);
+  if (tmp5_input.d24()) {
+    tmp4_local0 = tmp5_input.w23(tmp0_desc, 0);
+    tmp3_bitMask0 = tmp3_bitMask0 | 1;
+  } else
+    while (tmp1_flag) {
+      tmp2_index = tmp5_input.e24(tmp0_desc);
+      switch (tmp2_index) {
+        case -1:
+          tmp1_flag = false;
+          break;
+        case 0:
+          tmp4_local0 = tmp5_input.w23(tmp0_desc, 0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          break;
+        default:
+          throw UnknownFieldException_init_$Create$(tmp2_index);
+      }
+    }
+  tmp5_input.n23(tmp0_desc);
+  return ProofOfWork_init_$Create$(tmp3_bitMask0, tmp4_local0, null);
+};
+protoOf($serializer_0).b20 = function () {
+  return this.c7f_1;
+};
+protoOf($serializer_0).s2b = function () {
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return [StringSerializer_getInstance()];
+};
+var $serializer_instance_0;
+function $serializer_getInstance_0() {
+  if ($serializer_instance_0 == null)
+    new $serializer_0();
+  return $serializer_instance_0;
+}
+function ProofOfWork_init_$Init$(seen0, nonce, serializationConstructorMarker, $this) {
+  if (!(1 === (1 & seen0))) {
+    throwMissingFieldException(seen0, 1, $serializer_getInstance_0().c7f_1);
+  }
+  $this.z7e_1 = nonce;
+  return $this;
+}
+function ProofOfWork_init_$Create$(seen0, nonce, serializationConstructorMarker) {
+  return ProofOfWork_init_$Init$(seen0, nonce, serializationConstructorMarker, objectCreate(protoOf(ProofOfWork)));
+}
+function ProofOfWork(nonce) {
+  this.z7e_1 = nonce;
+}
+protoOf(ProofOfWork).toString = function () {
+  return 'ProofOfWork(nonce=' + this.z7e_1 + ')';
+};
+protoOf(ProofOfWork).hashCode = function () {
+  return getStringHashCode(this.z7e_1);
+};
+protoOf(ProofOfWork).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof ProofOfWork))
+    return false;
+  var tmp0_other_with_cast = other instanceof ProofOfWork ? other : THROW_CCE();
+  if (!(this.z7e_1 === tmp0_other_with_cast.z7e_1))
+    return false;
+  return true;
+};
+function Companion_2() {
+  Companion_instance_2 = this;
+  var tmp = this;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  tmp.e7f_1 = [null, new ArrayListSerializer(StringSerializer_getInstance())];
+}
+var Companion_instance_2;
+function Companion_getInstance_3() {
+  if (Companion_instance_2 == null)
+    new Companion_2();
+  return Companion_instance_2;
+}
+function $serializer_1() {
+  $serializer_instance_1 = this;
+  var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('com.icure.kerberus.Solution', this, 2);
+  tmp0_serialDesc.z2a('id', false);
+  tmp0_serialDesc.z2a('nonces', false);
+  this.f7f_1 = tmp0_serialDesc;
+}
+protoOf($serializer_1).g7f = function (encoder, value) {
+  var tmp0_desc = this.f7f_1;
+  var tmp1_output = encoder.m23(tmp0_desc);
+  var tmp2_cached = Companion_getInstance_3().e7f_1;
+  tmp1_output.c25(tmp0_desc, 0, value.a7f_1);
+  tmp1_output.e25(tmp0_desc, 1, tmp2_cached[1], value.b7f_1);
+  tmp1_output.n23(tmp0_desc);
+};
+protoOf($serializer_1).c20 = function (encoder, value) {
+  return this.g7f(encoder, value instanceof Solution ? value : THROW_CCE());
+};
+protoOf($serializer_1).d20 = function (decoder) {
+  var tmp0_desc = this.f7f_1;
+  var tmp1_flag = true;
+  var tmp2_index = 0;
+  var tmp3_bitMask0 = 0;
+  var tmp4_local0 = null;
+  var tmp5_local1 = null;
+  var tmp6_input = decoder.m23(tmp0_desc);
+  var tmp7_cached = Companion_getInstance_3().e7f_1;
+  if (tmp6_input.d24()) {
+    tmp4_local0 = tmp6_input.w23(tmp0_desc, 0);
+    tmp3_bitMask0 = tmp3_bitMask0 | 1;
+    tmp5_local1 = tmp6_input.y23(tmp0_desc, 1, tmp7_cached[1], tmp5_local1);
+    tmp3_bitMask0 = tmp3_bitMask0 | 2;
+  } else
+    while (tmp1_flag) {
+      tmp2_index = tmp6_input.e24(tmp0_desc);
+      switch (tmp2_index) {
+        case -1:
+          tmp1_flag = false;
+          break;
+        case 0:
+          tmp4_local0 = tmp6_input.w23(tmp0_desc, 0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          break;
+        case 1:
+          tmp5_local1 = tmp6_input.y23(tmp0_desc, 1, tmp7_cached[1], tmp5_local1);
+          tmp3_bitMask0 = tmp3_bitMask0 | 2;
+          break;
+        default:
+          throw UnknownFieldException_init_$Create$(tmp2_index);
+      }
+    }
+  tmp6_input.n23(tmp0_desc);
+  return Solution_init_$Create$(tmp3_bitMask0, tmp4_local0, tmp5_local1, null);
+};
+protoOf($serializer_1).b20 = function () {
+  return this.f7f_1;
+};
+protoOf($serializer_1).s2b = function () {
+  var tmp0_cached = Companion_getInstance_3().e7f_1;
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return [StringSerializer_getInstance(), tmp0_cached[1]];
+};
+var $serializer_instance_1;
+function $serializer_getInstance_1() {
+  if ($serializer_instance_1 == null)
+    new $serializer_1();
+  return $serializer_instance_1;
+}
+function Solution_init_$Init$(seen0, id, nonces, serializationConstructorMarker, $this) {
+  if (!(3 === (3 & seen0))) {
+    throwMissingFieldException(seen0, 3, $serializer_getInstance_1().f7f_1);
+  }
+  $this.a7f_1 = id;
+  $this.b7f_1 = nonces;
+  return $this;
+}
+function Solution_init_$Create$(seen0, id, nonces, serializationConstructorMarker) {
+  return Solution_init_$Init$(seen0, id, nonces, serializationConstructorMarker, objectCreate(protoOf(Solution)));
+}
+function Solution(id, nonces) {
+  Companion_getInstance_3();
+  this.a7f_1 = id;
+  this.b7f_1 = nonces;
+}
+function resolveChallenge_0(config, serializedInput, cryptoService, onProgress) {
+  cryptoService = cryptoService === VOID ? null : cryptoService;
+  var tmp;
+  if (onProgress === VOID) {
+    tmp = resolveChallengeJs$lambda;
+  } else {
+    tmp = onProgress;
+  }
+  onProgress = tmp;
+  return new Promise(resolveChallengeJs$lambda_0(config, serializedInput, cryptoService, onProgress));
+}
+function validateSolution_0(config, result, serializedInput, cryptoService) {
+  cryptoService = cryptoService === VOID ? null : cryptoService;
+  return new Promise(validateSolutionJs$lambda(config, result, serializedInput, cryptoService));
+}
+function toSolutionJs(_this__u8e3s4) {
+  var tmp = to('id', _this__u8e3s4.a7f_1);
+  // Inline function 'kotlin.collections.toTypedArray' call
+  var this_0 = _this__u8e3s4.b7f_1;
+  var tmp$ret$0 = copyToArray(this_0);
+  var tmp_0 = json([tmp, to('nonces', tmp$ret$0)]);
+  return !(tmp_0 == null) ? tmp_0 : THROW_CCE();
+}
+function toConfig(_this__u8e3s4) {
+  return new Challenge(_this__u8e3s4.id, toList_0(_this__u8e3s4.salts), _this__u8e3s4.difficultyFactor);
+}
+function toSolution(_this__u8e3s4) {
+  return new Solution(_this__u8e3s4.id, toList_0(_this__u8e3s4.nonces));
+}
+function resolveChallengeJs$lambda(it) {
+  return Unit_instance;
+}
+function resolveChallengeJs$lambda$slambda($resolve, $config, $serializedInput, $cryptoService, $onProgress, resultContinuation) {
+  this.p7f_1 = $resolve;
+  this.q7f_1 = $config;
+  this.r7f_1 = $serializedInput;
+  this.s7f_1 = $cryptoService;
+  this.t7f_1 = $onProgress;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(resolveChallengeJs$lambda$slambda).c1y = function ($this$launch, $completion) {
+  var tmp = this.d1y($this$launch, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(resolveChallengeJs$lambda$slambda).fa = function (p1, $completion) {
+  return this.c1y((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(resolveChallengeJs$lambda$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          this.j9_1 = 1;
+          var tmp_0 = toConfig(this.q7f_1);
+          var tmp0_safe_receiver = this.s7f_1;
+          var tmp_1;
+          if (tmp0_safe_receiver == null) {
+            tmp_1 = null;
+          } else {
+            tmp_1 = adaptExternalCryptoService(tmp0_safe_receiver);
+          }
+
+          var tmp1_elvis_lhs = tmp_1;
+          suspendResult = resolveChallenge(tmp_0, this.r7f_1, tmp1_elvis_lhs == null ? get_defaultCryptoService() : tmp1_elvis_lhs, this.t7f_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          var ARGUMENT_0 = toSolutionJs(ARGUMENT);
+          this.p7f_1(ARGUMENT_0);
+          return Unit_instance;
+        case 2:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 2) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(resolveChallengeJs$lambda$slambda).d1y = function ($this$launch, completion) {
+  var i = new resolveChallengeJs$lambda$slambda(this.p7f_1, this.q7f_1, this.r7f_1, this.s7f_1, this.t7f_1, completion);
+  i.u7f_1 = $this$launch;
+  return i;
+};
+function resolveChallengeJs$lambda$slambda_0($resolve, $config, $serializedInput, $cryptoService, $onProgress, resultContinuation) {
+  var i = new resolveChallengeJs$lambda$slambda($resolve, $config, $serializedInput, $cryptoService, $onProgress, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.c1y($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function resolveChallengeJs$lambda_0($config, $serializedInput, $cryptoService, $onProgress) {
+  return function (resolve, _unused_var__etf5q3) {
+    var tmp = GlobalScope_instance;
+    launch(tmp, VOID, VOID, resolveChallengeJs$lambda$slambda_0(resolve, $config, $serializedInput, $cryptoService, $onProgress, null));
+    return Unit_instance;
+  };
+}
+function validateSolutionJs$lambda$slambda($resolve, $config, $result, $serializedInput, $cryptoService, resultContinuation) {
+  this.d7g_1 = $resolve;
+  this.e7g_1 = $config;
+  this.f7g_1 = $result;
+  this.g7g_1 = $serializedInput;
+  this.h7g_1 = $cryptoService;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(validateSolutionJs$lambda$slambda).c1y = function ($this$launch, $completion) {
+  var tmp = this.d1y($this$launch, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(validateSolutionJs$lambda$slambda).fa = function (p1, $completion) {
+  return this.c1y((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(validateSolutionJs$lambda$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          this.j9_1 = 1;
+          var tmp_0 = toConfig(this.e7g_1);
+          var tmp_1 = toSolution(this.f7g_1);
+          var tmp0_safe_receiver = this.h7g_1;
+          var tmp_2;
+          if (tmp0_safe_receiver == null) {
+            tmp_2 = null;
+          } else {
+            tmp_2 = adaptExternalCryptoService(tmp0_safe_receiver);
+          }
+
+          var tmp1_elvis_lhs = tmp_2;
+          suspendResult = validateSolution(tmp_0, tmp_1, this.g7g_1, tmp1_elvis_lhs == null ? get_defaultCryptoService() : tmp1_elvis_lhs, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          this.d7g_1(ARGUMENT);
+          return Unit_instance;
+        case 2:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 2) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(validateSolutionJs$lambda$slambda).d1y = function ($this$launch, completion) {
+  var i = new validateSolutionJs$lambda$slambda(this.d7g_1, this.e7g_1, this.f7g_1, this.g7g_1, this.h7g_1, completion);
+  i.i7g_1 = $this$launch;
+  return i;
+};
+function validateSolutionJs$lambda$slambda_0($resolve, $config, $result, $serializedInput, $cryptoService, resultContinuation) {
+  var i = new validateSolutionJs$lambda$slambda($resolve, $config, $result, $serializedInput, $cryptoService, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.c1y($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function validateSolutionJs$lambda($config, $result, $serializedInput, $cryptoService) {
+  return function (resolve, _unused_var__etf5q3) {
+    var tmp = GlobalScope_instance;
+    launch(tmp, VOID, VOID, validateSolutionJs$lambda$slambda_0(resolve, $config, $result, $serializedInput, $cryptoService, null));
+    return Unit_instance;
+  };
+}
+//region block: post-declaration
+protoOf($serializer).t2b = typeParametersSerializers;
+protoOf($serializer_0).t2b = typeParametersSerializers;
+protoOf($serializer_1).t2b = typeParametersSerializers;
+//endregion
+//region block: init
+Companion_instance_1 = new Companion_1();
+//endregion
+//region block: exports
+export {
+  resolveChallenge_0 as resolveChallenge,
+  validateSolution_0 as validateSolution,
+};
+export {
+  Challenge as Challenge4lodadd2dc9x,
+  Solution as Solution3a9kygahi3ko,
+  resolveChallenge as resolveChallenge309c0v4fl8824,
+};
+//endregion
+
+//# sourceMappingURL=kerberus.mjs.map