@icure/cardinal-sdk 1.0.0-RC.1

package/ktor-ktor-shared-ktor-serialization-ktor-serialization-kotlinx.mjs

@@ -0,0 +1,867 @@
+import {
+  ArrayList_init_$Create$1mg0hvj9t69gh as ArrayList_init_$Create$,
+  Unit_instanceqsdpd0g7knqt as Unit_instance,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  protoOf180f3jzyo7rfj as protoOf,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  VOID7hggqo3abtya as VOID,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$1wrwcvkb28rrz as IllegalStateException_init_$Create$,
+  isInterface3d6p8outrmvmk as isInterface,
+  equals2au1ep9vhcato as equals,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  hashCodeq5arwsb9dgti as hashCode,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  IllegalArgumentException_init_$Create$254crr0i81sni as IllegalArgumentException_init_$Create$,
+  getKClassFromExpression3vpejubogshaw as getKClassFromExpression,
+  KtMap140uvy3s5zad8 as KtMap,
+  KtSetjrjc7fhfd6b9 as KtSet,
+  firstOrNull1gk7vzkf4h3nq as firstOrNull,
+  StringCompanionObject_instanceyucdfbp4i0g4 as StringCompanionObject_instance,
+  isArray1hxjqtqy632bc as isArray,
+  KtList3hktaavzmj137 as KtList,
+  filterNotNull3qfgcwmxhwfxe as filterNotNull,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$2x2ziwir2uf5h as ArrayList_init_$Create$_0,
+  HashSet_init_$Create$3v2p69c7z9lq1 as HashSet_init_$Create$,
+  singleOrNullrknfaxokm1sl as singleOrNull,
+  Collection1k04j3hzsbod0 as Collection,
+  emptyList1g2z5xcrvp2zy as emptyList,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  KSerializerzf77vz1967fq as KSerializer,
+  BinaryFormat3f3aelhmz0ro1 as BinaryFormat,
+  StringFormat2r2ka8mzcb3mi as StringFormat,
+  SerializationExceptioneqrdve3ts2n9 as SerializationException,
+  serializerOrNull31x2b6nu6gruj as serializerOrNull,
+  serializer1rka18p0rjk4x as serializer,
+  MapSerializer11kmegt3g5c1g as MapSerializer,
+  SetSerializert3lb0yy9iftr as SetSerializer,
+  serializer1x79l67jvwntn as serializer_0,
+  ListSerializer1hxuk9dx5n9du as ListSerializer,
+  get_nullable197rfua9r7fsz as get_nullable,
+} from './kotlinx-serialization-kotlinx-serialization-core.mjs';
+import {
+  ByteArrayContent9zol65b22hp0 as ByteArrayContent,
+  withCharsetIfNeeded3sz33ys0x9vfx as withCharsetIfNeeded,
+  TextContent1rb6ftlpvl1d2 as TextContent,
+  OutgoingContent3t2ohmyam9o76 as OutgoingContent,
+} from './ktor-ktor-http.mjs';
+import {
+  FlowCollector26clgpmzihvke as FlowCollector,
+  Flow3375h4584bu3w as Flow,
+  asFlow3ngsnn5xpz8pw as asFlow,
+  firstOrNull3pfaj04seehr5 as firstOrNull_0,
+} from './kotlinx-coroutines-core.mjs';
+import {
+  discard2nktejhnnvzvk as discard,
+  readBytes2b47ed7nra7rg as readBytes,
+  readText3x4cv5p7hylp as readText,
+} from './ktor-ktor-io.mjs';
+import { JsonConvertExceptiongnc5x6xwaf77 as JsonConvertException } from './ktor-ktor-shared-ktor-serialization.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForLambda(KotlinxSerializationConverter$serialize$o$collect$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($collectCOROUTINE$2, CoroutineImpl);
+initMetadataForLambda(KotlinxSerializationConverter$deserialize$o$collect$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($collectCOROUTINE$3, CoroutineImpl);
+initMetadataForClass(sam$kotlinx_coroutines_flow_FlowCollector$0, 'sam$kotlinx_coroutines_flow_FlowCollector$0', VOID, VOID, [FlowCollector, FunctionAdapter], [1]);
+initMetadataForClass(sam$kotlinx_coroutines_flow_FlowCollector$0_0, 'sam$kotlinx_coroutines_flow_FlowCollector$0', VOID, VOID, [FlowCollector, FunctionAdapter], [1]);
+initMetadataForClass(_no_name_provided__qut3iv, VOID, VOID, VOID, [Flow], [1]);
+initMetadataForLambda(KotlinxSerializationConverter$serialize$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForClass(_no_name_provided__qut3iv_0, VOID, VOID, VOID, [Flow], [1]);
+initMetadataForLambda(KotlinxSerializationConverter$deserialize$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($serializeCOROUTINE$0, CoroutineImpl);
+initMetadataForCoroutine($deserializeCOROUTINE$1, CoroutineImpl);
+initMetadataForClass(KotlinxSerializationConverter, 'KotlinxSerializationConverter', VOID, VOID, VOID, [4, 3]);
+//endregion
+function extensions(format) {
+  // Inline function 'kotlin.collections.mapNotNull' call
+  // Inline function 'kotlin.collections.mapNotNullTo' call
+  var this_0 = get_providers();
+  var destination = ArrayList_init_$Create$();
+  // Inline function 'kotlin.collections.forEach' call
+  var tmp0_iterator = this_0.p();
+  while (tmp0_iterator.q()) {
+    var element = tmp0_iterator.r();
+    // Inline function 'kotlin.collections.mapNotNullTo.<anonymous>' call
+    // Inline function 'io.ktor.serialization.kotlinx.extensions.<anonymous>' call
+    var tmp0_safe_receiver = element.r3f(format);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      destination.k(tmp0_safe_receiver);
+    }
+  }
+  return destination;
+}
+function serialization(_this__u8e3s4, contentType, format) {
+  _this__u8e3s4.b2s(contentType, new KotlinxSerializationConverter(format));
+}
+function KotlinxSerializationConverter$serialize$o$collect$slambda($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value, resultContinuation) {
+  this.a3g_1 = $$this$unsafeFlow;
+  this.b3g_1 = $contentType;
+  this.c3g_1 = $charset;
+  this.d3g_1 = $typeInfo;
+  this.e3g_1 = $value;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).u2s = function (value, $completion) {
+  var tmp = this.v2s(value, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).s9 = function (p1, $completion) {
+  return this.u2s((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 3;
+          var tmp_0 = this;
+          tmp_0.g3g_1 = this.a3g_1;
+          var tmp_1 = this;
+          tmp_1.h3g_1 = this.f3g_1;
+          var tmp_2 = this;
+          tmp_2.i3g_1 = this.h3g_1;
+          this.a9_1 = 1;
+          suspendResult = this.i3g_1.k3g(this.b3g_1, this.c3g_1, this.d3g_1, this.e3g_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.j3g_1 = suspendResult;
+          this.a9_1 = 2;
+          suspendResult = this.g3g_1.e19(this.j3g_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 3) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).v2s = function (value, completion) {
+  var i = new KotlinxSerializationConverter$serialize$o$collect$slambda(this.a3g_1, this.b3g_1, this.c3g_1, this.d3g_1, this.e3g_1, completion);
+  i.f3g_1 = value;
+  return i;
+};
+function KotlinxSerializationConverter$serialize$o$collect$slambda_0($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value, resultContinuation) {
+  var i = new KotlinxSerializationConverter$serialize$o$collect$slambda($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value, resultContinuation);
+  var l = function (value, $completion) {
+    return i.u2s(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$2(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.t3g_1 = _this__u8e3s4;
+  this.u3g_1 = collector;
+}
+protoOf($collectCOROUTINE$2).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 2;
+          var tmp_0 = this;
+          tmp_0.v3g_1 = this.u3g_1;
+          this.a9_1 = 1;
+          var tmp_1 = KotlinxSerializationConverter$serialize$o$collect$slambda_0(this.v3g_1, this.t3g_1.x3g_1, this.t3g_1.y3g_1, this.t3g_1.z3g_1, this.t3g_1.a3h_1, null);
+          suspendResult = this.t3g_1.w3g_1.b18(new sam$kotlinx_coroutines_flow_FlowCollector$0(tmp_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return Unit_instance;
+        case 2:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 2) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+function KotlinxSerializationConverter$deserialize$o$collect$slambda($$this$unsafeFlow, $charset, $typeInfo, $content, resultContinuation) {
+  this.j3h_1 = $$this$unsafeFlow;
+  this.k3h_1 = $charset;
+  this.l3h_1 = $typeInfo;
+  this.m3h_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).u2s = function (value, $completion) {
+  var tmp = this.v2s(value, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).s9 = function (p1, $completion) {
+  return this.u2s((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 3;
+          var tmp_0 = this;
+          tmp_0.o3h_1 = this.j3h_1;
+          var tmp_1 = this;
+          tmp_1.p3h_1 = this.n3h_1;
+          var tmp_2 = this;
+          tmp_2.q3h_1 = this.p3h_1;
+          this.a9_1 = 1;
+          suspendResult = this.q3h_1.w2s(this.k3h_1, this.l3h_1, this.m3h_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.r3h_1 = suspendResult;
+          this.a9_1 = 2;
+          suspendResult = this.o3h_1.e19(this.r3h_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 3) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).v2s = function (value, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$o$collect$slambda(this.j3h_1, this.k3h_1, this.l3h_1, this.m3h_1, completion);
+  i.n3h_1 = value;
+  return i;
+};
+function KotlinxSerializationConverter$deserialize$o$collect$slambda_0($$this$unsafeFlow, $charset, $typeInfo, $content, resultContinuation) {
+  var i = new KotlinxSerializationConverter$deserialize$o$collect$slambda($$this$unsafeFlow, $charset, $typeInfo, $content, resultContinuation);
+  var l = function (value, $completion) {
+    return i.u2s(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$3(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.a3i_1 = _this__u8e3s4;
+  this.b3i_1 = collector;
+}
+protoOf($collectCOROUTINE$3).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 2;
+          var tmp_0 = this;
+          tmp_0.c3i_1 = this.b3i_1;
+          this.a9_1 = 1;
+          var tmp_1 = KotlinxSerializationConverter$deserialize$o$collect$slambda_0(this.c3i_1, this.a3i_1.e3i_1, this.a3i_1.f3i_1, this.a3i_1.g3i_1, null);
+          suspendResult = this.a3i_1.d3i_1.b18(new sam$kotlinx_coroutines_flow_FlowCollector$0_0(tmp_1), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return Unit_instance;
+        case 2:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 2) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+function serializeContent($this, serializer, format, value, contentType, charset) {
+  var tmp;
+  if (isInterface(format, StringFormat)) {
+    var content = format.y2u(isInterface(serializer, KSerializer) ? serializer : THROW_CCE(), value);
+    tmp = new TextContent(content, withCharsetIfNeeded(contentType, charset));
+  } else {
+    if (isInterface(format, BinaryFormat)) {
+      var content_0 = format.b2v(isInterface(serializer, KSerializer) ? serializer : THROW_CCE(), value);
+      tmp = new ByteArrayContent(content_0, contentType);
+    } else {
+      var message = 'Unsupported format ' + toString(format);
+      throw IllegalStateException_init_$Create$(toString(message));
+    }
+  }
+  return tmp;
+}
+function sam$kotlinx_coroutines_flow_FlowCollector$0(function_0) {
+  this.h3i_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).e19 = function (value, $completion) {
+  return this.h3i_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).p3 = function () {
+  return this.h3i_1;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).equals = function (other) {
+  var tmp;
+  if (!(other == null) ? isInterface(other, FlowCollector) : false) {
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+      tmp_0 = equals(this.p3(), other.p3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).hashCode = function () {
+  return hashCode(this.p3());
+};
+function sam$kotlinx_coroutines_flow_FlowCollector$0_0(function_0) {
+  this.i3i_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).e19 = function (value, $completion) {
+  return this.i3i_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).p3 = function () {
+  return this.i3i_1;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).equals = function (other) {
+  var tmp;
+  if (!(other == null) ? isInterface(other, FlowCollector) : false) {
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+      tmp_0 = equals(this.p3(), other.p3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).hashCode = function () {
+  return hashCode(this.p3());
+};
+function _no_name_provided__qut3iv($this, $contentType, $charset, $typeInfo, $value) {
+  this.w3g_1 = $this;
+  this.x3g_1 = $contentType;
+  this.y3g_1 = $charset;
+  this.z3g_1 = $typeInfo;
+  this.a3h_1 = $value;
+}
+protoOf(_no_name_provided__qut3iv).f19 = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$2(this, collector, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(_no_name_provided__qut3iv).b18 = function (collector, $completion) {
+  return this.f19(collector, $completion);
+};
+function KotlinxSerializationConverter$serialize$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$slambda).s3i = function (it, $completion) {
+  var tmp = this.t3i(it, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).s9 = function (p1, $completion) {
+  return this.s3i((p1 == null ? true : p1 instanceof OutgoingContent) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      if (tmp === 0) {
+        this.b9_1 = 1;
+        return !(this.r3i_1 == null);
+      } else if (tmp === 1) {
+        throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).t3i = function (it, completion) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(completion);
+  i.r3i_1 = it;
+  return i;
+};
+function KotlinxSerializationConverter$serialize$slambda_0(resultContinuation) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(resultContinuation);
+  var l = function (it, $completion) {
+    return i.s3i(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function _no_name_provided__qut3iv_0($this, $charset, $typeInfo, $content) {
+  this.d3i_1 = $this;
+  this.e3i_1 = $charset;
+  this.f3i_1 = $typeInfo;
+  this.g3i_1 = $content;
+}
+protoOf(_no_name_provided__qut3iv_0).f19 = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$3(this, collector, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(_no_name_provided__qut3iv_0).b18 = function (collector, $completion) {
+  return this.f19(collector, $completion);
+};
+function KotlinxSerializationConverter$deserialize$slambda($content, resultContinuation) {
+  this.c3j_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$slambda).w2t = function (it, $completion) {
+  var tmp = this.v2s(it, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).s9 = function (p1, $completion) {
+  return this.w2t((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      if (tmp === 0) {
+        this.b9_1 = 1;
+        return !(this.d3j_1 == null) || this.c3j_1.l1l();
+      } else if (tmp === 1) {
+        throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).v2s = function (it, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$slambda(this.c3j_1, completion);
+  i.d3j_1 = it;
+  return i;
+};
+function KotlinxSerializationConverter$deserialize$slambda_0($content, resultContinuation) {
+  var i = new KotlinxSerializationConverter$deserialize$slambda($content, resultContinuation);
+  var l = function (it, $completion) {
+    return i.w2t(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $serializeCOROUTINE$0(_this__u8e3s4, contentType, charset, typeInfo, value, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.m3j_1 = _this__u8e3s4;
+  this.n3j_1 = contentType;
+  this.o3j_1 = charset;
+  this.p3j_1 = typeInfo;
+  this.q3j_1 = value;
+}
+protoOf($serializeCOROUTINE$0).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 2;
+          this.a9_1 = 1;
+          var this_0 = asFlow(this.m3j_1.s3j_1);
+          var tmp_0 = new _no_name_provided__qut3iv(this_0, this.n3j_1, this.o3j_1, this.p3j_1, this.q3j_1);
+          suspendResult = firstOrNull_0(tmp_0, KotlinxSerializationConverter$serialize$slambda_0(null), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var fromExtension = suspendResult;
+          if (!(fromExtension == null))
+            return fromExtension;
+          var tmp_1;
+          try {
+            tmp_1 = serializerForTypeInfo(this.m3j_1.r3j_1.a2v(), this.p3j_1);
+          } catch ($p) {
+            var tmp_2;
+            if ($p instanceof SerializationException) {
+              var cause = $p;
+              tmp_2 = guessSerializer(this.q3j_1, this.m3j_1.r3j_1.a2v());
+            } else {
+              throw $p;
+            }
+            tmp_1 = tmp_2;
+          }
+
+          var serializer = tmp_1;
+          return serializeContent(this.m3j_1, serializer, this.m3j_1.r3j_1, this.q3j_1, this.n3j_1, this.o3j_1);
+        case 2:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 2) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+function $deserializeCOROUTINE$1(_this__u8e3s4, charset, typeInfo, content, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.b3k_1 = _this__u8e3s4;
+  this.c3k_1 = charset;
+  this.d3k_1 = typeInfo;
+  this.e3k_1 = content;
+}
+protoOf($deserializeCOROUTINE$1).i9 = function () {
+  var suspendResult = this.c9_1;
+  $sm: do
+    try {
+      var tmp = this.a9_1;
+      switch (tmp) {
+        case 0:
+          this.b9_1 = 5;
+          this.a9_1 = 1;
+          var this_0 = asFlow(this.b3k_1.s3j_1);
+          var tmp_0 = new _no_name_provided__qut3iv_0(this_0, this.c3k_1, this.d3k_1, this.e3k_1);
+          suspendResult = firstOrNull_0(tmp_0, KotlinxSerializationConverter$deserialize$slambda_0(this.e3k_1, null), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.f3k_1 = suspendResult;
+          var tmp_1;
+          if (!this.b3k_1.s3j_1.h()) {
+            tmp_1 = !(this.f3k_1 == null) || this.e3k_1.l1l();
+          } else {
+            tmp_1 = false;
+          }
+
+          if (tmp_1)
+            return this.f3k_1;
+          this.g3k_1 = serializerForTypeInfo(this.b3k_1.r3j_1.a2v(), this.d3k_1);
+          this.a9_1 = 2;
+          suspendResult = this.e3k_1.p1s(VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          var contentPacket = suspendResult;
+          this.b9_1 = 3;
+          var tmp0_subject = this.b3k_1.r3j_1;
+          var tmp_2;
+          if (isInterface(tmp0_subject, StringFormat)) {
+            tmp_2 = this.b3k_1.r3j_1.z2u(this.g3k_1, readText(contentPacket, this.c3k_1));
+          } else {
+            if (isInterface(tmp0_subject, BinaryFormat)) {
+              tmp_2 = this.b3k_1.r3j_1.c2v(this.g3k_1, readBytes(contentPacket));
+            } else {
+              discard(contentPacket);
+              var message = 'Unsupported format ' + toString(this.b3k_1.r3j_1);
+              throw IllegalStateException_init_$Create$(toString(message));
+            }
+          }
+
+          return tmp_2;
+        case 3:
+          this.b9_1 = 5;
+          var tmp_3 = this.d9_1;
+          if (tmp_3 instanceof Error) {
+            var cause = this.d9_1;
+            throw new JsonConvertException('Illegal input: ' + cause.message, cause);
+          } else {
+            throw this.d9_1;
+          }
+
+        case 4:
+          this.b9_1 = 5;
+          return Unit_instance;
+        case 5:
+          throw this.d9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.b9_1 === 5) {
+        throw e;
+      } else {
+        this.a9_1 = this.b9_1;
+        this.d9_1 = e;
+      }
+    }
+   while (true);
+};
+function KotlinxSerializationConverter(format) {
+  this.r3j_1 = format;
+  this.s3j_1 = extensions(this.r3j_1);
+  // Inline function 'kotlin.require' call
+  var tmp;
+  var tmp_0 = this.r3j_1;
+  if (isInterface(tmp_0, BinaryFormat)) {
+    tmp = true;
+  } else {
+    var tmp_1 = this.r3j_1;
+    tmp = isInterface(tmp_1, StringFormat);
+  }
+  // Inline function 'kotlin.contracts.contract' call
+  if (!tmp) {
+    // Inline function 'io.ktor.serialization.kotlinx.KotlinxSerializationConverter.<anonymous>' call
+    var message = 'Only binary and string formats are supported, ' + toString(this.r3j_1) + ' is not supported.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(KotlinxSerializationConverter).h3k = function (contentType, charset, typeInfo, value, $completion) {
+  var tmp = new $serializeCOROUTINE$0(this, contentType, charset, typeInfo, value, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+protoOf(KotlinxSerializationConverter).k3g = function (contentType, charset, typeInfo, value, $completion) {
+  return this.h3k(contentType, charset, typeInfo, value, $completion);
+};
+protoOf(KotlinxSerializationConverter).w2s = function (charset, typeInfo, content, $completion) {
+  var tmp = new $deserializeCOROUTINE$1(this, charset, typeInfo, content, $completion);
+  tmp.c9_1 = Unit_instance;
+  tmp.d9_1 = null;
+  return tmp.i9();
+};
+function serializerForTypeInfo(_this__u8e3s4, typeInfo) {
+  var module_0 = _this__u8e3s4;
+  var tmp0_safe_receiver = typeInfo.z26_1;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'io.ktor.serialization.kotlinx.serializerForTypeInfo.<anonymous>' call
+    var tmp_0;
+    if (tmp0_safe_receiver.ab().h()) {
+      tmp_0 = null;
+    } else {
+      tmp_0 = serializerOrNull(module_0, tmp0_safe_receiver);
+    }
+    tmp = tmp_0;
+  }
+  var tmp2_elvis_lhs = tmp;
+  var tmp_1;
+  if (tmp2_elvis_lhs == null) {
+    var tmp1_safe_receiver = module_0.f2v(typeInfo.x26_1);
+    tmp_1 = tmp1_safe_receiver == null ? null : maybeNullable(tmp1_safe_receiver, typeInfo);
+  } else {
+    tmp_1 = tmp2_elvis_lhs;
+  }
+  var tmp3_elvis_lhs = tmp_1;
+  return tmp3_elvis_lhs == null ? maybeNullable(serializer(typeInfo.x26_1), typeInfo) : tmp3_elvis_lhs;
+}
+function guessSerializer(value, module_0) {
+  var tmp;
+  if (value == null) {
+    tmp = get_nullable(serializer_0(StringCompanionObject_instance));
+  } else {
+    if (!(value == null) ? isInterface(value, KtList) : false) {
+      tmp = ListSerializer(elementSerializer(value, module_0));
+    } else {
+      if (!(value == null) ? isArray(value) : false) {
+        var tmp1_safe_receiver = firstOrNull(value);
+        var tmp_0;
+        if (tmp1_safe_receiver == null) {
+          tmp_0 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          // Inline function 'kotlin.contracts.contract' call
+          // Inline function 'io.ktor.serialization.kotlinx.guessSerializer.<anonymous>' call
+          tmp_0 = guessSerializer(tmp1_safe_receiver, module_0);
+        }
+        var tmp2_elvis_lhs = tmp_0;
+        tmp = tmp2_elvis_lhs == null ? ListSerializer(serializer_0(StringCompanionObject_instance)) : tmp2_elvis_lhs;
+      } else {
+        if (!(value == null) ? isInterface(value, KtSet) : false) {
+          tmp = SetSerializer(elementSerializer(value, module_0));
+        } else {
+          if (!(value == null) ? isInterface(value, KtMap) : false) {
+            var keySerializer = elementSerializer(value.l2(), module_0);
+            var valueSerializer = elementSerializer(value.m2(), module_0);
+            tmp = MapSerializer(keySerializer, valueSerializer);
+          } else {
+            var tmp3_elvis_lhs = module_0.f2v(getKClassFromExpression(value));
+            tmp = tmp3_elvis_lhs == null ? serializer(getKClassFromExpression(value)) : tmp3_elvis_lhs;
+          }
+        }
+      }
+    }
+  }
+  var tmp_1 = tmp;
+  return isInterface(tmp_1, KSerializer) ? tmp_1 : THROW_CCE();
+}
+function maybeNullable(_this__u8e3s4, typeInfo) {
+  var tmp;
+  var tmp0_safe_receiver = typeInfo.z26_1;
+  if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.bb()) === true) {
+    tmp = get_nullable(_this__u8e3s4);
+  } else {
+    tmp = _this__u8e3s4;
+  }
+  return tmp;
+}
+function elementSerializer(_this__u8e3s4, module_0) {
+  // Inline function 'kotlin.collections.distinctBy' call
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = filterNotNull(_this__u8e3s4);
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var tmp0_iterator = this_0.p();
+  while (tmp0_iterator.q()) {
+    var item = tmp0_iterator.r();
+    // Inline function 'io.ktor.serialization.kotlinx.elementSerializer.<anonymous>' call
+    var tmp$ret$0 = guessSerializer(item, module_0);
+    destination.k(tmp$ret$0);
+  }
+  var set = HashSet_init_$Create$();
+  var list = ArrayList_init_$Create$();
+  var tmp0_iterator_0 = destination.p();
+  while (tmp0_iterator_0.q()) {
+    var e = tmp0_iterator_0.r();
+    // Inline function 'io.ktor.serialization.kotlinx.elementSerializer.<anonymous>' call
+    var key = e.x2t().x2u();
+    if (set.k(key)) {
+      list.k(e);
+    }
+  }
+  var serializers = list;
+  if (serializers.s() > 1) {
+    // Inline function 'kotlin.error' call
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(serializers, 10));
+    var tmp0_iterator_1 = serializers.p();
+    while (tmp0_iterator_1.q()) {
+      var item_0 = tmp0_iterator_1.r();
+      // Inline function 'io.ktor.serialization.kotlinx.elementSerializer.<anonymous>' call
+      var tmp$ret$5 = item_0.x2t().x2u();
+      destination_0.k(tmp$ret$5);
+    }
+    var message = 'Serializing collections of different element types is not yet supported. ' + ('Selected serializers: ' + toString(destination_0));
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+  var tmp0_elvis_lhs = singleOrNull(serializers);
+  var selected = tmp0_elvis_lhs == null ? serializer_0(StringCompanionObject_instance) : tmp0_elvis_lhs;
+  if (selected.x2t().i2v()) {
+    return selected;
+  }
+  if (!isInterface(selected, KSerializer))
+    THROW_CCE();
+  var tmp$ret$8;
+  $l$block_0: {
+    // Inline function 'kotlin.collections.any' call
+    var tmp;
+    if (isInterface(_this__u8e3s4, Collection)) {
+      tmp = _this__u8e3s4.h();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      tmp$ret$8 = false;
+      break $l$block_0;
+    }
+    var tmp0_iterator_2 = _this__u8e3s4.p();
+    while (tmp0_iterator_2.q()) {
+      var element = tmp0_iterator_2.r();
+      // Inline function 'io.ktor.serialization.kotlinx.elementSerializer.<anonymous>' call
+      if (element == null) {
+        tmp$ret$8 = true;
+        break $l$block_0;
+      }
+    }
+    tmp$ret$8 = false;
+  }
+  if (tmp$ret$8) {
+    return get_nullable(selected);
+  }
+  return selected;
+}
+function get_providers() {
+  return emptyList();
+}
+//region block: exports
+export {
+  serialization as serialization1fpeds7cruos4,
+};
+//endregion
+
+//# sourceMappingURL=ktor-ktor-shared-ktor-serialization-ktor-serialization-kotlinx.mjs.map