@attocash/commons-js 5.0.0

package/ktor-ktor-client-cio/io/ktor/client/engine/cio/utils.mjs

@@ -0,0 +1,1339 @@
+import {
+  NoContent1bdx48poqrifq as NoContent,
+  ProtocolUpgradexnnpt2xliy8g as ProtocolUpgrade,
+  ContentWrapper3n9gdymgnbto9 as ContentWrapper,
+  WriteChannelContent1d7f40hsfcaxg as WriteChannelContent,
+  ReadChannelContentz1amb4hnpqp4 as ReadChannelContent,
+  ByteArrayContent2n0wb43y6ugs1 as ByteArrayContent,
+} from '../../../../../../ktor-ktor-http/io/ktor/http/content/OutgoingContent.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  withContexte657h72vdbqn as withContext,
+  launch1c91vkjzdi9sd as launch,
+} from '../../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { closeqm43o3junf8o as close } from '../../../../../../ktor-ktor-io/io/ktor/utils/io/ByteWriteChannel.mjs';
+import { UnsupportedContentTypeException1omj39t4jp3a7 as UnsupportedContentTypeException } from '../../../../../../ktor-ktor-client-core/io/ktor/client/call/utils.mjs';
+import { HttpHeaders_getInstanceelogg8fjd54u as HttpHeaders_getInstance } from '../../../../../../ktor-ktor-http/io/ktor/http/HttpHeaders.mjs';
+import { encodeChunked133ferbkcl2ky as encodeChunked } from '../../../../../../ktor-ktor-http-cio/io/ktor/http/cio/ChunkedTransferEncoding.mjs';
+import { CoroutineName2g5zosw74tf0f as CoroutineName } from '../../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineName.mjs';
+import {
+  CoroutineScopelux7s7zphw7e as CoroutineScope,
+  GlobalScope_instance1sfulufhd2ijt as GlobalScope_instance,
+  CoroutineScopefcb5f5dwqcas as CoroutineScope_0,
+} from '../../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { get_job2zvlvce9o9a29 as get_job } from '../../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Job.mjs';
+import {
+  reader248c0jw1ii7vm as reader,
+  ReaderScope2dc8cistt42km as ReaderScope,
+  copyTo2vm7vz7rr51or as copyTo,
+  discard2tnmk0ppobupv as discard,
+  copyAndClose18m9s4thl5g8a as copyAndClose,
+} from '../../../../../../ktor-ktor-io/io/ktor/utils/io/ByteReadChannelOperations.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  mutableListOf6oorvk2mtdmp as mutableListOf,
+  listOf1jh22dvmctj1r as listOf,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import {
+  WriterScope3b0bo1enaee6b as WriterScope,
+  writer1eia5its2a1fh as writer,
+  close3semq7pafb42g as close_0,
+  join2urjmnc3jly88 as join,
+  writePacketg3gtxxix1x9l as writePacket,
+  writeFully3gv1ab611t04k as writeFully,
+} from '../../../../../../ktor-ktor-io/io/ktor/utils/io/ByteWriteChannelOperations.mjs';
+import { parseHttpBody26ete4vj86xh1 as parseHttpBody } from '../../../../../../ktor-ktor-http-cio/io/ktor/http/cio/HttpBody.mjs';
+import { parseResponse4z7nmc7nt7d9 as parseResponse } from '../../../../../../ktor-ktor-http-cio/io/ktor/http/cio/HttpParser.mjs';
+import { ClosedReadChannelException9jdpzh6uy12w as ClosedReadChannelException } from '../../../../../../ktor-ktor-io/io/ktor/utils/io/Exceptions.mjs';
+import {
+  EOFExceptionh831u25jcq9n as EOFException,
+  IOException1wyutdmfe71nu as IOException,
+} from '../../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/-PlatformJs.mjs';
+import {
+  HttpStatusCode3o1wkms10pg4k as HttpStatusCode,
+  Companion_getInstanceud97dyzf471m as Companion_getInstance,
+} from '../../../../../../ktor-ktor-http/io/ktor/http/HttpStatusCode.mjs';
+import { toLongkk4waq8msp1k as toLong } from '../../../../../../kotlin-kotlin-stdlib/kotlin/text/numberConversions.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import { Companion_getInstance2p223k6x3d6mk as Companion_getInstance_0 } from '../../../../../../ktor-ktor-http-cio/io/ktor/http/cio/ConnectionOptions.mjs';
+import { HeadersImplgosrgxq9oqma as HeadersImpl } from '../../../../../../ktor-ktor-http/io/ktor/http/Headers.mjs';
+import { Companion_getInstance312jiahuid5ey as Companion_getInstance_1 } from '../../../../../../ktor-ktor-http/io/ktor/http/HttpProtocolVersion.mjs';
+import { RawWebSocket2pme5y82im9ml as RawWebSocket } from '../../../../../../ktor-ktor-websockets/io/ktor/websocket/RawWebSocket.mjs';
+import {
+  HttpResponseData2dozo5khuplr6 as HttpResponseData,
+  get_ResponseAdapterAttributeKey1ll13ywinsgvd as get_ResponseAdapterAttributeKey,
+} from '../../../../../../ktor-ktor-client-core/io/ktor/client/request/HttpRequest.mjs';
+import { Companion_getInstance2ai11rhpust2a as Companion_getInstance_2 } from '../../../../../../ktor-ktor-io/io/ktor/utils/io/ByteReadChannel.mjs';
+import {
+  Companion_getInstance1p3cpld7r1jz3 as Companion_getInstance_3,
+  get_supportsRequestBodyjdtitrt33hir as get_supportsRequestBody,
+  HttpMethod3h6z7cp149m8j as HttpMethod,
+} from '../../../../../../ktor-ktor-http/io/ktor/http/HttpMethod.mjs';
+import { closeFinally1sadm0w9gt3u4 as closeFinally } from '../../../../../../kotlin-kotlin-stdlib/kotlin/AutoCloseableJs.mjs';
+import { unwrapCancellationException1zvbmufui4i9c as unwrapCancellationException } from '../../../../../../ktor-ktor-client-core/io/ktor/client/utils/ExceptionUtils.nonJvm.mjs';
+import { CancellationException3b36o9qz53rgr as CancellationException } from '../../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs';
+import { RequestResponseBuilder3ogeff86bzsnw as RequestResponseBuilder } from '../../../../../../ktor-ktor-http-cio/io/ktor/http/cio/RequestResponseBuilderJs.mjs';
+import {
+  URLBuilder1hwx1b9569i61 as URLBuilder,
+  get_fullPath1nnuhxveoo485 as get_fullPath,
+  get_hostWithPort2ab9xqdozpn7k as get_hostWithPort,
+} from '../../../../../../ktor-ktor-http/io/ktor/http/URLUtils.mjs';
+import { set_encodedPath3q0i8nsv3a7qy as set_encodedPath } from '../../../../../../ktor-ktor-http/io/ktor/http/URLBuilder.mjs';
+import { mergeHeadersub4y73mj759y as mergeHeaders } from '../../../../../../ktor-ktor-client-core/io/ktor/client/engine/Utils.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function handleHalfClosed(_this__u8e3s4, coroutineContext, propagateClose) {
+  return propagateClose ? _this__u8e3s4 : withoutClosePropagation(_this__u8e3s4, coroutineContext);
+}
+function expectContinue(expectHeader, body) {
+  var tmp;
+  if (!(expectHeader == null)) {
+    tmp = !(body instanceof NoContent());
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function writeRequest(request, output, callContext, overProxy, closeChannel, $completion) {
+  closeChannel = closeChannel === VOID ? true : closeChannel;
+  return withContext(callContext, writeRequest$slambda_0(request, output, overProxy, closeChannel, callContext, null), $completion);
+}
+function readResponse(requestTime, request, input, output, callContext, $completion) {
+  return withContext(callContext, readResponse$slambda_0(input, output, callContext, requestTime, request, null), $completion);
+}
+function writeHeaders(request, output, overProxy, closeChannel, $completion) {
+  closeChannel = closeChannel === VOID ? true : closeChannel;
+  var tmp = new ($writeHeadersCOROUTINE$())(request, output, overProxy, closeChannel, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function writeBody(request, output, callContext, closeChannel, $completion) {
+  closeChannel = closeChannel === VOID ? true : closeChannel;
+  var body = getUnwrapped(request.f56_1);
+  if (body instanceof NoContent()) {
+    if (closeChannel) {
+      close(output);
+    }
+    return Unit_instance;
+  }
+  if (body instanceof ProtocolUpgrade()) {
+    throw UnsupportedContentTypeException().z54(body);
+  }
+  var tmp0_elvis_lhs = request.e56_1.o3r(HttpHeaders_getInstance().h41_1);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var tmp1_safe_receiver = body.f4b();
+    tmp = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.toString();
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var contentLength = tmp;
+  var contentEncoding = request.e56_1.o3r(HttpHeaders_getInstance().o43_1);
+  var responseEncoding = body.l45().o3r(HttpHeaders_getInstance().o43_1);
+  var chunked = isChunked(contentLength, responseEncoding, contentEncoding);
+  var chunkedJob = chunked ? encodeChunked(output, callContext) : null;
+  var tmp3_elvis_lhs = chunkedJob == null ? null : chunkedJob.p3g_1;
+  var channel = tmp3_elvis_lhs == null ? output : tmp3_elvis_lhs;
+  var scope = CoroutineScope(callContext.lm(new (CoroutineName())('cio-client-body-writer')));
+  launch(scope, VOID, VOID, writeBody$slambda_0(request, body, channel, chunkedJob, output, closeChannel, null));
+  return Unit_instance;
+}
+function startTunnel(request, output, input, $completion) {
+  var tmp = new ($startTunnelCOROUTINE$())(request, output, input, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function withoutClosePropagation(_this__u8e3s4, coroutineContext, closeOnCoroutineCompletion) {
+  closeOnCoroutineCompletion = closeOnCoroutineCompletion === VOID ? true : closeOnCoroutineCompletion;
+  if (closeOnCoroutineCompletion) {
+    var tmp = get_job(coroutineContext);
+    tmp.v1y(withoutClosePropagation$lambda(_this__u8e3s4));
+  }
+  var tmp_0 = GlobalScope_instance;
+  return reader(tmp_0, coroutineContext, true, withoutClosePropagation$slambda_0(_this__u8e3s4, null)).p3g_1;
+}
+function toMap(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  var result = LinkedHashMap().ub();
+  var _iterator__ex2g4s = _this__u8e3s4.f4h().d1();
+  while (_iterator__ex2g4s.e1()) {
+    var offset = _iterator__ex2g4s.f1();
+    var key = toString(_this__u8e3s4.n4h(offset));
+    var value = toString(_this__u8e3s4.e4h(offset));
+    var tmp0_safe_receiver = result.w2(key);
+    if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.m(value)) == null) {
+      // Inline function 'kotlin.collections.set' call
+      var value_0 = mutableListOf([value]);
+      result.d3(key, value_0);
+    }
+  }
+  return result;
+}
+function isInformational(_this__u8e3s4) {
+  return (_this__u8e3s4.h48_1 / 100 | 0) === 1;
+}
+function isChunked(contentLength, responseEncoding, contentEncoding) {
+  return contentLength == null || responseEncoding === 'chunked' || contentEncoding === 'chunked';
+}
+function getUnwrapped(_this__u8e3s4) {
+  var tmp;
+  if (_this__u8e3s4 instanceof ContentWrapper()) {
+    tmp = getUnwrapped(_this__u8e3s4.p4b());
+  } else {
+    tmp = _this__u8e3s4;
+  }
+  return tmp;
+}
+function processOutgoingContent(request, body, channel, $completion) {
+  var tmp = new ($processOutgoingContentCOROUTINE$())(request, body, channel, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var writeRequest$slambdaClass;
+function writeRequest$slambda() {
+  if (writeRequest$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($request, $output, $overProxy, $closeChannel, $callContext, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.z7b_1 = $request;
+        $box.a7c_1 = $output;
+        $box.b7c_1 = $overProxy;
+        $box.c7c_1 = $closeChannel;
+        $box.d7c_1 = $callContext;
+        super(resultContinuation, $box);
+      }
+      l37($this$withContext, $completion) {
+        var tmp = this.p35($this$withContext, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.l37((!(p1 == null) ? isInterface(p1, CoroutineScope_0()) : false) ? 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;
+                this.ac_1 = 1;
+                suspendResult = writeHeaders(this.z7b_1, this.a7c_1, this.b7c_1, this.c7c_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.ac_1 = 2;
+                suspendResult = writeBody(this.z7b_1, this.a7c_1, this.d7c_1, VOID, 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);
+      }
+      p35($this$withContext, completion) {
+        var i = new (writeRequest$slambda())(this.z7b_1, this.a7c_1, this.b7c_1, this.c7c_1, this.d7c_1, completion);
+        i.e7c_1 = $this$withContext;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    writeRequest$slambdaClass = $;
+  }
+  return writeRequest$slambdaClass;
+}
+function writeRequest$slambda_0($request, $output, $overProxy, $closeChannel, $callContext, resultContinuation) {
+  var i = new (writeRequest$slambda())($request, $output, $overProxy, $closeChannel, $callContext, resultContinuation);
+  var l = function ($this$withContext, $completion) {
+    return i.l37($this$withContext, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var readResponse$slambda$slambdaClass;
+function readResponse$slambda$slambda() {
+  if (readResponse$slambda$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($version, $contentLength, $transferEncoding, $connectionType, $input, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.n7c_1 = $version;
+        $box.o7c_1 = $contentLength;
+        $box.p7c_1 = $transferEncoding;
+        $box.q7c_1 = $connectionType;
+        $box.r7c_1 = $input;
+        super(resultContinuation, $box);
+      }
+      l4l($this$writer, $completion) {
+        var tmp = this.m4l($this$writer, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.l4l(p1 instanceof WriterScope() ? 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 = 2;
+                this.ac_1 = 1;
+                suspendResult = parseHttpBody(this.n7c_1, this.o7c_1, this.p7c_1, this.q7c_1, this.r7c_1, this.s7c_1.v3m_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);
+      }
+      m4l($this$writer, completion) {
+        var i = new (readResponse$slambda$slambda())(this.n7c_1, this.o7c_1, this.p7c_1, this.q7c_1, this.r7c_1, completion);
+        i.s7c_1 = $this$writer;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    readResponse$slambda$slambdaClass = $;
+  }
+  return readResponse$slambda$slambdaClass;
+}
+function readResponse$slambda$slambda_0($version, $contentLength, $transferEncoding, $connectionType, $input, resultContinuation) {
+  var i = new (readResponse$slambda$slambda())($version, $contentLength, $transferEncoding, $connectionType, $input, resultContinuation);
+  var l = function ($this$writer, $completion) {
+    return i.l4l($this$writer, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var readResponse$slambdaClass;
+function readResponse$slambda() {
+  if (readResponse$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($input, $output, $callContext, $requestTime, $request, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.b7d_1 = $input;
+        $box.c7d_1 = $output;
+        $box.d7d_1 = $callContext;
+        $box.e7d_1 = $requestTime;
+        $box.f7d_1 = $request;
+        super(resultContinuation, $box);
+      }
+      o57($this$withContext, $completion) {
+        var tmp = this.p35($this$withContext, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.o57((!(p1 == null) ? isInterface(p1, CoroutineScope_0()) : false) ? 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 = 2;
+                this.ac_1 = 1;
+                suspendResult = parseResponse(this.b7d_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var tmp0_elvis_lhs = suspendResult;
+                var tmp_0;
+                if (tmp0_elvis_lhs == null) {
+                  throw ClosedReadChannelException().n38(EOFException().y2q('Failed to parse HTTP response: the server prematurely closed the connection'));
+                } else {
+                  tmp_0 = tmp0_elvis_lhs;
+                }
+
+                var rawResponse = tmp_0;
+                l$ret$7: do {
+                  var exception = null;
+                  l$ret$5: do {
+                    l$ret$3: do {
+                      var tmp$ret$0;
+                      l$ret$1: do {
+                        var tmp_1;
+                        try {
+                          var tmp_2;
+                          try {
+                            var status = new (HttpStatusCode())(rawResponse.v4m_1, toString(rawResponse.w4m_1));
+                            var tmp0_safe_receiver = rawResponse.x4m_1.o3r(HttpHeaders_getInstance().h41_1);
+                            var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : toString(tmp0_safe_receiver);
+                            var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : toLong(tmp1_safe_receiver);
+                            var contentLength = tmp2_elvis_lhs == null ? new (Long())(-1, -1) : tmp2_elvis_lhs;
+                            var tmp3_safe_receiver = rawResponse.x4m_1.o3r(HttpHeaders_getInstance().o43_1);
+                            var transferEncoding = tmp3_safe_receiver == null ? null : toString(tmp3_safe_receiver);
+                            var connectionType = Companion_getInstance_0().n4f(rawResponse.x4m_1.o3r(HttpHeaders_getInstance().d41_1));
+                            var rawHeaders = rawResponse.x4m_1;
+                            var headers = new (HeadersImpl())(toMap(rawHeaders));
+                            var version = Companion_getInstance_1().h1l(rawResponse.u4m_1);
+                            if (status.equals(Companion_getInstance().f46_1)) {
+                              var session = RawWebSocket(this.b7d_1, this.c7d_1, VOID, true, this.d7d_1);
+                              tmp$ret$0 = new (HttpResponseData())(status, this.e7d_1, headers, version, session, this.d7d_1);
+                              break l$ret$1;
+                            }
+                            var tmp_3;
+                            if (this.f7d_1.d56_1.equals(Companion_getInstance_3().r45_1) || listOf([Companion_getInstance().t46_1, Companion_getInstance().l46_1]).q2(status) || isInformational(status)) {
+                              tmp_3 = Companion_getInstance_2().t3c_1;
+                            } else {
+                              var coroutineScope = CoroutineScope(this.d7d_1.lm(new (CoroutineName())('cio-client-body-reader')));
+                              var httpBodyParser = writer(coroutineScope, VOID, true, readResponse$slambda$slambda_0(version, contentLength, transferEncoding, connectionType, this.b7d_1, null));
+                              tmp_3 = httpBodyParser.t3m_1;
+                            }
+                            var body = tmp_3;
+                            var tmp4_safe_receiver = this.f7d_1.h56_1.e3r(get_ResponseAdapterAttributeKey());
+                            var tmp5_elvis_lhs = tmp4_safe_receiver == null ? null : tmp4_safe_receiver.f5w(this.f7d_1, status, headers, body, this.f7d_1.f56_1, this.d7d_1);
+                            var responseBody = tmp5_elvis_lhs == null ? body : tmp5_elvis_lhs;
+                            tmp$ret$0 = new (HttpResponseData())(status, this.e7d_1, headers, version, responseBody, this.d7d_1);
+                            break l$ret$1;
+                          } catch ($p) {
+                            var tmp_4;
+                            if ($p instanceof Error) {
+                              var e = $p;
+                              exception = e;
+                              throw e;
+                            } else {
+                              throw $p;
+                            }
+                          }
+                        } catch ($p) {
+                          var tmp_5;
+                          var t = $p;
+                          closeFinally(rawResponse, exception);
+                          throw t;
+                        }
+                      }
+                       while (false);
+                      var tmp_6 = tmp$ret$0;
+                      closeFinally(rawResponse, exception);
+                      return tmp_6;
+                    }
+                     while (false);
+                    closeFinally(rawResponse, exception);
+                    break l$ret$7;
+                  }
+                   while (false);
+                  closeFinally(rawResponse, exception);
+                }
+                 while (false);
+                return Unit_instance;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e_0 = $p;
+            if (this.bc_1 === 2) {
+              throw e_0;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e_0;
+            }
+          }
+         while (true);
+      }
+      p35($this$withContext, completion) {
+        var i = new (readResponse$slambda())(this.b7d_1, this.c7d_1, this.d7d_1, this.e7d_1, this.f7d_1, completion);
+        i.g7d_1 = $this$withContext;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    readResponse$slambdaClass = $;
+  }
+  return readResponse$slambdaClass;
+}
+function readResponse$slambda_0($input, $output, $callContext, $requestTime, $request, resultContinuation) {
+  var i = new (readResponse$slambda())($input, $output, $callContext, $requestTime, $request, resultContinuation);
+  var l = function ($this$withContext, $completion) {
+    return i.o57($this$withContext, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function writeHeaders$lambda($builder) {
+  return function (key, value) {
+    var tmp;
+    if (key === HttpHeaders_getInstance().h41_1 || key === HttpHeaders_getInstance().s41_1) {
+      return Unit_instance;
+    }
+    $builder.b4o(key, value);
+    return Unit_instance;
+  };
+}
+var writeBody$slambdaClass;
+function writeBody$slambda() {
+  if (writeBody$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($request, $body, $channel, $chunkedJob, $output, $closeChannel, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.p7d_1 = $request;
+        $box.q7d_1 = $body;
+        $box.r7d_1 = $channel;
+        $box.s7d_1 = $chunkedJob;
+        $box.t7d_1 = $output;
+        $box.u7d_1 = $closeChannel;
+        super(resultContinuation, $box);
+      }
+      l37($this$launch, $completion) {
+        var tmp = this.p35($this$launch, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.l37((!(p1 == null) ? isInterface(p1, CoroutineScope_0()) : false) ? 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 = 12;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 4;
+                this.bc_1 = 3;
+                this.ac_1 = 2;
+                suspendResult = processOutgoingContent(this.p7d_1, this.q7d_1, this.r7d_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.w7d_1 = suspendResult;
+                this.bc_1 = 12;
+                this.ac_1 = 8;
+                continue $sm;
+              case 3:
+                this.bc_1 = 4;
+                var tmp_0 = this.dc_1;
+                if (tmp_0 instanceof Error) {
+                  this.x7d_1 = this.dc_1;
+                  var tmp_1 = this;
+                  close_0(this.r7d_1, this.x7d_1);
+                  throw this.x7d_1;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 4:
+                this.bc_1 = 12;
+                this.y7d_1 = this.dc_1;
+                this.ac_1 = 5;
+                suspendResult = this.r7d_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 5:
+                var tmp0_safe_receiver = this.s7d_1;
+                var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p3g_1;
+                if (tmp1_safe_receiver == null)
+                  null;
+                else {
+                  close(tmp1_safe_receiver);
+                }
+
+                this.z7d_1 = this.s7d_1;
+                if (this.z7d_1 == null) {
+                  this.a7e_1 = null;
+                  this.ac_1 = 7;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 6;
+                  suspendResult = join(this.z7d_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                }
+
+              case 6:
+                var tmp_2 = this;
+                tmp_2.a7e_1 = Unit_instance;
+                this.ac_1 = 7;
+                continue $sm;
+              case 7:
+                var tmp3_safe_receiver = this.t7d_1.r3a();
+                var tmp4_safe_receiver = tmp3_safe_receiver == null ? null : unwrapCancellationException(tmp3_safe_receiver);
+                var tmp_3;
+                if (tmp4_safe_receiver == null) {
+                  tmp_3 = null;
+                } else {
+                  var tmp_4;
+                  if (!(tmp4_safe_receiver instanceof CancellationException())) {
+                    tmp_4 = tmp4_safe_receiver;
+                  } else {
+                    tmp_4 = null;
+                  }
+                  tmp_3 = tmp_4;
+                }
+
+                var tmp5_safe_receiver = tmp_3;
+                if (tmp5_safe_receiver == null)
+                  null;
+                else {
+                  throw tmp5_safe_receiver;
+                }
+
+                if (this.u7d_1) {
+                  close(this.t7d_1);
+                }
+
+                throw this.y7d_1;
+              case 8:
+                this.bc_1 = 12;
+                this.ac_1 = 9;
+                suspendResult = this.r7d_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 9:
+                var tmp0_safe_receiver_0 = this.s7d_1;
+                var tmp1_safe_receiver_0 = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.p3g_1;
+                if (tmp1_safe_receiver_0 == null)
+                  null;
+                else {
+                  close(tmp1_safe_receiver_0);
+                }
+
+                this.b7e_1 = this.s7d_1;
+                if (this.b7e_1 == null) {
+                  this.c7e_1 = null;
+                  this.ac_1 = 11;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 10;
+                  suspendResult = join(this.b7e_1, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                }
+
+              case 10:
+                var tmp_5 = this;
+                tmp_5.c7e_1 = Unit_instance;
+                this.ac_1 = 11;
+                continue $sm;
+              case 11:
+                var tmp3_safe_receiver_0 = this.t7d_1.r3a();
+                var tmp4_safe_receiver_0 = tmp3_safe_receiver_0 == null ? null : unwrapCancellationException(tmp3_safe_receiver_0);
+                var tmp_6;
+                if (tmp4_safe_receiver_0 == null) {
+                  tmp_6 = null;
+                } else {
+                  var tmp_7;
+                  if (!(tmp4_safe_receiver_0 instanceof CancellationException())) {
+                    tmp_7 = tmp4_safe_receiver_0;
+                  } else {
+                    tmp_7 = null;
+                  }
+                  tmp_6 = tmp_7;
+                }
+
+                var tmp5_safe_receiver_0 = tmp_6;
+                if (tmp5_safe_receiver_0 == null)
+                  null;
+                else {
+                  throw tmp5_safe_receiver_0;
+                }
+
+                if (this.u7d_1) {
+                  close(this.t7d_1);
+                }
+
+                return Unit_instance;
+              case 12:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 12) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$launch, completion) {
+        var i = new (writeBody$slambda())(this.p7d_1, this.q7d_1, this.r7d_1, this.s7d_1, this.t7d_1, this.u7d_1, completion);
+        i.v7d_1 = $this$launch;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    writeBody$slambdaClass = $;
+  }
+  return writeBody$slambdaClass;
+}
+function writeBody$slambda_0($request, $body, $channel, $chunkedJob, $output, $closeChannel, resultContinuation) {
+  var i = new (writeBody$slambda())($request, $body, $channel, $chunkedJob, $output, $closeChannel, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.l37($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function withoutClosePropagation$lambda($this_withoutClosePropagation) {
+  return function (it) {
+    close_0($this_withoutClosePropagation, it);
+    return Unit_instance;
+  };
+}
+var withoutClosePropagation$slambdaClass;
+function withoutClosePropagation$slambda() {
+  if (withoutClosePropagation$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($this_withoutClosePropagation, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.l7e_1 = $this_withoutClosePropagation;
+        super(resultContinuation, $box);
+      }
+      a4f($this$reader, $completion) {
+        var tmp = this.b4f($this$reader, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.a4f(p1 instanceof ReaderScope() ? 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;
+                this.ac_1 = 1;
+                suspendResult = copyTo(this.m7e_1.r3g_1, this.l7e_1, new (Long())(-1, 2147483647), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.ac_1 = 2;
+                suspendResult = this.l7e_1.l3a(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);
+      }
+      b4f($this$reader, completion) {
+        var i = new (withoutClosePropagation$slambda())(this.l7e_1, completion);
+        i.m7e_1 = $this$reader;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    withoutClosePropagation$slambdaClass = $;
+  }
+  return withoutClosePropagation$slambdaClass;
+}
+function withoutClosePropagation$slambda_0($this_withoutClosePropagation, resultContinuation) {
+  var i = new (withoutClosePropagation$slambda())($this_withoutClosePropagation, resultContinuation);
+  var l = function ($this$reader, $completion) {
+    return i.a4f($this$reader, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var $writeHeadersCOROUTINE$Class;
+function $writeHeadersCOROUTINE$() {
+  if ($writeHeadersCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(request, output, overProxy, closeChannel, resultContinuation) {
+        super(resultContinuation);
+        this.i79_1 = request;
+        this.j79_1 = output;
+        this.k79_1 = overProxy;
+        this.l79_1 = closeChannel;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 9;
+                this.m79_1 = new (RequestResponseBuilder())();
+                this.n79_1 = this.i79_1.d56_1;
+                this.o79_1 = this.i79_1.c56_1;
+                this.p79_1 = this.i79_1.e56_1;
+                this.q79_1 = this.i79_1.f56_1;
+                var tmp_0 = this;
+                var tmp0_elvis_lhs = this.p79_1.o3r(HttpHeaders_getInstance().h41_1);
+                var tmp_1;
+                if (tmp0_elvis_lhs == null) {
+                  var tmp1_safe_receiver = this.q79_1.f4b();
+                  tmp_1 = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.toString();
+                } else {
+                  tmp_1 = tmp0_elvis_lhs;
+                }
+
+                tmp_0.r79_1 = tmp_1;
+                this.s79_1 = this.p79_1.o3r(HttpHeaders_getInstance().o43_1);
+                this.t79_1 = this.q79_1.l45().o3r(HttpHeaders_getInstance().o43_1);
+                this.u79_1 = isChunked(this.r79_1, this.t79_1, this.s79_1);
+                this.v79_1 = this.p79_1.o3r(HttpHeaders_getInstance().s41_1);
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 8;
+                this.bc_1 = 4;
+                var tmp_2 = this;
+                var tmp_3;
+                if (this.o79_1.j49_1.j()) {
+                  var this_0 = URLBuilder(this.o79_1);
+                  set_encodedPath(this_0, '/');
+                  tmp_3 = this_0.z1i();
+                } else {
+                  tmp_3 = this.o79_1;
+                }
+
+                tmp_2.x79_1 = tmp_3;
+                this.y79_1 = this.k79_1 ? this.x79_1.toString() : get_fullPath(this.x79_1);
+                this.m79_1.a4o(this.n79_1, this.y79_1, Companion_getInstance_1().w45_1.toString());
+                if (!this.p79_1.v3s(HttpHeaders_getInstance().w41_1)) {
+                  var tmp_4;
+                  if (this.o79_1.m49_1.y48_1 === this.o79_1.s4a()) {
+                    tmp_4 = this.o79_1.a49_1;
+                  } else {
+                    tmp_4 = get_hostWithPort(this.o79_1);
+                  }
+                  var host = tmp_4;
+                  this.m79_1.b4o(HttpHeaders_getInstance().w41_1, host);
+                }
+
+                var tmp_5 = this;
+                var tmp_6 = this.q79_1;
+                tmp_5.z79_1 = !(tmp_6 instanceof NoContent());
+                if (!(this.r79_1 == null)) {
+                  if (get_supportsRequestBody(this.n79_1) || this.z79_1) {
+                    this.m79_1.b4o(HttpHeaders_getInstance().h41_1, this.r79_1);
+                  }
+                }
+
+                mergeHeaders(this.p79_1, this.q79_1, writeHeaders$lambda(this.m79_1));
+                var tmp_7;
+                if (this.u79_1 && this.s79_1 == null && this.t79_1 == null) {
+                  var tmp_8 = this.q79_1;
+                  tmp_7 = !(tmp_8 instanceof NoContent());
+                } else {
+                  tmp_7 = false;
+                }
+
+                if (tmp_7) {
+                  this.m79_1.b4o(HttpHeaders_getInstance().o43_1, 'chunked');
+                }
+
+                if (expectContinue(this.v79_1, this.q79_1)) {
+                  this.m79_1.b4o(HttpHeaders_getInstance().s41_1, ensureNotNull(this.v79_1));
+                }
+
+                this.m79_1.c4o();
+                this.ac_1 = 2;
+                suspendResult = writePacket(this.j79_1, this.m79_1.z1i(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 3;
+                suspendResult = this.j79_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 3:
+                this.w79_1 = suspendResult;
+                this.bc_1 = 9;
+                this.ac_1 = 7;
+                continue $sm;
+              case 4:
+                this.bc_1 = 8;
+                var tmp_9 = this.dc_1;
+                if (tmp_9 instanceof Error) {
+                  this.a7a_1 = this.dc_1;
+                  if (this.l79_1) {
+                    this.ac_1 = 5;
+                    suspendResult = this.j79_1.w3a(this);
+                    if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                      return suspendResult;
+                    }
+                    continue $sm;
+                  } else {
+                    this.ac_1 = 6;
+                    continue $sm;
+                  }
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 5:
+                this.ac_1 = 6;
+                continue $sm;
+              case 6:
+                var tmp_10 = this;
+                throw this.a7a_1;
+              case 7:
+                this.bc_1 = 9;
+                this.m79_1.y2n();
+                return Unit_instance;
+              case 8:
+                this.bc_1 = 9;
+                var t = this.dc_1;
+                this.m79_1.y2n();
+                throw t;
+              case 9:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 9) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $writeHeadersCOROUTINE$Class = $;
+  }
+  return $writeHeadersCOROUTINE$Class;
+}
+var $startTunnelCOROUTINE$Class;
+function $startTunnelCOROUTINE$() {
+  if ($startTunnelCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(request, output, input, resultContinuation) {
+        super(resultContinuation);
+        this.j7a_1 = request;
+        this.k7a_1 = output;
+        this.l7a_1 = input;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 17;
+                this.m7a_1 = new (RequestResponseBuilder())();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 16;
+                this.o7a_1 = get_hostWithPort(this.j7a_1.c56_1);
+                this.m7a_1.a4o(new (HttpMethod())('CONNECT'), this.o7a_1, Companion_getInstance_1().w45_1.toString());
+                this.m7a_1.b4o(HttpHeaders_getInstance().w41_1, this.o7a_1);
+                this.m7a_1.b4o('Proxy-Connection', 'Keep-Alive');
+                var tmp0_safe_receiver = this.j7a_1.e56_1.o3r(HttpHeaders_getInstance().q43_1);
+                if (tmp0_safe_receiver == null)
+                  null;
+                else {
+                  this.m7a_1.b4o(HttpHeaders_getInstance().q43_1, tmp0_safe_receiver);
+                }
+
+                var tmp1_safe_receiver = this.j7a_1.e56_1.o3r(HttpHeaders_getInstance().s42_1);
+                if (tmp1_safe_receiver == null)
+                  null;
+                else {
+                  this.m7a_1.b4o(HttpHeaders_getInstance().s42_1, tmp1_safe_receiver);
+                }
+
+                var tmp2_safe_receiver = this.j7a_1.e56_1.o3r(HttpHeaders_getInstance().u42_1);
+                if (tmp2_safe_receiver == null)
+                  null;
+                else {
+                  this.m7a_1.b4o(HttpHeaders_getInstance().u42_1, tmp2_safe_receiver);
+                }
+
+                this.m7a_1.c4o();
+                this.ac_1 = 2;
+                suspendResult = writePacket(this.k7a_1, this.m7a_1.z1i(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 3;
+                suspendResult = this.k7a_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 3:
+                this.ac_1 = 4;
+                suspendResult = parseResponse(this.l7a_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 4:
+                this.p7a_1 = suspendResult;
+                var tmp_0 = this;
+                var tmp_1;
+                if (this.p7a_1 == null) {
+                  throw ClosedReadChannelException().n38(EOFException().y2q('Failed to parse CONNECT response: unexpected EOF'));
+                } else {
+                  tmp_1 = this.p7a_1;
+                }
+
+                tmp_0.q7a_1 = tmp_1;
+                var tmp_2 = this;
+                tmp_2.r7a_1 = this.q7a_1;
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                this.t7a_1 = this.r7a_1;
+                this.u7a_1 = null;
+                this.ac_1 = 6;
+                continue $sm;
+              case 6:
+                this.ac_1 = 7;
+                continue $sm;
+              case 7:
+                this.bc_1 = 12;
+                this.bc_1 = 11;
+                var tmp_3 = this;
+                tmp_3.w7a_1 = this.t7a_1;
+                this.x7a_1 = this.w7a_1;
+                if (!((this.q7a_1.v4m_1 / 200 | 0) === 1)) {
+                  throw IOException().l2u('Can not establish tunnel connection');
+                }
+
+                this.y7a_1 = this.q7a_1.x4m_1.o3r(HttpHeaders_getInstance().h41_1);
+                if (this.y7a_1 == null) {
+                  this.z7a_1 = null;
+                  this.ac_1 = 9;
+                  continue $sm;
+                } else {
+                  var tmp_4 = this;
+                  tmp_4.a7b_1 = this.y7a_1;
+                  this.b7b_1 = this.a7b_1;
+                  var tmp_5 = this;
+                  tmp_5.c7b_1 = this.b7b_1;
+                  this.d7b_1 = this.c7b_1;
+                  this.ac_1 = 8;
+                  suspendResult = discard(this.l7a_1, toLong(toString(this.d7b_1)), this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                }
+
+              case 8:
+                this.z7a_1 = suspendResult;
+                this.ac_1 = 9;
+                continue $sm;
+              case 9:
+                this.v7a_1 = this.z7a_1;
+                this.ac_1 = 10;
+                var tmp_6 = this;
+                continue $sm;
+              case 10:
+                var tmp_7 = this.v7a_1;
+                this.bc_1 = 16;
+                closeFinally(this.t7a_1, this.u7a_1);
+                this.s7a_1 = tmp_7;
+                this.ac_1 = 14;
+                continue $sm;
+              case 11:
+                this.bc_1 = 12;
+                var tmp_8 = this.dc_1;
+                if (tmp_8 instanceof Error) {
+                  var e = this.dc_1;
+                  var tmp_9 = this;
+                  this.u7a_1 = e;
+                  throw e;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 12:
+                this.bc_1 = 16;
+                var t = this.dc_1;
+                closeFinally(this.t7a_1, this.u7a_1);
+                throw t;
+              case 13:
+                this.bc_1 = 16;
+                closeFinally(this.t7a_1, this.u7a_1);
+                if (false) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+                this.ac_1 = 14;
+                continue $sm;
+              case 14:
+                this.n7a_1 = this.s7a_1;
+                this.bc_1 = 17;
+                this.ac_1 = 15;
+                continue $sm;
+              case 15:
+                this.n7a_1;
+                this.bc_1 = 17;
+                this.m7a_1.y2n();
+                return Unit_instance;
+              case 16:
+                this.bc_1 = 17;
+                var t_0 = this.dc_1;
+                this.m7a_1.y2n();
+                throw t_0;
+              case 17:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e_0 = $p;
+            if (this.bc_1 === 17) {
+              throw e_0;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e_0;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $startTunnelCOROUTINE$Class = $;
+  }
+  return $startTunnelCOROUTINE$Class;
+}
+var $processOutgoingContentCOROUTINE$Class;
+function $processOutgoingContentCOROUTINE$() {
+  if ($processOutgoingContentCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(request, body, channel, resultContinuation) {
+        super(resultContinuation);
+        this.m7b_1 = request;
+        this.n7b_1 = body;
+        this.o7b_1 = channel;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 6;
+                this.p7b_1 = this.n7b_1;
+                var tmp_0 = this.p7b_1;
+                if (tmp_0 instanceof ByteArrayContent()) {
+                  this.ac_1 = 4;
+                  suspendResult = writeFully(this.o7b_1, this.n7b_1.g4b(), VOID, VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  var tmp_1 = this.p7b_1;
+                  if (tmp_1 instanceof ReadChannelContent()) {
+                    this.ac_1 = 3;
+                    suspendResult = copyAndClose(this.n7b_1.j4b(), this.o7b_1, this);
+                    if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                      return suspendResult;
+                    }
+                    continue $sm;
+                  } else {
+                    var tmp_2 = this.p7b_1;
+                    if (tmp_2 instanceof WriteChannelContent()) {
+                      this.ac_1 = 2;
+                      suspendResult = this.n7b_1.l4b(this.o7b_1, this);
+                      if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                        return suspendResult;
+                      }
+                      continue $sm;
+                    } else {
+                      var tmp_3 = this.p7b_1;
+                      if (tmp_3 instanceof ContentWrapper()) {
+                        this.ac_1 = 1;
+                        suspendResult = processOutgoingContent(this.m7b_1, this.n7b_1.p4b(), this.o7b_1, this);
+                        if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                          return suspendResult;
+                        }
+                        continue $sm;
+                      } else {
+                        var tmp_4 = this.p7b_1;
+                        if (tmp_4 instanceof ProtocolUpgrade()) {
+                          var tmp_5 = this;
+                          var message = 'unreachable code';
+                          throw IllegalStateException().o4(toString(message));
+                        } else {
+                          var tmp_6 = this.p7b_1;
+                          if (tmp_6 instanceof NoContent()) {
+                            var tmp_7 = this;
+                            var message_0 = 'unreachable code';
+                            throw IllegalStateException().o4(toString(message_0));
+                          } else {
+                            var tmp_8 = this;
+                            noWhenBranchMatchedException();
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+
+                break;
+              case 1:
+                var tmp_9 = this;
+                tmp_9.q7b_1 = Unit_instance;
+                this.ac_1 = 5;
+                continue $sm;
+              case 2:
+                var tmp_10 = this;
+                tmp_10.q7b_1 = Unit_instance;
+                this.ac_1 = 5;
+                continue $sm;
+              case 3:
+                this.q7b_1 = suspendResult;
+                this.ac_1 = 5;
+                continue $sm;
+              case 4:
+                var tmp_11 = this;
+                tmp_11.q7b_1 = Unit_instance;
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                return Unit_instance;
+              case 6:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 6) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $processOutgoingContentCOROUTINE$Class = $;
+  }
+  return $processOutgoingContentCOROUTINE$Class;
+}
+//region block: exports
+export {
+  readResponse as readResponse3pzkg6nmigx14,
+  startTunnel as startTunnel1d7yehxlf7rw4,
+  writeBody as writeBody1pf0c8yzqudeb,
+  writeHeaders as writeHeaders3cmofgdna8yuh,
+  writeRequest as writeRequest3kogzlmopewf4,
+  expectContinue as expectContinue3jqhf2bcc56gi,
+  handleHalfClosed as handleHalfClosed1fhienq61fie8,
+};
+//endregion
+
+//# sourceMappingURL=utils.mjs.map