@attocash/commons-js 5.0.0

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSCommon.mjs

@@ -0,0 +1,99 @@
+import { TLSConfigBuilder13okkyh7n55vn as TLSConfigBuilder } from './TLSConfigBuilder.nonJvm.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { openTLSSession34e5qousamb68 as openTLSSession } from './TLSClientSession.nonJvm.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { close3semq7pafb42g as close } from '../../../../../ktor-ktor-io/io/ktor/utils/io/ByteWriteChannelOperations.mjs';
+import { initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function tls(_this__u8e3s4, coroutineContext, block, $completion) {
+  // Inline function 'kotlin.apply' call
+  var this_0 = new (TLSConfigBuilder())();
+  block(this_0);
+  return tls_0(_this__u8e3s4, coroutineContext, this_0.z1i(), $completion);
+}
+function tls_0(_this__u8e3s4, coroutineContext, config, $completion) {
+  var tmp = new ($tlsCOROUTINE$())(_this__u8e3s4, coroutineContext, config, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var $tlsCOROUTINE$Class;
+function $tlsCOROUTINE$() {
+  if ($tlsCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, coroutineContext, config, resultContinuation) {
+        super(resultContinuation);
+        this.e6z_1 = _this__u8e3s4;
+        this.f6z_1 = coroutineContext;
+        this.g6z_1 = config;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 3;
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = openTLSSession(this.e6z_1.b6w_1, this.e6z_1.c6w_1, this.e6z_1.d6w_1, this.g6z_1, this.f6z_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.h6z_1 = suspendResult;
+                this.bc_1 = 3;
+                this.ac_1 = 4;
+                continue $sm;
+              case 2:
+                this.bc_1 = 3;
+                var tmp_0 = this.dc_1;
+                if (tmp_0 instanceof Error) {
+                  var cause = this.dc_1;
+                  var tmp_1 = this;
+                  this.e6z_1.c6w_1.x3a(cause);
+                  close(this.e6z_1.d6w_1, cause);
+                  this.e6z_1.b6w_1.v5();
+                  throw cause;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 3:
+                throw this.dc_1;
+              case 4:
+                this.bc_1 = 3;
+                return this.h6z_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 3) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $tlsCOROUTINE$Class = $;
+  }
+  return $tlsCOROUTINE$Class;
+}
+//region block: exports
+export {
+  tls as tls914asjl5d6bh,
+};
+//endregion
+
+//# sourceMappingURL=TLSCommon.mjs.map

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSCommon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-network/ktor-network-tls/common/src/io/ktor/network/tls/TLSCommon.kt","src/kotlin/util/Standard.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["tls","<this>","coroutineContext","block","$completion","config","doResume","cause"],"mappings":";;;;;;;;;;;;YAmEAA,CAAmBC,a,EAAeC,gB,EAAoCC,K,EAAtEC,WAAAJ,EACI;A;eAAsB,0B;EAAyB,KCc/C,Q;EDd8D,OAA9D,qBAAI,gBAAJ,ECeO,MDf+C,MAAtD,c;AAA6D,C;cA3BjEA,CAAmBC,a,EACfC,gB,EACAG,M,EAFJD,WAAAJ,EAGU;A;;;;AASV,C;;;;;kBAZmB,a,EACf,gB,EACA,M,EAFJ,kB;;;;;;QAAAM,CAAAA,EAAA;A;;UAAA,I;;;;;;;gCAKQ,oBAAe,KAAf,CAAe,KAAf,OAAuB,KAAvB,CAAuB,KAAvB,OAA8B,KAA9B,CAA8B,KAA9B,OAAsC,KAAtC,OAA8C,KAA9C,O;;;;;;;;;;;;;;;sBACKC,iB;;kBACC,KAAN,KAAM,CAAN,KAAM,KAAO,KAAP,C;kBACC,WAAP,KAAO,CAAP,KAAO,EAAM,KAAN,C;kBACA,KAAP,KAAO,CAAP,KAAO,K;kBACP,MAAM,K;;;;;;;;;;;;;;;;;;;;;MAEd,C;;;;;;;;;;;"}

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSConfig.nonJvm.mjs

@@ -0,0 +1,22 @@
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var TLSConfigClass;
+function TLSConfig() {
+  if (TLSConfigClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'TLSConfig', TLSConfig);
+    TLSConfigClass = $;
+  }
+  return TLSConfigClass;
+}
+//region block: exports
+export {
+  TLSConfig as TLSConfig1yfd1i4f6tpl8,
+};
+//endregion
+
+//# sourceMappingURL=TLSConfig.nonJvm.mjs.map

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSConfig.nonJvm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSConfigBuilder.nonJvm.mjs

@@ -0,0 +1,33 @@
+import { TLSConfig1yfd1i4f6tpl8 as TLSConfig } from './TLSConfig.nonJvm.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var TLSConfigBuilderClass;
+function TLSConfigBuilder() {
+  if (TLSConfigBuilderClass === VOID) {
+    class $ {
+      constructor() {
+        this.v6y_1 = null;
+      }
+      z1i() {
+        return new (TLSConfig())();
+      }
+    }
+    initMetadataForClass($, 'TLSConfigBuilder', TLSConfigBuilder);
+    TLSConfigBuilderClass = $;
+  }
+  return TLSConfigBuilderClass;
+}
+function takeFrom(_this__u8e3s4, other) {
+}
+//region block: exports
+export {
+  TLSConfigBuilder as TLSConfigBuilder13okkyh7n55vn,
+  takeFrom as takeFrom1qtq5x148q1f9,
+};
+//endregion
+
+//# sourceMappingURL=TLSConfigBuilder.nonJvm.mjs.map

package/ktor-ktor-network-tls/io/ktor/network/tls/TLSConfigBuilder.nonJvm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-network/ktor-network-tls/nonJvm/src/io/ktor/network/tls/TLSConfigBuilder.nonJvm.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["build","takeFrom","<this>","other"],"mappings":";;;;;;;;;;;;QAkB4C,iB;;SAOxCA,CAAAA,EAAuC;A,QAAW,0B;MAAD,C;;;;;;;iBAQrDC,CAAkBC,a,EAA0BC,KAA5CF,EAAqE;AACrE,C;;;;;"}

package/ktor-ktor-serialization/io/ktor/serialization/ContentConvertException.mjs

@@ -0,0 +1,48 @@
+import { Exceptiondt2hlxn7j7vw as Exception } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { captureStack1fzi4aczwc4hg as captureStack } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var ContentConvertExceptionClass;
+function ContentConvertException() {
+  if (ContentConvertExceptionClass === VOID) {
+    class $ extends Exception() {
+      static w4u(message, cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.re(message, cause);
+        captureStack($this, $this.v4u_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ContentConvertException');
+    ContentConvertExceptionClass = $;
+  }
+  return ContentConvertExceptionClass;
+}
+var JsonConvertExceptionClass;
+function JsonConvertException() {
+  if (JsonConvertExceptionClass === VOID) {
+    class $ extends ContentConvertException() {
+      static a4v(message, cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.w4u(message, cause);
+        captureStack($this, $this.z4u_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'JsonConvertException');
+    JsonConvertExceptionClass = $;
+  }
+  return JsonConvertExceptionClass;
+}
+//region block: exports
+export {
+  ContentConvertException as ContentConvertExceptione8d7sn5vn4zf,
+  JsonConvertException as JsonConvertExceptiongnc5x6xwaf77,
+};
+//endregion
+
+//# sourceMappingURL=ContentConvertException.mjs.map

package/ktor-ktor-serialization/io/ktor/serialization/ContentConvertException.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-serialization/common/src/ContentConvertException.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["message","cause"],"mappings":";;;;;;;;;;;;iBASIA,O,EACAC,K;iCAAoB,I;4BACV,O,EAAS,K;;;;;;;;;;;;;;iBAGnBD,O,EACAC,K;iCAAoB,I;6BACI,O,EAAS,K;;;;;;;;;;;;;;"}

package/ktor-ktor-serialization/io/ktor/serialization/ContentConverter.mjs

@@ -0,0 +1,419 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  Charsets_getInstanceqs70pvl4noow as Charsets_getInstance,
+  forName2faodmskqnoz5 as forName,
+  isSupported2nf870ypy50et as isSupported,
+} from '../../../../ktor-ktor-io/io/ktor/utils/io/charsets/Charset.js.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { HttpHeaders_getInstanceelogg8fjd54u as HttpHeaders_getInstance } from '../../../../ktor-ktor-http/io/ktor/http/HttpHeaders.mjs';
+import { parseAndSortHeader33xgq5fx7y6j1 as parseAndSortHeader } from '../../../../ktor-ktor-http/io/ktor/http/HttpHeaderValueParser.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { FunctionAdapter3lcrrz3moet5b as FunctionAdapter } from '../../../../kotlin-kotlin-stdlib/kotlin/js/FunctionAdapter.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from '../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/FlowCollector.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { asFlow3ngsnn5xpz8pw as asFlow } from '../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Builders.mjs';
+import { firstOrNull3jjcu7fygcopr as firstOrNull } from '../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Reduce.mjs';
+import { ContentConvertExceptione8d7sn5vn4zf as ContentConvertException } from './ContentConvertException.mjs';
+import { NullBody_instance2i6w0hfghwfg0 as NullBody_instance } from '../../../../ktor-ktor-http/io/ktor/http/content/OutgoingContent.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function deserialize(_this__u8e3s4, body, typeInfo, charset, $completion) {
+  var tmp = new ($deserializeCOROUTINE$())(_this__u8e3s4, body, typeInfo, charset, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function suitableCharset(_this__u8e3s4, defaultCharset) {
+  defaultCharset = defaultCharset === VOID ? Charsets_getInstance().y3p_1 : defaultCharset;
+  var tmp0_elvis_lhs = suitableCharsetOrNull(_this__u8e3s4, defaultCharset);
+  return tmp0_elvis_lhs == null ? defaultCharset : tmp0_elvis_lhs;
+}
+function Configuration$register$lambda(_this__u8e3s4) {
+  return Unit_instance;
+}
+function register$default(contentType, converter, configuration, $super) {
+  var tmp;
+  if (configuration === VOID) {
+    tmp = Configuration$register$lambda;
+  } else {
+    tmp = configuration;
+  }
+  configuration = tmp;
+  var tmp_0;
+  if ($super === VOID) {
+    this.n4v(contentType, converter, configuration);
+    tmp_0 = Unit_instance;
+  } else {
+    tmp_0 = $super.n4v.call(this, contentType, converter, configuration);
+  }
+  return tmp_0;
+}
+var ConfigurationClass;
+function Configuration() {
+  if (ConfigurationClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Configuration');
+    ConfigurationClass = $;
+  }
+  return ConfigurationClass;
+}
+function suitableCharsetOrNull(_this__u8e3s4, defaultCharset) {
+  defaultCharset = defaultCharset === VOID ? Charsets_getInstance().y3p_1 : defaultCharset;
+  var _iterator__ex2g4s = parseAndSortHeader(_this__u8e3s4.o3r(HttpHeaders_getInstance().t40_1)).d1();
+  while (_iterator__ex2g4s.e1()) {
+    var charset = _iterator__ex2g4s.f1().gl();
+    if (charset === '*')
+      return defaultCharset;
+    else if (isSupported(Charsets_getInstance(), charset))
+      return forName(Charsets_getInstance(), charset);
+  }
+  return null;
+}
+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.p4v_1 = function_0;
+      }
+      w2k(value, $completion) {
+        return this.p4v_1(value, $completion);
+      }
+      i4() {
+        return this.p4v_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.i4(), other.i4());
+          } else {
+            tmp_0 = false;
+          }
+          tmp = tmp_0;
+        } else {
+          tmp = false;
+        }
+        return tmp;
+      }
+      hashCode() {
+        return hashCode(this.i4());
+      }
+    }
+    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 deserialize$o$collect$slambdaClass;
+function deserialize$o$collect$slambda() {
+  if (deserialize$o$collect$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($$this$unsafeFlow, $charset, $typeInfo, $body, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.y4v_1 = $$this$unsafeFlow;
+        $box.z4v_1 = $charset;
+        $box.a4w_1 = $typeInfo;
+        $box.b4w_1 = $body;
+        super(resultContinuation, $box);
+      }
+      k4w(value, $completion) {
+        var tmp = this.l4w(value, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.k4w((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 3;
+                var tmp_0 = this;
+                tmp_0.d4w_1 = this.y4v_1;
+                var tmp_1 = this;
+                tmp_1.e4w_1 = this.c4w_1;
+                this.f4w_1 = this.d4w_1;
+                this.g4w_1 = this.e4w_1;
+                var tmp_2 = this;
+                tmp_2.h4w_1 = this.g4w_1;
+                this.i4w_1 = this.h4w_1;
+                this.ac_1 = 1;
+                suspendResult = this.i4w_1.m4w(this.z4v_1, this.a4w_1, this.b4w_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.j4w_1 = suspendResult;
+                this.ac_1 = 2;
+                suspendResult = this.f4w_1.w2k(this.j4w_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                return Unit_instance;
+              case 3:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 3) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      l4w(value, completion) {
+        var i = new (deserialize$o$collect$slambda())(this.y4v_1, this.z4v_1, this.a4w_1, this.b4w_1, completion);
+        i.c4w_1 = value;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    deserialize$o$collect$slambdaClass = $;
+  }
+  return deserialize$o$collect$slambdaClass;
+}
+function deserialize$o$collect$slambda_0($$this$unsafeFlow, $charset, $typeInfo, $body, resultContinuation) {
+  var i = new (deserialize$o$collect$slambda())($$this$unsafeFlow, $charset, $typeInfo, $body, resultContinuation);
+  var l = function (value, $completion) {
+    return i.k4w(value, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var $collectCOROUTINE$Class;
+function $collectCOROUTINE$() {
+  if ($collectCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, collector, resultContinuation) {
+        super(resultContinuation);
+        this.v4w_1 = _this__u8e3s4;
+        this.w4w_1 = collector;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                var tmp_0 = this;
+                tmp_0.x4w_1 = this.w4w_1;
+                this.y4w_1 = this.x4w_1;
+                this.ac_1 = 1;
+                var tmp_1 = deserialize$o$collect$slambda_0(this.y4w_1, this.v4w_1.a4x_1, this.v4w_1.b4x_1, this.v4w_1.c4x_1, null);
+                suspendResult = this.v4w_1.z4w_1.c2k(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.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $collectCOROUTINE$Class = $;
+  }
+  return $collectCOROUTINE$Class;
+}
+var deserialize$$inlined$map$1Class;
+function deserialize$$inlined$map$1() {
+  if (deserialize$$inlined$map$1Class === VOID) {
+    class $ {
+      constructor($this, $charset, $typeInfo, $body) {
+        this.z4w_1 = $this;
+        this.a4x_1 = $charset;
+        this.b4x_1 = $typeInfo;
+        this.c4x_1 = $body;
+      }
+      x2k(collector, $completion) {
+        var tmp = new ($collectCOROUTINE$())(this, collector, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      c2k(collector, $completion) {
+        return this.x2k(collector, $completion);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
+    deserialize$$inlined$map$1Class = $;
+  }
+  return deserialize$$inlined$map$1Class;
+}
+var deserialize$slambdaClass;
+function deserialize$slambda() {
+  if (deserialize$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($body, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.l4x_1 = $body;
+        super(resultContinuation, $box);
+      }
+      n4x(it, $completion) {
+        var tmp = this.l4w(it, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.n4x((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            if (tmp === 0) {
+              this.bc_1 = 1;
+              return !(this.m4x_1 == null) || this.l4x_1.t3a();
+            } else if (tmp === 1) {
+              throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            throw e;
+          }
+         while (true);
+      }
+      l4w(it, completion) {
+        var i = new (deserialize$slambda())(this.l4x_1, completion);
+        i.m4x_1 = it;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    deserialize$slambdaClass = $;
+  }
+  return deserialize$slambdaClass;
+}
+function deserialize$slambda_0($body, resultContinuation) {
+  var i = new (deserialize$slambda())($body, resultContinuation);
+  var l = function (it, $completion) {
+    return i.n4x(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var $deserializeCOROUTINE$Class;
+function $deserializeCOROUTINE$() {
+  if ($deserializeCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, body, typeInfo, charset, resultContinuation) {
+        super(resultContinuation);
+        this.j4v_1 = _this__u8e3s4;
+        this.k4v_1 = body;
+        this.l4v_1 = typeInfo;
+        this.m4v_1 = charset;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                var this_0 = asFlow(this.j4v_1);
+                var tmp_0 = new (deserialize$$inlined$map$1())(this_0, this.m4v_1, this.l4v_1, this.k4v_1);
+                suspendResult = firstOrNull(tmp_0, deserialize$slambda_0(this.k4v_1, null), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var result = suspendResult;
+                var tmp_1;
+                if (!(result == null)) {
+                  tmp_1 = result;
+                } else {
+                  if (!this.k4v_1.t3a()) {
+                    tmp_1 = this.k4v_1;
+                  } else {
+                    var tmp0_safe_receiver = this.l4v_1.a3x_1;
+                    if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.rg()) === true) {
+                      tmp_1 = NullBody_instance;
+                    } else {
+                      throw ContentConvertException().w4u('No suitable converter found for ' + this.l4v_1.toString());
+                    }
+                  }
+                }
+
+                return tmp_1;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $deserializeCOROUTINE$Class = $;
+  }
+  return $deserializeCOROUTINE$Class;
+}
+//region block: exports
+export {
+  deserialize as deserialize3kqe4vxpbxz1,
+  register$default as register$default3vdkjcc7m2cj0,
+  Configuration as Configuration20xgygxdzhlk5,
+  suitableCharset as suitableCharset1jgdcpdzbzgzn,
+};
+//endregion
+
+//# sourceMappingURL=ContentConverter.mjs.map

package/ktor-ktor-serialization/io/ktor/serialization/ContentConverter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-shared/ktor-serialization/common/src/ContentConverter.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["deserialize","<this>","body","typeInfo","charset","$completion","suitableCharset","defaultCharset","Configuration$register$lambda","register$default","contentType","converter","configuration","suitableCharsetOrNull","emit","value","equals","hashCode","$charset","$typeInfo","$body","invoke","doResume","deserialize$o$collect$slambda","deserialize$o$collect$slambda$lambda","collect","collector","deserialize$slambda","deserialize$slambda$lambda","result"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmGAA,CACmBC,a,EACfC,I,EACAC,Q,EACAC,O,EAJJC,WAAAL,EAKO;A;;;;AAgBP,C;wBArDAM,CAAWL,a,EAAwBM,cAAnCD,EACI;A,oEADkE,K;MAClE,sDAAsB,cAAtB,C;EAAuD,OAAvD,yBAAyC,cAAzC,iB;AAAsD,C;sCA2BpBE,CAAA,aAAAA,EAAA;A,EAAE,oB;AAAD,C;yBAHnCC,CACIC,W,EACAC,S,EACAC,a,QAHJH,E;;;UAGkC,6B;;;;;;;;;;;;;C;;;;;;;;;;8BApBtCI,CAAWZ,a,EAA8BM,cAAzCM,EAA6F;A,oEAAjB,K;MACnD,uCAAmB,4CAAgB,KAAhB,CAAnB,M;SAAA,sB,EAAoD;A,QAAnET,UAAe,sBAAf,K;IAEE,gBAAW,GAAX,C;MAAkB,OAAO,c;SACzB,IAAS,oCAAY,OAAZ,CAAT,C;MAAiC,OAAgB,gCAAQ,OAAR,C;EAEzD,C;EACA,OAAO,I;AACX,C;;;;;;QA3CkC,uB;;SAAAU,CAd7BC,K,EAc6BV,WAAAS,E;;O;;;;YAxClCE,C,KAAAA,E;;;;;;;;;;;;;;O;cAAAC,CAAAA,E;;O;;;;;;;;;;;qCAuGIC,Q,EADAC,S,EADAC,K;;;;;;;;;SA7D8BC,CAClC,K,EADkChB,WAAAgB,EAE4D;A;;;;MAEnF,C;SA5CX,E,EAAAhB,W;;;QAwCkCiB,CAAAA,EAAA;A;;UAAA,I;;;;;;;;mCAI5B,K;;;;mCAFkG,K;;;gCAqElE,KAAV,KAAU,UAAsB,KAAtB,OAA0C,KAA1C,OAA8D,KAA9D,O;;;;;;;;;gCArEmD,gC;;;;;;;;;;;;;;;;;;;;;MAExE,C;UAHjB,K,EA0ByB,U;;;;;;;;;;;wCA3BSC,C,mBA+D9BL,Q,EADAC,S,EADAC,K,oBA7D8BG,E;;mBAAAC,CAClC,K,EADkCnB,WAAAmB,E;;G;;;C;;;;;kBAoEZ,a,EACf,S,EADe,kB;;;;;QAAAF,CAAAA,EAAA;A;;UAAA,I;;;;;;mCAC4B,K;;;oBArEhB,+G;gCAAR,yEAAQ,KAAR,Q;;;;;;;gBAqEkD,oB;;;;;;;;;;;;;;MAAA,C;;;;;;;;;;;yBANxEJ,Q,EADAC,S,EADAC,K;;;;;;SAOkBK,CACfC,S,EADerB,WAAAoB,EACc;A;;;;MAAwC,C;UAYk7KC,S,EAA3BrB,W;;;;;;;;;;;;;kBApB/9Ke,K;;;;;;SAWiBC,CAAA,E,EAAAhB,WAAAgB,EAAE;A;;;;MAAiC,C;SAhHxD,E,EAAAhB,W;;;QAgHqBiB,CAAAA,EAAA;A;;UAAA,I;;;;qBAAE,gBAAM,IAAN,C,IAAmB,KAAL,KAAK,M;;;;;;;;;MAAgB,C;UAArC,E,EA7CI,U;;;;;;;;;;;8BA6CJK,CAXjBP,K,oBAWiBO,E;;mBAAAC,CAAA,E,EAAAvB,WAAAuB,E;;G;;;C;;;;;kBAZF,a,EACf,I,EACA,Q,EACA,O,EAJJ,kB;;;;;;;QAAAN,CAAAA,EAAA;A;;UAAA,I;;;;;;6BAWiB,kB;4BAvE6B,mCAoEV,MApEU,OAoEV,KApEU,OAoEV,KApEU,OAoEV,KApEU,C;gCAyErC,mBAAY,uCAAZ,O;;;;;;;oBAFLO,sB;;gBAKI,gBAAU,IAAV,E;0BAAkB,M;;kBAClB,KAAM,KAAL,KAAK,MAAN,C;iCAAyB,K;;wBAChB,0BAAT,KAAS,M;oBAAT,KAAqB,oCAArB,kBAAqB,KAArB,MAAyC,IAAzC,C;;;sBACQ,oCAA+B,kCAA/B,QAAgE,KAAhE,Y;;;;;;;;;;;;;;;;;;;MAEhB,C;;;;;;;;;;;"}

package/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/Extensions.mjs

@@ -0,0 +1,33 @@
+import { get_providers3pa8rlw39y46i as get_providers } from './ExtensionsJs.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function extensions(format) {
+  // Inline function 'kotlin.collections.mapNotNull' call
+  var tmp0 = get_providers();
+  // Inline function 'kotlin.collections.mapNotNullTo' call
+  var destination = ArrayList().l1();
+  // Inline function 'kotlin.collections.forEach' call
+  var _iterator__ex2g4s = tmp0.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var element = _iterator__ex2g4s.f1();
+    var tmp0_safe_receiver = element.b6b(format);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      destination.m(tmp0_safe_receiver);
+    }
+  }
+  return destination;
+}
+//region block: exports
+export {
+  extensions as extensionsocv2ha4uem50,
+};
+//endregion
+
+//# sourceMappingURL=Extensions.mjs.map

package/ktor-ktor-serialization-kotlinx/io/ktor/serialization/kotlinx/Extensions.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/Extensions.kt","common/src/generated/_Collections.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["extensions","format","element"],"mappings":";;;;;;;mBAeAA,CAAwBC,MAAxBD,EACI;A;aAAA,e;;oBCgkDoB,gB;;MA4PJ,6B;SAAA,sB,EAAM;A,QAAjBE,UAAW,sB;QApPK,qBAoPQ,OD5zDH,KAAU,MAAV,C;ICwkDe,+B;MAAA,I;;;MAAM,WAAY,GAAtC,kBAAsC,C;;EAoPvB,C;ED5zDS,OCykDtC,W;ADzkDqC,C;;;;;"}