@continuous-excellence/coupling-cli 0.0.0

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/KotlinxSerializationConverter.mjs

@@ -0,0 +1,442 @@
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { asFlow3ngsnn5xpz8pw as asFlow } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Builders.mjs';
+import { firstOrNull2i7tb1ukmw7gz as firstOrNull } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Reduce.mjs';
+import {
+  serializerForTypeInfofg753n9o7cfi as serializerForTypeInfo,
+  guessSerializerlivkaydavxr9 as guessSerializer,
+} from './SerializerLookup.mjs';
+import { SerializationExceptioneqrdve3ts2n9 as SerializationException } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerializationExceptions.mjs';
+import { readRemaininghtnrfi4c8vp0 as readRemaining } from '../../../../../ktor-ktor-io/io/ktor/utils/io/ByteReadChannelOperations.mjs';
+import { discard3ugntd47xyll6 as discard } from '../../../../../ktor-ktor-io/io/ktor/utils/io/core/ByteReadPacket.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { readByteArray1ri21h2rciakw as readByteArray } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
+import {
+  BinaryFormat3f3aelhmz0ro1 as BinaryFormat,
+  StringFormat2r2ka8mzcb3mi as StringFormat,
+} from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerialFormat.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { readText27783kyxjxi1g as readText } from '../../../../../ktor-ktor-io/io/ktor/utils/io/core/Strings.mjs';
+import { JsonConvertExceptiongnc5x6xwaf77 as JsonConvertException } from '../../../../../ktor-ktor-serialization/io/ktor/serialization/ContentConvertException.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { ByteArrayContent9zol65b22hp0 as ByteArrayContent } from '../../../../../ktor-ktor-http/io/ktor/http/content/ByteArrayContent.mjs';
+import { withCharsetIfNeeded3sz33ys0x9vfx as withCharsetIfNeeded } from '../../../../../ktor-ktor-http/io/ktor/http/ContentTypes.mjs';
+import { TextContent1rb6ftlpvl1d2 as TextContent } from '../../../../../ktor-ktor-http/io/ktor/http/content/TextContent.mjs';
+import { FunctionAdapter3lcrrz3moet5b as FunctionAdapter } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/FunctionAdapter.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/FlowCollector.mjs';
+import { OutgoingContent3t2ohmyam9o76 as OutgoingContent } from '../../../../../ktor-ktor-http/io/ktor/http/content/OutgoingContent.mjs';
+import { extensionsocv2ha4uem50 as extensions } from './Extensions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function serialization(_this__u8e3s4, contentType, format) {
+  _this__u8e3s4.i3a(contentType, new (KotlinxSerializationConverter())(format));
+}
+function *_generator_invoke__zhh2q8($this, value, $completion) {
+  var $this$transform = $this.a48_1;
+  var tmp = value.q3w($this.b48_1, $this.c48_1, $this.d48_1, $this.e48_1, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp$ret$0 = tmp;
+  var tmp_0 = $this$transform.p1e(tmp$ret$0, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return Unit_instance;
+}
+function *_generator_collect__dlomyy($this, collector, $completion) {
+  var tmp = KotlinxSerializationConverter$serialize$o$collect$slambda_0(collector, $this.g48_1, $this.h48_1, $this.i48_1, $this.j48_1);
+  var tmp_0 = $this.f48_1.y1d(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return Unit_instance;
+}
+var KotlinxSerializationConverter$serialize$o$collect$slambdaClass;
+function KotlinxSerializationConverter$serialize$o$collect$slambda() {
+  if (KotlinxSerializationConverter$serialize$o$collect$slambdaClass === VOID) {
+    class $ {
+      constructor($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value) {
+        this.a48_1 = $$this$unsafeFlow;
+        this.b48_1 = $contentType;
+        this.c48_1 = $charset;
+        this.d48_1 = $typeInfo;
+        this.e48_1 = $value;
+      }
+      y1i(value, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, value), $completion);
+      }
+      de(p1, $completion) {
+        return this.y1i((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    KotlinxSerializationConverter$serialize$o$collect$slambdaClass = $;
+  }
+  return KotlinxSerializationConverter$serialize$o$collect$slambdaClass;
+}
+function KotlinxSerializationConverter$serialize$o$collect$slambda_0($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value) {
+  var i = new (KotlinxSerializationConverter$serialize$o$collect$slambda())($$this$unsafeFlow, $contentType, $charset, $typeInfo, $value);
+  var l = (value, $completion) => i.y1i(value, $completion);
+  l.$arity = 1;
+  return l;
+}
+function *_generator_invoke__zhh2q8_0($this, value, $completion) {
+  var $this$transform = $this.k48_1;
+  var tmp = value.n3a($this.l48_1, $this.m48_1, $this.n48_1, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp$ret$0 = tmp;
+  var tmp_0 = $this$transform.p1e(tmp$ret$0, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return Unit_instance;
+}
+function *_generator_collect__dlomyy_0($this, collector, $completion) {
+  var tmp = KotlinxSerializationConverter$deserialize$o$collect$slambda_0(collector, $this.p48_1, $this.q48_1, $this.r48_1);
+  var tmp_0 = $this.o48_1.y1d(new (sam$kotlinx_coroutines_flow_FlowCollector$0_0())(tmp), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return Unit_instance;
+}
+var KotlinxSerializationConverter$deserialize$o$collect$slambdaClass;
+function KotlinxSerializationConverter$deserialize$o$collect$slambda() {
+  if (KotlinxSerializationConverter$deserialize$o$collect$slambdaClass === VOID) {
+    class $ {
+      constructor($$this$unsafeFlow, $charset, $typeInfo, $content) {
+        this.k48_1 = $$this$unsafeFlow;
+        this.l48_1 = $charset;
+        this.m48_1 = $typeInfo;
+        this.n48_1 = $content;
+      }
+      y1i(value, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_0.bind(VOID, this, value), $completion);
+      }
+      de(p1, $completion) {
+        return this.y1i((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    KotlinxSerializationConverter$deserialize$o$collect$slambdaClass = $;
+  }
+  return KotlinxSerializationConverter$deserialize$o$collect$slambdaClass;
+}
+function KotlinxSerializationConverter$deserialize$o$collect$slambda_0($$this$unsafeFlow, $charset, $typeInfo, $content) {
+  var i = new (KotlinxSerializationConverter$deserialize$o$collect$slambda())($$this$unsafeFlow, $charset, $typeInfo, $content);
+  var l = (value, $completion) => i.y1i(value, $completion);
+  l.$arity = 1;
+  return l;
+}
+function *_generator_serialize__l2piac($this, contentType, charset, typeInfo, value, $completion) {
+  // Inline function 'kotlinx.coroutines.flow.map' call
+  // Inline function 'kotlinx.coroutines.flow.unsafeTransform' call
+  var this_0 = asFlow($this.t48_1);
+  // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
+  var tmp = new (KotlinxSerializationConverter$serialize$$inlined$map$1())(this_0, contentType, charset, typeInfo, value);
+  var tmp_0 = firstOrNull(tmp, KotlinxSerializationConverter$serialize$slambda_0(), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var fromExtension = tmp_0;
+  if (!(fromExtension == null))
+    return fromExtension;
+  var tmp_1;
+  try {
+    tmp_1 = serializerForTypeInfo($this.s48_1.y20(), typeInfo);
+  } catch ($p) {
+    var tmp_2;
+    if ($p instanceof SerializationException()) {
+      var cause = $p;
+      tmp_2 = guessSerializer(value, $this.s48_1.y20());
+    } else {
+      throw $p;
+    }
+    tmp_1 = tmp_2;
+  }
+  var serializer = tmp_1;
+  return serializeContent($this, serializer, $this.s48_1, value, contentType, charset);
+}
+function *_generator_deserialize__why6p7($this, charset, typeInfo, content, $completion) {
+  // Inline function 'kotlinx.coroutines.flow.map' call
+  // Inline function 'kotlinx.coroutines.flow.unsafeTransform' call
+  var this_0 = asFlow($this.t48_1);
+  // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
+  var tmp = new (KotlinxSerializationConverter$deserialize$$inlined$map$1())(this_0, charset, typeInfo, content);
+  var tmp_0 = firstOrNull(tmp, KotlinxSerializationConverter$deserialize$slambda_0(content), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var fromExtension = tmp_0;
+  var tmp_1;
+  // Inline function 'kotlin.collections.isNotEmpty' call
+  if (!$this.t48_1.o1()) {
+    tmp_1 = !(fromExtension == null) || content.f1t();
+  } else {
+    tmp_1 = false;
+  }
+  if (tmp_1)
+    return fromExtension;
+  var serializer = serializerForTypeInfo($this.s48_1.y20(), typeInfo);
+  var tmp_2 = readRemaining(content, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  var contentPacket = tmp_2;
+  try {
+    var tmp0_subject = $this.s48_1;
+    var tmp_3;
+    if (isInterface(tmp0_subject, StringFormat())) {
+      tmp_3 = $this.s48_1.e1x(serializer, readText(contentPacket, charset));
+    } else {
+      if (isInterface(tmp0_subject, BinaryFormat())) {
+        tmp_3 = $this.s48_1.g1x(serializer, readByteArray(contentPacket));
+      } else {
+        discard(contentPacket);
+        // Inline function 'kotlin.error' call
+        var message = 'Unsupported format ' + toString($this.s48_1);
+        throw IllegalStateException().o(toString(message));
+      }
+    }
+    return tmp_3;
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var cause = $p;
+      throw JsonConvertException().g3a('Illegal input: ' + cause.message, cause);
+    } else {
+      throw $p;
+    }
+  }
+}
+function serializeContent($this, serializer, format, value, contentType, charset) {
+  var tmp;
+  if (isInterface(format, StringFormat())) {
+    var content = format.d1x(isInterface(serializer, KSerializer()) ? serializer : THROW_CCE(), value);
+    tmp = new (TextContent())(content, withCharsetIfNeeded(contentType, charset));
+  } else {
+    if (isInterface(format, BinaryFormat())) {
+      var content_0 = format.f1x(isInterface(serializer, KSerializer()) ? serializer : THROW_CCE(), value);
+      tmp = new (ByteArrayContent())(content_0, contentType);
+    } else {
+      var message = 'Unsupported format ' + toString(format);
+      throw IllegalStateException().o(toString(message));
+    }
+  }
+  return tmp;
+}
+var sam$kotlinx_coroutines_flow_FlowCollector$0Class;
+function sam$kotlinx_coroutines_flow_FlowCollector$0() {
+  if (sam$kotlinx_coroutines_flow_FlowCollector$0Class === VOID) {
+    class $ {
+      constructor(function_0) {
+        this.u48_1 = function_0;
+      }
+      p1e(value, $completion) {
+        return this.u48_1(value, $completion);
+      }
+      h5() {
+        return this.u48_1;
+      }
+      equals(other) {
+        var tmp;
+        if (!(other == null) ? isInterface(other, FlowCollector()) : false) {
+          var tmp_0;
+          if (!(other == null) ? isInterface(other, FunctionAdapter()) : false) {
+            tmp_0 = equals(this.h5(), other.h5());
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.h5());
+      }
+    }
+    initMetadataForClass($, 'sam$kotlinx_coroutines_flow_FlowCollector$0', VOID, VOID, [FlowCollector(), FunctionAdapter()], [1]);
+    sam$kotlinx_coroutines_flow_FlowCollector$0Class = $;
+  }
+  return sam$kotlinx_coroutines_flow_FlowCollector$0Class;
+}
+var sam$kotlinx_coroutines_flow_FlowCollector$0Class_0;
+function sam$kotlinx_coroutines_flow_FlowCollector$0_0() {
+  if (sam$kotlinx_coroutines_flow_FlowCollector$0Class_0 === VOID) {
+    class $ {
+      constructor(function_0) {
+        this.v48_1 = function_0;
+      }
+      p1e(value, $completion) {
+        return this.v48_1(value, $completion);
+      }
+      h5() {
+        return this.v48_1;
+      }
+      equals(other) {
+        var tmp;
+        if (!(other == null) ? isInterface(other, FlowCollector()) : false) {
+          var tmp_0;
+          if (!(other == null) ? isInterface(other, FunctionAdapter()) : false) {
+            tmp_0 = equals(this.h5(), other.h5());
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.h5());
+      }
+    }
+    initMetadataForClass($, 'sam$kotlinx_coroutines_flow_FlowCollector$0', VOID, VOID, [FlowCollector(), FunctionAdapter()], [1]);
+    sam$kotlinx_coroutines_flow_FlowCollector$0Class_0 = $;
+  }
+  return sam$kotlinx_coroutines_flow_FlowCollector$0Class_0;
+}
+var KotlinxSerializationConverter$serialize$$inlined$map$1Class;
+function KotlinxSerializationConverter$serialize$$inlined$map$1() {
+  if (KotlinxSerializationConverter$serialize$$inlined$map$1Class === VOID) {
+    class $ {
+      constructor($this, $contentType, $charset, $typeInfo, $value) {
+        this.f48_1 = $this;
+        this.g48_1 = $contentType;
+        this.h48_1 = $charset;
+        this.i48_1 = $typeInfo;
+        this.j48_1 = $value;
+      }
+      q1e(collector, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_collect__dlomyy.bind(VOID, this, collector), $completion);
+      }
+      y1d(collector, $completion) {
+        return this.q1e(collector, $completion);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
+    KotlinxSerializationConverter$serialize$$inlined$map$1Class = $;
+  }
+  return KotlinxSerializationConverter$serialize$$inlined$map$1Class;
+}
+var KotlinxSerializationConverter$serialize$slambdaClass;
+function KotlinxSerializationConverter$serialize$slambda() {
+  if (KotlinxSerializationConverter$serialize$slambdaClass === VOID) {
+    class $ {
+      w48(it, $completion) {
+        return !(it == null);
+      }
+      de(p1, $completion) {
+        return this.w48((p1 == null ? true : p1 instanceof OutgoingContent()) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    KotlinxSerializationConverter$serialize$slambdaClass = $;
+  }
+  return KotlinxSerializationConverter$serialize$slambdaClass;
+}
+function KotlinxSerializationConverter$serialize$slambda_0() {
+  var i = new (KotlinxSerializationConverter$serialize$slambda())();
+  var l = (it, $completion) => i.w48(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var KotlinxSerializationConverter$deserialize$$inlined$map$1Class;
+function KotlinxSerializationConverter$deserialize$$inlined$map$1() {
+  if (KotlinxSerializationConverter$deserialize$$inlined$map$1Class === VOID) {
+    class $ {
+      constructor($this, $charset, $typeInfo, $content) {
+        this.o48_1 = $this;
+        this.p48_1 = $charset;
+        this.q48_1 = $typeInfo;
+        this.r48_1 = $content;
+      }
+      q1e(collector, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_collect__dlomyy_0.bind(VOID, this, collector), $completion);
+      }
+      y1d(collector, $completion) {
+        return this.q1e(collector, $completion);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
+    KotlinxSerializationConverter$deserialize$$inlined$map$1Class = $;
+  }
+  return KotlinxSerializationConverter$deserialize$$inlined$map$1Class;
+}
+var KotlinxSerializationConverter$deserialize$slambdaClass;
+function KotlinxSerializationConverter$deserialize$slambda() {
+  if (KotlinxSerializationConverter$deserialize$slambdaClass === VOID) {
+    class $ {
+      constructor($content) {
+        this.x48_1 = $content;
+      }
+      y1i(it, $completion) {
+        return !(it == null) || this.x48_1.f1t();
+      }
+      de(p1, $completion) {
+        return this.y1i((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    KotlinxSerializationConverter$deserialize$slambdaClass = $;
+  }
+  return KotlinxSerializationConverter$deserialize$slambdaClass;
+}
+function KotlinxSerializationConverter$deserialize$slambda_0($content) {
+  var i = new (KotlinxSerializationConverter$deserialize$slambda())($content);
+  var l = (it, $completion) => i.y1i(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var KotlinxSerializationConverterClass;
+function KotlinxSerializationConverter() {
+  if (KotlinxSerializationConverterClass === VOID) {
+    class $ {
+      constructor(format) {
+        this.s48_1 = format;
+        this.t48_1 = extensions(this.s48_1);
+        var tmp;
+        var tmp_0 = this.s48_1;
+        if (isInterface(tmp_0, BinaryFormat())) {
+          tmp = true;
+        } else {
+          var tmp_1 = this.s48_1;
+          tmp = isInterface(tmp_1, StringFormat());
+        }
+        // Inline function 'kotlin.require' call
+        if (!tmp) {
+          var message = 'Only binary and string formats are supported, ' + toString(this.s48_1) + ' is not supported.';
+          throw IllegalArgumentException().r2(toString(message));
+        }
+      }
+      q3w(contentType, charset, typeInfo, value, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_serialize__l2piac.bind(VOID, this, contentType, charset, typeInfo, value), $completion);
+      }
+      n3a(charset, typeInfo, content, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_deserialize__why6p7.bind(VOID, this, charset, typeInfo, content), $completion);
+      }
+    }
+    initMetadataForClass($, 'KotlinxSerializationConverter', VOID, VOID, VOID, [4, 3]);
+    KotlinxSerializationConverterClass = $;
+  }
+  return KotlinxSerializationConverterClass;
+}
+//region block: exports
+export {
+  serialization as serialization1fpeds7cruos4,
+};
+//endregion
+
+//# sourceMappingURL=KotlinxSerializationConverter.mjs.map

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/KotlinxSerializationConverter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-serialization/ktor-serialization-kotlinx/common/src/io/ktor/serialization/kotlinx/KotlinxSerializationConverter.kt","../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/operators/Transform.kt","../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/operators/Emitters.kt","../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/internal/SafeCollector.common.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/src/kotlin/collections/Collections.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["serialization","<this>","contentType","format","<generator-invoke>","$completion","<generator-collect>","collector","$contentType","$charset","$typeInfo","$value","invoke","KotlinxSerializationConverter$serialize$o$collect$slambda","KotlinxSerializationConverter$serialize$o$collect$slambda$lambda","$content","KotlinxSerializationConverter$deserialize$o$collect$slambda","KotlinxSerializationConverter$deserialize$o$collect$slambda$lambda","<generator-serialize>","charset","typeInfo","value","fromExtension","cause","serializer","<generator-deserialize>","content","contentPacket","serializeContent","emit","equals","hashCode","collect","KotlinxSerializationConverter$serialize$slambda","KotlinxSerializationConverter$serialize$slambda$lambda","KotlinxSerializationConverter$deserialize$slambda","KotlinxSerializationConverter$deserialize$slambda$lambda","message","serialize","deserialize"],"mappings":"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"}

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/SerializerLookup.mjs

@@ -0,0 +1,195 @@
+import {
+  serializerOrNull31x2b6nu6gruj as serializerOrNull,
+  serializer1rka18p0rjk4x as serializer,
+} from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/Serializers.mjs';
+import { getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression } from '../../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import {
+  MapSerializer11kmegt3g5c1g as MapSerializer,
+  SetSerializert3lb0yy9iftr as SetSerializer,
+  serializer1x79l67jvwntn as serializer_0,
+  ListSerializer1hxuk9dx5n9du as ListSerializer,
+  get_nullable197rfua9r7fsz as get_nullable,
+} from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/builtins/BuiltinSerializers.mjs';
+import {
+  KtMap140uvy3s5zad8 as KtMap,
+  KtSetjrjc7fhfd6b9 as KtSet,
+  KtList3hktaavzmj137 as KtList,
+  Collection1k04j3hzsbod0 as Collection,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import {
+  isInterface3d6p8outrmvmk as isInterface,
+  isArray1hxjqtqy632bc as isArray,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { firstOrNull1gk7vzkf4h3nq as firstOrNull } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Arrays.mjs';
+import { StringCompanionObject_instance3sox3h548pjra as StringCompanionObject_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/primitiveCompanionObjects.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import {
+  filterNotNull3qfgcwmxhwfxe as filterNotNull,
+  singleOrNullrknfaxokm1sl as singleOrNull,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { HashSet2dzve9y63nf0v as HashSet } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/HashSet.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function serializerForTypeInfo(_this__u8e3s4, typeInfo) {
+  var module_0 = _this__u8e3s4;
+  var tmp0_safe_receiver = typeInfo.p2n_1;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    var tmp_0;
+    if (tmp0_safe_receiver.g1().o1()) {
+      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.e1y(typeInfo.o2n_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.o2n_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.p4(), module_0);
+            var valueSerializer = elementSerializer(value.q4(), module_0);
+            tmp = MapSerializer(keySerializer, valueSerializer);
+          } else {
+            var tmp3_elvis_lhs = module_0.e1y(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.p2n_1;
+  if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.h1()) === 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().w2(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.q1();
+  while (_iterator__ex2g4s.r1()) {
+    var item = _iterator__ex2g4s.s1();
+    var tmp$ret$0 = guessSerializer(item, module_0);
+    destination.t2(tmp$ret$0);
+  }
+  // Inline function 'kotlin.collections.distinctBy' call
+  var set = HashSet().sa();
+  var list = ArrayList().n2();
+  var _iterator__ex2g4s_0 = destination.q1();
+  while (_iterator__ex2g4s_0.r1()) {
+    var e = _iterator__ex2g4s_0.s1();
+    var key = e.j1w().p1y();
+    if (set.t2(key)) {
+      list.t2(e);
+    }
+  }
+  var serializers = list;
+  if (serializers.v2() > 1) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList().w2(collectionSizeOrDefault(serializers, 10));
+    var _iterator__ex2g4s_1 = serializers.q1();
+    while (_iterator__ex2g4s_1.r1()) {
+      var item_0 = _iterator__ex2g4s_1.s1();
+      var tmp$ret$5 = item_0.j1w().p1y();
+      destination_0.t2(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().o(toString(message));
+  }
+  var tmp0_elvis_lhs = singleOrNull(serializers);
+  var selected = tmp0_elvis_lhs == null ? serializer_0(StringCompanionObject_instance) : tmp0_elvis_lhs;
+  if (selected.j1w().i1y()) {
+    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.o1();
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      tmp$ret$8 = false;
+      break $l$block_0;
+    }
+    var _iterator__ex2g4s_2 = _this__u8e3s4.q1();
+    while (_iterator__ex2g4s_2.r1()) {
+      var element = _iterator__ex2g4s_2.s1();
+      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;
+}
+//region block: exports
+export {
+  guessSerializer as guessSerializerlivkaydavxr9,
+  serializerForTypeInfo as serializerForTypeInfofg753n9o7cfi,
+};
+//endregion
+
+//# sourceMappingURL=SerializerLookup.mjs.map

package/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/SerializerLookup.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-serialization/ktor-serialization-kotlinx/common/src/io/ktor/serialization/kotlinx/SerializerLookup.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/common/src/generated/_Collections.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["serializerForTypeInfo","<this>","typeInfo","module","guessSerializer","value","keySerializer","valueSerializer","maybeNullable","elementSerializer","item","set","list","e","key","serializers","selected","element"],"mappings":"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"}