@solibo/home-api 1.1.9 → 1.1.10

package/ktor-ktor-serialization-kotlinx.mjs

@@ -0,0 +1,843 @@
+import {
+  ArrayList_init_$Create$1jemgvhi5v0js as ArrayList_init_$Create$,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  protoOf180f3jzyo7rfj as protoOf,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  VOID3gxj6tk5isa35 as VOID,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  isInterface3d6p8outrmvmk as isInterface,
+  equals2au1ep9vhcato as equals,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  hashCodeq5arwsb9dgti as hashCode,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression,
+  KtMap140uvy3s5zad8 as KtMap,
+  KtSetjrjc7fhfd6b9 as KtSet,
+  firstOrNull1gk7vzkf4h3nq as firstOrNull,
+  StringCompanionObject_instance3sox3h548pjra as StringCompanionObject_instance,
+  isArray1hxjqtqy632bc as isArray,
+  KtList3hktaavzmj137 as KtList,
+  filterNotNull3qfgcwmxhwfxe as filterNotNull,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3ivpeip4ouddx as ArrayList_init_$Create$_0,
+  HashSet_init_$Create$33p49hmosnvr4 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,
+  asFlow3ngsnn5xpz8pw as asFlow,
+  firstOrNull2i7tb1ukmw7gz as firstOrNull_0,
+} from './kotlinx-coroutines-core.mjs';
+import {
+  readRemaininghtnrfi4c8vp0 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-serialization.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForLambda(KotlinxSerializationConverter$serialize$o$collect$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($collectCOROUTINE$, CoroutineImpl);
+initMetadataForLambda(KotlinxSerializationConverter$deserialize$o$collect$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($collectCOROUTINE$_0, 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, VOID, [1]);
+initMetadataForLambda(KotlinxSerializationConverter$serialize$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForClass(KotlinxSerializationConverter$deserialize$$inlined$map$1, VOID, VOID, VOID, VOID, [1]);
+initMetadataForLambda(KotlinxSerializationConverter$deserialize$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($serializeCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($deserializeCOROUTINE$, 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.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    var tmp0_safe_receiver = element.l4z(format);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      destination.e1(tmp0_safe_receiver);
+    }
+  }
+  return destination;
+}
+function serialization(_this__u8e3s4, contentType, format) {
+  _this__u8e3s4.u3a(contentType, new KotlinxSerializationConverter(format));
+}
+function KotlinxSerializationConverter$serialize$o$collect$slambda($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value, resultContinuation) {
+  this.u4z_1 = $$this$unsafeFlow;
+  this.v4z_1 = $contentType;
+  this.w4z_1 = $charset;
+  this.x4z_1 = $typeInfo;
+  this.y4z_1 = $value;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).k3b = function (value, $completion) {
+  var tmp = this.l3b(value, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).d9 = function (p1, $completion) {
+  return this.k3b((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          var tmp0 = this.u4z_1;
+          var tmp2 = this.z4z_1;
+          this.a50_1 = tmp0;
+          this.j8_1 = 1;
+          suspendResult = tmp2.g4o(this.v4z_1, this.w4z_1, this.x4z_1, this.y4z_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          this.j8_1 = 2;
+          suspendResult = this.a50_1.d1b(ARGUMENT, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$serialize$o$collect$slambda).l3b = function (value, completion) {
+  var i = new KotlinxSerializationConverter$serialize$o$collect$slambda(this.u4z_1, this.v4z_1, this.w4z_1, this.x4z_1, this.y4z_1, completion);
+  i.z4z_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.k3b(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.j50_1 = _this__u8e3s4;
+  this.k50_1 = collector;
+}
+protoOf($collectCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 2;
+          var $this$unsafeFlow = this.k50_1;
+          this.j8_1 = 1;
+          var tmp_0 = KotlinxSerializationConverter$serialize$o$collect$slambda_0($this$unsafeFlow, this.j50_1.m50_1, this.j50_1.n50_1, this.j50_1.o50_1, this.j50_1.p50_1, null);
+          suspendResult = this.j50_1.l50_1.f1b(new sam$kotlinx_coroutines_flow_FlowCollector$0(tmp_0), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return Unit_instance;
+        case 2:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 2) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function KotlinxSerializationConverter$deserialize$o$collect$slambda($$this$unsafeFlow, $charset, $typeInfo, $content, resultContinuation) {
+  this.y50_1 = $$this$unsafeFlow;
+  this.z50_1 = $charset;
+  this.a51_1 = $typeInfo;
+  this.b51_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).k3b = function (value, $completion) {
+  var tmp = this.l3b(value, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).d9 = function (p1, $completion) {
+  return this.k3b((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 3;
+          var tmp0 = this.y50_1;
+          var tmp2 = this.c51_1;
+          this.d51_1 = tmp0;
+          this.j8_1 = 1;
+          suspendResult = tmp2.m3b(this.z50_1, this.a51_1, this.b51_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          this.j8_1 = 2;
+          suspendResult = this.d51_1.d1b(ARGUMENT, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 3) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$deserialize$o$collect$slambda).l3b = function (value, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$o$collect$slambda(this.y50_1, this.z50_1, this.a51_1, this.b51_1, completion);
+  i.c51_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.k3b(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $collectCOROUTINE$_0(_this__u8e3s4, collector, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.m51_1 = _this__u8e3s4;
+  this.n51_1 = collector;
+}
+protoOf($collectCOROUTINE$_0).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 2;
+          var $this$unsafeFlow = this.n51_1;
+          this.j8_1 = 1;
+          var tmp_0 = KotlinxSerializationConverter$deserialize$o$collect$slambda_0($this$unsafeFlow, this.m51_1.p51_1, this.m51_1.q51_1, this.m51_1.r51_1, null);
+          suspendResult = this.m51_1.o51_1.f1b(new sam$kotlinx_coroutines_flow_FlowCollector$0_0(tmp_0), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return Unit_instance;
+        case 2:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 2) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function serializeContent($this, serializer, format, value, contentType, charset) {
+  var tmp;
+  if (isInterface(format, StringFormat)) {
+    var content = format.c1t(isInterface(serializer, KSerializer) ? serializer : THROW_CCE(), value);
+    tmp = new TextContent(content, withCharsetIfNeeded(contentType, charset));
+  } else {
+    if (isInterface(format, BinaryFormat)) {
+      var content_0 = format.e1t(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.s51_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).d1b = function (value, $completion) {
+  return this.s51_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).g3 = function () {
+  return this.s51_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.g3(), other.g3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0).hashCode = function () {
+  return hashCode(this.g3());
+};
+function sam$kotlinx_coroutines_flow_FlowCollector$0_0(function_0) {
+  this.t51_1 = function_0;
+}
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).d1b = function (value, $completion) {
+  return this.t51_1(value, $completion);
+};
+protoOf(sam$kotlinx_coroutines_flow_FlowCollector$0_0).g3 = function () {
+  return this.t51_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.g3(), other.g3());
+    } 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.g3());
+};
+function KotlinxSerializationConverter$serialize$$inlined$map$1($this, $contentType, $charset, $typeInfo, $value) {
+  this.l50_1 = $this;
+  this.m50_1 = $contentType;
+  this.n50_1 = $charset;
+  this.o50_1 = $typeInfo;
+  this.p50_1 = $value;
+}
+protoOf(KotlinxSerializationConverter$serialize$$inlined$map$1).e1b = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$(this, collector, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$serialize$$inlined$map$1).f1b = function (collector, $completion) {
+  return this.e1b(collector, $completion);
+};
+function KotlinxSerializationConverter$serialize$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$serialize$slambda).d52 = function (it, $completion) {
+  var tmp = this.e52(it, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).d9 = function (p1, $completion) {
+  return this.d52((p1 == null ? true : p1 instanceof OutgoingContent) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      if (tmp === 0) {
+        this.k8_1 = 1;
+        return !(this.c52_1 == null);
+      } else if (tmp === 1) {
+        throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$serialize$slambda).e52 = function (it, completion) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(completion);
+  i.c52_1 = it;
+  return i;
+};
+function KotlinxSerializationConverter$serialize$slambda_0(resultContinuation) {
+  var i = new KotlinxSerializationConverter$serialize$slambda(resultContinuation);
+  var l = function (it, $completion) {
+    return i.d52(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function KotlinxSerializationConverter$deserialize$$inlined$map$1($this, $charset, $typeInfo, $content) {
+  this.o51_1 = $this;
+  this.p51_1 = $charset;
+  this.q51_1 = $typeInfo;
+  this.r51_1 = $content;
+}
+protoOf(KotlinxSerializationConverter$deserialize$$inlined$map$1).e1b = function (collector, $completion) {
+  var tmp = new $collectCOROUTINE$_0(this, collector, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$deserialize$$inlined$map$1).f1b = function (collector, $completion) {
+  return this.e1b(collector, $completion);
+};
+function KotlinxSerializationConverter$deserialize$slambda($content, resultContinuation) {
+  this.n52_1 = $content;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(KotlinxSerializationConverter$deserialize$slambda).l3c = function (it, $completion) {
+  var tmp = this.l3b(it, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).d9 = function (p1, $completion) {
+  return this.l3c((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      if (tmp === 0) {
+        this.k8_1 = 1;
+        return !(this.o52_1 == null) || this.n52_1.z1g();
+      } else if (tmp === 1) {
+        throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(KotlinxSerializationConverter$deserialize$slambda).l3b = function (it, completion) {
+  var i = new KotlinxSerializationConverter$deserialize$slambda(this.n52_1, completion);
+  i.o52_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.l3c(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $serializeCOROUTINE$(_this__u8e3s4, contentType, charset, typeInfo, value, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.x52_1 = _this__u8e3s4;
+  this.y52_1 = contentType;
+  this.z52_1 = charset;
+  this.a53_1 = typeInfo;
+  this.b53_1 = value;
+}
+protoOf($serializeCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 2;
+          this.j8_1 = 1;
+          var this_0 = asFlow(this.x52_1.d53_1);
+          var tmp_0 = new KotlinxSerializationConverter$serialize$$inlined$map$1(this_0, this.y52_1, this.z52_1, this.a53_1, this.b53_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.x52_1.c53_1.c1w(), this.a53_1);
+          } catch ($p) {
+            var tmp_2;
+            if ($p instanceof SerializationException) {
+              var cause = $p;
+              tmp_2 = guessSerializer(this.b53_1, this.x52_1.c53_1.c1w());
+            } else {
+              throw $p;
+            }
+            tmp_1 = tmp_2;
+          }
+
+          var serializer = tmp_1;
+          return serializeContent(this.x52_1, serializer, this.x52_1.c53_1, this.b53_1, this.y52_1, this.z52_1);
+        case 2:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 2) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function $deserializeCOROUTINE$(_this__u8e3s4, charset, typeInfo, content, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.m53_1 = _this__u8e3s4;
+  this.n53_1 = charset;
+  this.o53_1 = typeInfo;
+  this.p53_1 = content;
+}
+protoOf($deserializeCOROUTINE$).r8 = function () {
+  var suspendResult = this.l8_1;
+  $sm: do
+    try {
+      var tmp = this.j8_1;
+      switch (tmp) {
+        case 0:
+          this.k8_1 = 4;
+          this.j8_1 = 1;
+          var this_0 = asFlow(this.m53_1.d53_1);
+          var tmp_0 = new KotlinxSerializationConverter$deserialize$$inlined$map$1(this_0, this.n53_1, this.o53_1, this.p53_1);
+          suspendResult = firstOrNull_0(tmp_0, KotlinxSerializationConverter$deserialize$slambda_0(this.p53_1, null), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var fromExtension = suspendResult;
+          var tmp_1;
+          if (!this.m53_1.d53_1.r()) {
+            tmp_1 = !(fromExtension == null) || this.p53_1.z1g();
+          } else {
+            tmp_1 = false;
+          }
+
+          if (tmp_1)
+            return fromExtension;
+          this.q53_1 = serializerForTypeInfo(this.m53_1.c53_1.c1w(), this.o53_1);
+          this.j8_1 = 2;
+          suspendResult = readRemaining(this.p53_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          var contentPacket = suspendResult;
+          this.k8_1 = 3;
+          var tmp0_subject = this.m53_1.c53_1;
+          var tmp_2;
+          if (isInterface(tmp0_subject, StringFormat)) {
+            tmp_2 = this.m53_1.c53_1.d1t(this.q53_1, readText(contentPacket, this.n53_1));
+          } else {
+            if (isInterface(tmp0_subject, BinaryFormat)) {
+              tmp_2 = this.m53_1.c53_1.f1t(this.q53_1, readByteArray(contentPacket));
+            } else {
+              discard(contentPacket);
+              var message = 'Unsupported format ' + toString(this.m53_1.c53_1);
+              throw IllegalStateException_init_$Create$(toString(message));
+            }
+          }
+
+          return tmp_2;
+        case 3:
+          this.k8_1 = 4;
+          var tmp_3 = this.m8_1;
+          if (tmp_3 instanceof Error) {
+            var cause = this.m8_1;
+            throw new JsonConvertException('Illegal input: ' + cause.message, cause);
+          } else {
+            throw this.m8_1;
+          }
+
+        case 4:
+          throw this.m8_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k8_1 === 4) {
+        throw e;
+      } else {
+        this.j8_1 = this.k8_1;
+        this.m8_1 = e;
+      }
+    }
+   while (true);
+};
+function KotlinxSerializationConverter(format) {
+  this.c53_1 = format;
+  this.d53_1 = extensions(this.c53_1);
+  var tmp;
+  var tmp_0 = this.c53_1;
+  if (isInterface(tmp_0, BinaryFormat)) {
+    tmp = true;
+  } else {
+    var tmp_1 = this.c53_1;
+    tmp = isInterface(tmp_1, StringFormat);
+  }
+  // Inline function 'kotlin.require' call
+  if (!tmp) {
+    var message = 'Only binary and string formats are supported, ' + toString(this.c53_1) + ' is not supported.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(KotlinxSerializationConverter).r53 = function (contentType, charset, typeInfo, value, $completion) {
+  var tmp = new $serializeCOROUTINE$(this, contentType, charset, typeInfo, value, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+protoOf(KotlinxSerializationConverter).g4o = function (contentType, charset, typeInfo, value, $completion) {
+  return this.r53(contentType, charset, typeInfo, value, $completion);
+};
+protoOf(KotlinxSerializationConverter).m3b = function (charset, typeInfo, content, $completion) {
+  var tmp = new $deserializeCOROUTINE$(this, charset, typeInfo, content, $completion);
+  tmp.l8_1 = Unit_instance;
+  tmp.m8_1 = null;
+  return tmp.r8();
+};
+function serializerForTypeInfo(_this__u8e3s4, typeInfo) {
+  var module_0 = _this__u8e3s4;
+  var tmp0_safe_receiver = typeInfo.l2i_1;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    var tmp_0;
+    if (tmp0_safe_receiver.k().r()) {
+      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.j1t(typeInfo.k2i_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.k2i_1), typeInfo) : tmp3_elvis_lhs;
+}
+function guessSerializer(value, module_0) {
+  var tmp;
+  if (value == null) {
+    tmp = get_nullable(serializer_0(StringCompanionObject_instance));
+  } else {
+    if (isInterface(value, KtList)) {
+      tmp = ListSerializer(elementSerializer(value, module_0));
+    } else {
+      if (isArray(value)) {
+        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 (isInterface(value, KtSet)) {
+          tmp = SetSerializer(elementSerializer(value, module_0));
+        } else {
+          if (isInterface(value, KtMap)) {
+            var keySerializer = elementSerializer(value.v2(), module_0);
+            var valueSerializer = elementSerializer(value.w2(), module_0);
+            tmp = MapSerializer(keySerializer, valueSerializer);
+          } else {
+            var tmp3_elvis_lhs = module_0.j1t(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.l2i_1;
+  if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.l()) === 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.t();
+  while (_iterator__ex2g4s.u()) {
+    var item = _iterator__ex2g4s.v();
+    var tmp$ret$0 = guessSerializer(item, module_0);
+    destination.e1(tmp$ret$0);
+  }
+  // Inline function 'kotlin.collections.distinctBy' call
+  var set = HashSet_init_$Create$();
+  var list = ArrayList_init_$Create$();
+  var _iterator__ex2g4s_0 = destination.t();
+  while (_iterator__ex2g4s_0.u()) {
+    var e = _iterator__ex2g4s_0.v();
+    var key = e.z1r().a1t();
+    if (set.e1(key)) {
+      list.e1(e);
+    }
+  }
+  var serializers = list;
+  if (serializers.g1() > 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.t();
+    while (_iterator__ex2g4s_1.u()) {
+      var item_0 = _iterator__ex2g4s_1.v();
+      var tmp$ret$5 = item_0.z1r().a1t();
+      destination_0.e1(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.z1r().n1t()) {
+    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.r();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      tmp$ret$8 = false;
+      break $l$block_0;
+    }
+    var _iterator__ex2g4s_2 = _this__u8e3s4.t();
+    while (_iterator__ex2g4s_2.u()) {
+      var element = _iterator__ex2g4s_2.v();
+      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-serialization-kotlinx.mjs.map