@icure/cardinal-sdk 0.0.0-unspecified

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

@@ -0,0 +1,860 @@
+import {
+  ArrayList_init_$Create$2qnngtk1et9r9 as ArrayList_init_$Create$,
+  Unit_instance104q5opgivhr8 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$3ib9qa3pip8n4 as IllegalStateException_init_$Create$,
+  isInterface3d6p8outrmvmk as isInterface,
+  equals2au1ep9vhcato as equals,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  hashCodeq5arwsb9dgti as hashCode,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  IllegalArgumentException_init_$Create$310sysrobvll9 as IllegalArgumentException_init_$Create$,
+  getKClassFromExpression3vpejubogshaw as getKClassFromExpression,
+  KtMap140uvy3s5zad8 as KtMap,
+  KtSetjrjc7fhfd6b9 as KtSet,
+  firstOrNull1gk7vzkf4h3nq as firstOrNull,
+  StringCompanionObject_instance2odz3s3zbrixa as StringCompanionObject_instance,
+  isArray1hxjqtqy632bc as isArray,
+  KtList3hktaavzmj137 as KtList,
+  filterNotNull3qfgcwmxhwfxe as filterNotNull,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$1s1wkrw82c0iw as ArrayList_init_$Create$_0,
+  HashSet_init_$Create$1urd5csbv51lq 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 {
+  readRemaining33cdmbznvdvtg as readRemaining,
+  discard3ugntd47xyll6 as discard,
+  readText27783kyxjxi1g as readText,
+} from './ktor-ktor-io.mjs';
+import { readByteArray1ri21h2rciakw as readByteArray } from './kotlinx-io-kotlinx-io-core.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(KotlinxSerializationConverter$serialize$$inlined$map$1, VOID, VOID, VOID, [Flow], [1]);
+initMetadataForLambda(KotlinxSerializationConverter$serialize$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForClass(KotlinxSerializationConverter$deserialize$$inlined$map$1, 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
+  var tmp0 = get_providers();
+  // Inline function 'kotlin.collections.mapNotNullTo' call
+  var destination = ArrayList_init_$Create$();
+  // Inline function 'kotlin.collections.forEach' call
+  var _iterator__ex2g4s = tmp0.p();
+  while (_iterator__ex2g4s.q()) {
+    var element = _iterator__ex2g4s.r();
+    var tmp0_safe_receiver = element.b4y(format);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      destination.k(tmp0_safe_receiver);
+    }
+  }
+  return destination;
+}
+function serialization(_this__u8e3s4, contentType, format) {
+  _this__u8e3s4.s3j(contentType, new KotlinxSerializationConverter(format));
+}
+function KotlinxSerializationConverter$serialize$o$collect$slambda($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value, resultContinuation) {
+  this.k4y_1 = $$this$unsafeFlow;
+  this.l4y_1 = $contentType;
+  this.m4y_1 = $charset;
+  this.n4y_1 = $typeInfo;
+  this.o4y_1 = $value;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).o3k = function (value, $completion) {
+  var tmp = this.p3k(value, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).fa = function (p1, $completion) {
+  return this.o3k((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          var tmp_0 = this;
+          tmp_0.q4y_1 = this.k4y_1;
+          var tmp_1 = this;
+          tmp_1.r4y_1 = this.p4y_1;
+          this.s4y_1 = this.q4y_1;
+          this.t4y_1 = this.r4y_1;
+          var tmp_2 = this;
+          tmp_2.u4y_1 = this.t4y_1;
+          this.v4y_1 = this.u4y_1;
+          this.j9_1 = 1;
+          suspendResult = this.v4y_1.a4y(this.l4y_1, this.m4y_1, this.n4y_1, this.o4y_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.w4y_1 = suspendResult;
+          this.j9_1 = 2;
+          suspendResult = this.s4y_1.g1b(this.w4y_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        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);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).p3k = function (value, completion) {
+  var i = new KotlinxSerializationConverter$serialize$o$collect$slambda(this.k4y_1, this.l4y_1, this.m4y_1, this.n4y_1, this.o4y_1, completion);
+  i.p4y_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.o3k(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$2(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.f4z_1 = _this__u8e3s4;
+  this.g4z_1 = collector;
+}
+protoOf($collectCOROUTINE$2).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          var tmp_0 = this;
+          tmp_0.h4z_1 = this.g4z_1;
+          this.i4z_1 = this.h4z_1;
+          this.j9_1 = 1;
+          var tmp_1 = KotlinxSerializationConverter$serialize$o$collect$slambda_0(this.i4z_1, this.f4z_1.k4z_1, this.f4z_1.l4z_1, this.f4z_1.m4z_1, this.f4z_1.n4z_1, null);
+          suspendResult = this.f4z_1.j4z_1.m1a(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.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 KotlinxSerializationConverter$deserialize$o$collect$slambda($$this$unsafeFlow, $charset, $typeInfo, $content, resultContinuation) {
+  this.w4z_1 = $$this$unsafeFlow;
+  this.x4z_1 = $charset;
+  this.y4z_1 = $typeInfo;
+  this.z4z_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).o3k = function (value, $completion) {
+  var tmp = this.p3k(value, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).fa = function (p1, $completion) {
+  return this.o3k((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          var tmp_0 = this;
+          tmp_0.b50_1 = this.w4z_1;
+          var tmp_1 = this;
+          tmp_1.c50_1 = this.a50_1;
+          this.d50_1 = this.b50_1;
+          this.e50_1 = this.c50_1;
+          var tmp_2 = this;
+          tmp_2.f50_1 = this.e50_1;
+          this.g50_1 = this.f50_1;
+          this.j9_1 = 1;
+          suspendResult = this.g50_1.q3k(this.x4z_1, this.y4z_1, this.z4z_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.h50_1 = suspendResult;
+          this.j9_1 = 2;
+          suspendResult = this.d50_1.g1b(this.h50_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        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);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).p3k = function (value, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$o$collect$slambda(this.w4z_1, this.x4z_1, this.y4z_1, this.z4z_1, completion);
+  i.a50_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.o3k(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$3(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.q50_1 = _this__u8e3s4;
+  this.r50_1 = collector;
+}
+protoOf($collectCOROUTINE$3).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 2;
+          var tmp_0 = this;
+          tmp_0.s50_1 = this.r50_1;
+          this.t50_1 = this.s50_1;
+          this.j9_1 = 1;
+          var tmp_1 = KotlinxSerializationConverter$deserialize$o$collect$slambda_0(this.t50_1, this.q50_1.v50_1, this.q50_1.w50_1, this.q50_1.x50_1, null);
+          suspendResult = this.q50_1.u50_1.m1a(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.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 serializeContent($this, serializer, format, value, contentType, charset) {
+  var tmp;
+  if (isInterface(format, StringFormat)) {
+    var content = format.c21(isInterface(serializer, KSerializer) ? serializer : THROW_CCE(), value);
+    tmp = new TextContent(content, withCharsetIfNeeded(contentType, charset));
+  } else {
+    if (isInterface(format, BinaryFormat)) {
+      var content_0 = format.e21(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.y50_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).g1b = function (value, $completion) {
+  return this.y50_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).u3 = function () {
+  return this.y50_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.u3(), other.u3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).hashCode = function () {
+  return hashCode(this.u3());
+};
+function sam$kotlinx_coroutines_flow_FlowCollector$0_0(function_0) {
+  this.z50_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).g1b = function (value, $completion) {
+  return this.z50_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).u3 = function () {
+  return this.z50_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.u3(), other.u3());
+    } 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.u3());
+};
+function KotlinxSerializationConverter$serialize$$inlined$map$1($this, $contentType, $charset, $typeInfo, $value) {
+  this.j4z_1 = $this;
+  this.k4z_1 = $contentType;
+  this.l4z_1 = $charset;
+  this.m4z_1 = $typeInfo;
+  this.n4z_1 = $value;
+}
+protoOf(KotlinxSerializationConverter$serialize$$inlined$map$1).h1b = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$2(this, collector, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$serialize$$inlined$map$1).m1a = function (collector, $completion) {
+  return this.h1b(collector, $completion);
+};
+function KotlinxSerializationConverter$serialize$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$slambda).j51 = function (it, $completion) {
+  var tmp = this.k51(it, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).fa = function (p1, $completion) {
+  return this.j51((p1 == null ? true : p1 instanceof OutgoingContent) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      if (tmp === 0) {
+        this.k9_1 = 1;
+        return !(this.i51_1 == null);
+      } else if (tmp === 1) {
+        throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).k51 = function (it, completion) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(completion);
+  i.i51_1 = it;
+  return i;
+};
+function KotlinxSerializationConverter$serialize$slambda_0(resultContinuation) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(resultContinuation);
+  var l = function (it, $completion) {
+    return i.j51(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function KotlinxSerializationConverter$deserialize$$inlined$map$1($this, $charset, $typeInfo, $content) {
+  this.u50_1 = $this;
+  this.v50_1 = $charset;
+  this.w50_1 = $typeInfo;
+  this.x50_1 = $content;
+}
+protoOf(KotlinxSerializationConverter$deserialize$$inlined$map$1).h1b = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$3(this, collector, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$deserialize$$inlined$map$1).m1a = function (collector, $completion) {
+  return this.h1b(collector, $completion);
+};
+function KotlinxSerializationConverter$deserialize$slambda($content, resultContinuation) {
+  this.t51_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$slambda).r3l = function (it, $completion) {
+  var tmp = this.p3k(it, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).fa = function (p1, $completion) {
+  return this.r3l((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      if (tmp === 0) {
+        this.k9_1 = 1;
+        return !(this.u51_1 == null) || this.t51_1.i1p();
+      } else if (tmp === 1) {
+        throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).p3k = function (it, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$slambda(this.t51_1, completion);
+  i.u51_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.r3l(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $serializeCOROUTINE$0(_this__u8e3s4, contentType, charset, typeInfo, value, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.d52_1 = _this__u8e3s4;
+  this.e52_1 = contentType;
+  this.f52_1 = charset;
+  this.g52_1 = typeInfo;
+  this.h52_1 = value;
+}
+protoOf($serializeCOROUTINE$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.j9_1 = 1;
+          var this_0 = asFlow(this.d52_1.j52_1);
+          var tmp_0 = new KotlinxSerializationConverter$serialize$$inlined$map$1(this_0, this.e52_1, this.f52_1, this.g52_1, this.h52_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.d52_1.i52_1.c24(), this.g52_1);
+          } catch ($p) {
+            var tmp_2;
+            if ($p instanceof SerializationException) {
+              var cause = $p;
+              tmp_2 = guessSerializer(this.h52_1, this.d52_1.i52_1.c24());
+            } else {
+              throw $p;
+            }
+            tmp_1 = tmp_2;
+          }
+
+          var serializer = tmp_1;
+          return serializeContent(this.d52_1, serializer, this.d52_1.i52_1, this.h52_1, this.e52_1, this.f52_1);
+        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 $deserializeCOROUTINE$1(_this__u8e3s4, charset, typeInfo, content, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.s52_1 = _this__u8e3s4;
+  this.t52_1 = charset;
+  this.u52_1 = typeInfo;
+  this.v52_1 = content;
+}
+protoOf($deserializeCOROUTINE$1).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 4;
+          this.j9_1 = 1;
+          var this_0 = asFlow(this.s52_1.j52_1);
+          var tmp_0 = new KotlinxSerializationConverter$deserialize$$inlined$map$1(this_0, this.t52_1, this.u52_1, this.v52_1);
+          suspendResult = firstOrNull_0(tmp_0, KotlinxSerializationConverter$deserialize$slambda_0(this.v52_1, null), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.w52_1 = suspendResult;
+          var tmp_1;
+          if (!this.s52_1.j52_1.h()) {
+            tmp_1 = !(this.w52_1 == null) || this.v52_1.i1p();
+          } else {
+            tmp_1 = false;
+          }
+
+          if (tmp_1)
+            return this.w52_1;
+          this.x52_1 = serializerForTypeInfo(this.s52_1.i52_1.c24(), this.u52_1);
+          this.j9_1 = 2;
+          suspendResult = readRemaining(this.v52_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          var contentPacket = suspendResult;
+          this.k9_1 = 3;
+          var tmp0_subject = this.s52_1.i52_1;
+          var tmp_2;
+          if (isInterface(tmp0_subject, StringFormat)) {
+            tmp_2 = this.s52_1.i52_1.d21(this.x52_1, readText(contentPacket, this.t52_1));
+          } else {
+            if (isInterface(tmp0_subject, BinaryFormat)) {
+              tmp_2 = this.s52_1.i52_1.f21(this.x52_1, readByteArray(contentPacket));
+            } else {
+              discard(contentPacket);
+              var message = 'Unsupported format ' + toString(this.s52_1.i52_1);
+              throw IllegalStateException_init_$Create$(toString(message));
+            }
+          }
+
+          return tmp_2;
+        case 3:
+          this.k9_1 = 4;
+          var tmp_3 = this.m9_1;
+          if (tmp_3 instanceof Error) {
+            var cause = this.m9_1;
+            throw new JsonConvertException('Illegal input: ' + cause.message, cause);
+          } else {
+            throw this.m9_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 KotlinxSerializationConverter(format) {
+  this.i52_1 = format;
+  this.j52_1 = extensions(this.i52_1);
+  var tmp;
+  var tmp_0 = this.i52_1;
+  if (isInterface(tmp_0, BinaryFormat)) {
+    tmp = true;
+  } else {
+    var tmp_1 = this.i52_1;
+    tmp = isInterface(tmp_1, StringFormat);
+  }
+  // Inline function 'kotlin.require' call
+  if (!tmp) {
+    var message = 'Only binary and string formats are supported, ' + toString(this.i52_1) + ' is not supported.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(KotlinxSerializationConverter).y52 = function (contentType, charset, typeInfo, value, $completion) {
+  var tmp = new $serializeCOROUTINE$0(this, contentType, charset, typeInfo, value, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(KotlinxSerializationConverter).a4y = function (contentType, charset, typeInfo, value, $completion) {
+  return this.y52(contentType, charset, typeInfo, value, $completion);
+};
+protoOf(KotlinxSerializationConverter).q3k = function (charset, typeInfo, content, $completion) {
+  var tmp = new $deserializeCOROUTINE$1(this, charset, typeInfo, content, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+function serializerForTypeInfo(_this__u8e3s4, typeInfo) {
+  var module_0 = _this__u8e3s4;
+  var tmp0_safe_receiver = typeInfo.x2r_1;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    var tmp_0;
+    if (tmp0_safe_receiver.hc().h()) {
+      tmp_0 = null;
+    } else {
+      tmp_0 = serializerOrNull(module_0, tmp0_safe_receiver);
+    }
+    tmp = tmp_0;
+  }
+  var tmp1_elvis_lhs = tmp;
+  var tmp_1;
+  if (tmp1_elvis_lhs == null) {
+    var tmp2_safe_receiver = module_0.i21(typeInfo.w2r_1);
+    tmp_1 = tmp2_safe_receiver == null ? null : maybeNullable(tmp2_safe_receiver, typeInfo);
+  } else {
+    tmp_1 = tmp1_elvis_lhs;
+  }
+  var tmp3_elvis_lhs = tmp_1;
+  return tmp3_elvis_lhs == null ? maybeNullable(serializer(typeInfo.w2r_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
+          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.p2(), module_0);
+            var valueSerializer = elementSerializer(value.q2(), module_0);
+            tmp = MapSerializer(keySerializer, valueSerializer);
+          } else {
+            var tmp3_elvis_lhs = module_0.i21(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.x2r_1;
+  if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.ic()) === true) {
+    tmp = get_nullable(_this__u8e3s4);
+  } else {
+    tmp = _this__u8e3s4;
+  }
+  return tmp;
+}
+function elementSerializer(_this__u8e3s4, module_0) {
+  // 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 _iterator__ex2g4s = this_0.p();
+  while (_iterator__ex2g4s.q()) {
+    var item = _iterator__ex2g4s.r();
+    var tmp$ret$0 = guessSerializer(item, module_0);
+    destination.k(tmp$ret$0);
+  }
+  // Inline function 'kotlin.collections.distinctBy' call
+  var set = HashSet_init_$Create$();
+  var list = ArrayList_init_$Create$();
+  var _iterator__ex2g4s_0 = destination.p();
+  while (_iterator__ex2g4s_0.q()) {
+    var e = _iterator__ex2g4s_0.r();
+    var key = e.b20().b21();
+    if (set.k(key)) {
+      list.k(e);
+    }
+  }
+  var serializers = list;
+  if (serializers.s() > 1) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(serializers, 10));
+    var _iterator__ex2g4s_1 = serializers.p();
+    while (_iterator__ex2g4s_1.q()) {
+      var item_0 = _iterator__ex2g4s_1.r();
+      var tmp$ret$5 = item_0.b20().b21();
+      destination_0.k(tmp$ret$5);
+    }
+    // Inline function 'kotlin.error' call
+    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.b20().m21()) {
+    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 _iterator__ex2g4s_2 = _this__u8e3s4.p();
+    while (_iterator__ex2g4s_2.q()) {
+      var element = _iterator__ex2g4s_2.r();
+      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