@attocash/commons-js 5.0.0

package/ktor-ktor-io/io/ktor/utils/io/ByteReadChannelOperations.mjs

@@ -0,0 +1,1825 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import {
+  cancelChildren10wlln0b749a7 as cancelChildren,
+  get_job2zvlvce9o9a29 as get_job,
+  Job13y4jkazwjho0 as Job,
+  cancel1xim2hrvjmwpn as cancel,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Job.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { EmptyCoroutineContext_getInstance31fow51ayy30t as EmptyCoroutineContext_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import { ByteChannel3cxdguezl3lu7 as ByteChannel } from './ByteChannel.mjs';
+import { CoroutineScopefcb5f5dwqcas as CoroutineScope } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import {
+  Companion_getInstance2zbi981hww1p4 as Companion_getInstance,
+  LineEndingMode__toString_impl_j4h76r32i8wewde0kag as LineEndingMode__toString_impl_j4h76r,
+  LineEndingMode__contains_impl_q5pr682au50lo4lfj91 as LineEndingMode__contains_impl_q5pr68,
+} from './LineEndingMode.mjs';
+import { launch1c91vkjzdi9sd as launch } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs';
+import { onClose3ga65cfvm2yet as onClose } from './CloseHookByteWriteChannel.mjs';
+import { ByteChannelScanner1h148q1m3y1ey as ByteChannelScanner } from './ByteChannelScanner.mjs';
+import {
+  IOException1wyutdmfe71nu as IOException,
+  EOFExceptionh831u25jcq9n as EOFException,
+} from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/-PlatformJs.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { close3semq7pafb42g as close } from './ByteWriteChannelOperations.mjs';
+import { BytePacketBuilder2biodf4wxvlba as BytePacketBuilder } from './core/BytePacketBuilder.mjs';
+import {
+  get_remaining1lapv95kcmm0y as get_remaining,
+  discard3ugntd47xyll6 as discard,
+} from './core/ByteReadPacket.mjs';
+import { readAvailable27gpepp0hyyts as readAvailable } from './core/Input.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.mjs';
+import { readBytesj5m5qe40si0k as readBytes } from './core/Buffers.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { readStringo8i62qxt5m4m as readString } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Utf8.mjs';
+import { TooLongLineException2d6ls946t46wx as TooLongLineException } from './charsets/Encoding.mjs';
+import {
+  toLongw1zpgk99d84b as toLong,
+  numberToLong1a4cndvg6c52s as numberToLong,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { closeFinally1sadm0w9gt3u4 as closeFinally } from '../../../../../kotlin-kotlin-stdlib/kotlin/AutoCloseableJs.mjs';
+import { equals2au1ep9vhcato as equals } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { readByteString2hnsbql6t4ads as readByteString } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/ByteStrings.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function readRemaining(_this__u8e3s4, $completion) {
+  var tmp = new ($readRemainingCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function discard_0(_this__u8e3s4, max, $completion) {
+  max = max === VOID ? new (Long())(-1, 2147483647) : max;
+  var tmp = new ($discardCOROUTINE$())(_this__u8e3s4, max, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function copyAndClose(_this__u8e3s4, channel, $completion) {
+  var tmp = new ($copyAndCloseCOROUTINE$())(_this__u8e3s4, channel, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readAvailable_0(_this__u8e3s4, buffer, offset, length, $completion) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  var tmp = new ($readAvailableCOROUTINE$())(_this__u8e3s4, buffer, offset, length, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readUTF8Line(_this__u8e3s4, max, $completion) {
+  max = max === VOID ? 2147483647 : max;
+  var tmp = new ($readUTF8LineCOROUTINE$())(_this__u8e3s4, max, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function toByteArray(_this__u8e3s4, $completion) {
+  var tmp = new ($toByteArrayCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function copyTo(_this__u8e3s4, channel, limit, $completion) {
+  var tmp = new ($copyToCOROUTINE$())(_this__u8e3s4, channel, limit, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var $flushAndCloseCOROUTINE$Class;
+function $flushAndCloseCOROUTINE$() {
+  if ($flushAndCloseCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.i3g_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 5;
+                cancelChildren(this.i3g_1.q3g_1);
+                var tmp_0 = this;
+                tmp_0.j3g_1 = this.i3g_1.q3g_1.l1z();
+                this.k3g_1 = this.j3g_1;
+                this.l3g_1 = this.k3g_1.d1();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!this.l3g_1.e1()) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.m3g_1 = this.l3g_1.f1();
+                var tmp_1 = this;
+                tmp_1.n3g_1 = this.m3g_1;
+                this.o3g_1 = this.n3g_1;
+                this.ac_1 = 2;
+                suspendResult = this.o3g_1.z1y(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                this.ac_1 = 4;
+                suspendResult = this.i3g_1.p3g_1.w3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 4:
+                return Unit_instance;
+              case 5:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 5) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $flushAndCloseCOROUTINE$Class = $;
+  }
+  return $flushAndCloseCOROUTINE$Class;
+}
+var ReaderJobClass;
+function ReaderJob() {
+  if (ReaderJobClass === VOID) {
+    class $ {
+      constructor(channel, job) {
+        this.p3g_1 = channel;
+        this.q3g_1 = job;
+      }
+      i24() {
+        return this.q3g_1;
+      }
+      w3a($completion) {
+        var tmp = new ($flushAndCloseCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+    }
+    initMetadataForClass($, 'ReaderJob', VOID, VOID, VOID, [0]);
+    ReaderJobClass = $;
+  }
+  return ReaderJobClass;
+}
+function reader(_this__u8e3s4, coroutineContext, autoFlush, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_getInstance() : coroutineContext;
+  autoFlush = autoFlush === VOID ? false : autoFlush;
+  return reader_0(_this__u8e3s4, coroutineContext, new (ByteChannel())(), block);
+}
+var ReaderScopeClass;
+function ReaderScope() {
+  if (ReaderScopeClass === VOID) {
+    class $ {
+      constructor(channel, coroutineContext) {
+        this.r3g_1 = channel;
+        this.s3g_1 = coroutineContext;
+      }
+      s1x() {
+        return this.s3g_1;
+      }
+    }
+    initMetadataForClass($, 'ReaderScope', VOID, VOID, [CoroutineScope()]);
+    ReaderScopeClass = $;
+  }
+  return ReaderScopeClass;
+}
+function rethrowCloseCauseIfNeeded(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.r3a();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function get_availableForRead(_this__u8e3s4) {
+  return _this__u8e3s4.m3a().z2q().i1().c2();
+}
+function readUTF8LineTo(_this__u8e3s4, out, max, $completion) {
+  max = max === VOID ? 2147483647 : max;
+  return readUTF8LineTo_0(_this__u8e3s4, out, max, Companion_getInstance().w3g_1, $completion);
+}
+function readBuffer(_this__u8e3s4, $completion) {
+  var tmp = new ($readBufferCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function reader_0(_this__u8e3s4, coroutineContext, channel, block) {
+  // Inline function 'kotlin.apply' call
+  var this_0 = launch(_this__u8e3s4, coroutineContext, VOID, reader$slambda_0(block, channel, null));
+  this_0.v1y(reader$lambda(channel));
+  var job = this_0;
+  return new (ReaderJob())(onClose(channel, reader$slambda_2(job, null)), job);
+}
+function readUTF8LineTo_0(_this__u8e3s4, out, max, lineEnding, $completion) {
+  max = max === VOID ? 2147483647 : max;
+  lineEnding = lineEnding === VOID ? Companion_getInstance().w3g_1 : lineEnding;
+  var tmp = new ($readUTF8LineToCOROUTINE$())(_this__u8e3s4, out, max, lineEnding, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function rethrowCloseCauseIfNeeded_0(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.r3a();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function rethrowCloseCauseIfNeeded_1(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.r3a();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function skipIfFound(_this__u8e3s4, byteString, $completion) {
+  var tmp = new ($skipIfFoundCOROUTINE$())(_this__u8e3s4, byteString, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readPacket(_this__u8e3s4, packet, $completion) {
+  var tmp = new ($readPacketCOROUTINE$())(_this__u8e3s4, packet, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readUntil(_this__u8e3s4, matchString, writeChannel, limit, ignoreMissing, $completion) {
+  limit = limit === VOID ? new (Long())(-1, 2147483647) : limit;
+  ignoreMissing = ignoreMissing === VOID ? false : ignoreMissing;
+  return (new (ByteChannelScanner())(_this__u8e3s4, matchString, writeChannel, limit)).q3c(ignoreMissing, $completion);
+}
+function readByte(_this__u8e3s4, $completion) {
+  var tmp = new ($readByteCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readShort(_this__u8e3s4, $completion) {
+  var tmp = new ($readShortCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readLong(_this__u8e3s4, $completion) {
+  var tmp = new ($readLongCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readInt(_this__u8e3s4, $completion) {
+  var tmp = new ($readIntCOROUTINE$())(_this__u8e3s4, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function peek(_this__u8e3s4, count, $completion) {
+  var tmp = new ($peekCOROUTINE$())(_this__u8e3s4, count, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function awaitUntilReadable(_this__u8e3s4, numberOfBytes, $completion) {
+  var tmp = new ($awaitUntilReadableCOROUTINE$())(_this__u8e3s4, numberOfBytes, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+function readUTF8LineTo$checkLineEndingAllowed($lineEnding, lineEndingToCheck) {
+  if (!LineEndingMode__contains_impl_q5pr68($lineEnding, lineEndingToCheck)) {
+    throw IOException().l2u('Unexpected line ending ' + LineEndingMode__toString_impl_j4h76r(lineEndingToCheck) + ', while expected ' + LineEndingMode__toString_impl_j4h76r($lineEnding));
+  }
+}
+var reader$slambdaClass;
+function reader$slambda() {
+  if (reader$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($block, $channel, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.m3l_1 = $block;
+        $box.n3l_1 = $channel;
+        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()) : 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 = 8;
+                this.p3l_1 = Job(get_job(this.o3l_1.s1x()));
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 4;
+                this.bc_1 = 3;
+                this.ac_1 = 2;
+                suspendResult = this.m3l_1(new (ReaderScope())(this.n3l_1, this.o3l_1.s1x().lm(this.p3l_1)), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.p3l_1.d25();
+                var tmp_0 = this;
+                var tmp_1;
+                if (get_job(this.o3l_1.s1x()).p1y()) {
+                  this.n3l_1.x3a(get_job(this.o3l_1.s1x()).s1y());
+                  tmp_1 = Unit_instance;
+                }
+
+                tmp_0.q3l_1 = tmp_1;
+                this.bc_1 = 8;
+                this.ac_1 = 6;
+                continue $sm;
+              case 3:
+                this.bc_1 = 4;
+                var tmp_2 = this.dc_1;
+                if (tmp_2 instanceof Error) {
+                  this.r3l_1 = this.dc_1;
+                  var tmp_3 = this;
+                  cancel(this.p3l_1, 'Exception thrown while reading from channel', this.r3l_1);
+                  close(this.n3l_1, this.r3l_1);
+                  tmp_3.q3l_1 = Unit_instance;
+                  this.bc_1 = 8;
+                  this.ac_1 = 6;
+                  continue $sm;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 4:
+                this.bc_1 = 8;
+                this.s3l_1 = this.dc_1;
+                this.ac_1 = 5;
+                suspendResult = this.p3l_1.z1y(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 5:
+                throw this.s3l_1;
+              case 6:
+                this.bc_1 = 8;
+                this.ac_1 = 7;
+                suspendResult = this.p3l_1.z1y(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 7:
+                return Unit_instance;
+              case 8:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 8) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$launch, completion) {
+        var i = new (reader$slambda())(this.m3l_1, this.n3l_1, completion);
+        i.o3l_1 = $this$launch;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    reader$slambdaClass = $;
+  }
+  return reader$slambdaClass;
+}
+function reader$slambda_0($block, $channel, resultContinuation) {
+  var i = new (reader$slambda())($block, $channel, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.l37($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function reader$lambda($channel) {
+  return function (it) {
+    var tmp;
+    if (!(it == null) && !$channel.t3a()) {
+      $channel.x3a(it);
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+var reader$slambdaClass_0;
+function reader$slambda_1() {
+  if (reader$slambdaClass_0 === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor($job, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.b3m_1 = $job;
+        super(resultContinuation, $box);
+      }
+      c3m($completion) {
+        var tmp = this.d3m($completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      pe($completion) {
+        return this.c3m($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 = this.b3m_1.z1y(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);
+      }
+      d3m(completion) {
+        return new (reader$slambda_1())(this.b3m_1, completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    reader$slambdaClass_0 = $;
+  }
+  return reader$slambdaClass_0;
+}
+function reader$slambda_2($job, resultContinuation) {
+  var i = new (reader$slambda_1())($job, resultContinuation);
+  var l = function ($completion) {
+    return i.c3m($completion);
+  };
+  l.$arity = 0;
+  return l;
+}
+var $readRemainingCOROUTINE$Class;
+function $readRemainingCOROUTINE$() {
+  if ($readRemainingCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.c3d_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                this.d3d_1 = BytePacketBuilder();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!!this.c3d_1.t3a()) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.d3d_1.w2s(this.c3d_1.m3a());
+                this.ac_1 = 2;
+                suspendResult = this.c3d_1.v3a(VOID, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                rethrowCloseCauseIfNeeded(this.c3d_1);
+                return this.d3d_1.z2q();
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $readRemainingCOROUTINE$Class = $;
+  }
+  return $readRemainingCOROUTINE$Class;
+}
+var $discardCOROUTINE$Class;
+function $discardCOROUTINE$() {
+  if ($discardCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, max, resultContinuation) {
+        super(resultContinuation);
+        this.m3d_1 = _this__u8e3s4;
+        this.n3d_1 = max;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 5;
+                this.o3d_1 = this.n3d_1;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!(this.o3d_1.a2(new (Long())(0, 0)) > 0 && !this.m3d_1.t3a())) {
+                  this.ac_1 = 4;
+                  continue $sm;
+                }
+
+                if (get_availableForRead(this.m3d_1) === 0) {
+                  this.ac_1 = 2;
+                  suspendResult = this.m3d_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 2:
+                this.ac_1 = 3;
+                continue $sm;
+              case 3:
+                var tmp0 = this.o3d_1;
+                var b = get_remaining(this.m3d_1.m3a());
+                var count = tmp0.a2(b) <= 0 ? tmp0 : b;
+                discard(this.m3d_1.m3a(), count);
+                this.o3d_1 = this.o3d_1.q3(count);
+                this.ac_1 = 1;
+                continue $sm;
+              case 4:
+                return this.n3d_1.q3(this.o3d_1);
+              case 5:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 5) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $discardCOROUTINE$Class = $;
+  }
+  return $discardCOROUTINE$Class;
+}
+var $copyAndCloseCOROUTINE$Class;
+function $copyAndCloseCOROUTINE$() {
+  if ($copyAndCloseCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, channel, resultContinuation) {
+        super(resultContinuation);
+        this.x3d_1 = _this__u8e3s4;
+        this.y3d_1 = channel;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 11;
+                this.z3d_1 = new (Long())(0, 0);
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 7;
+                this.bc_1 = 6;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (!!this.x3d_1.t3a()) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+                this.z3d_1 = this.z3d_1.p3(this.x3d_1.m3a().h2s(this.y3d_1.p3a()));
+                this.ac_1 = 3;
+                suspendResult = this.y3d_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 3:
+                this.ac_1 = 4;
+                suspendResult = this.x3d_1.v3a(VOID, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 4:
+                this.ac_1 = 2;
+                continue $sm;
+              case 5:
+                var tmp_0 = this;
+                var tmp0_safe_receiver = this.x3d_1.r3a();
+                var tmp_1;
+                if (tmp0_safe_receiver == null) {
+                  tmp_1 = null;
+                } else {
+                  throw tmp0_safe_receiver;
+                }
+
+                tmp_0.a3e_1 = tmp_1;
+                this.bc_1 = 11;
+                this.ac_1 = 9;
+                continue $sm;
+              case 6:
+                this.bc_1 = 7;
+                var tmp_2 = this.dc_1;
+                if (tmp_2 instanceof Error) {
+                  this.b3e_1 = this.dc_1;
+                  var tmp_3 = this;
+                  this.x3d_1.x3a(this.b3e_1);
+                  close(this.y3d_1, this.b3e_1);
+                  throw this.b3e_1;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 7:
+                this.bc_1 = 11;
+                this.c3e_1 = this.dc_1;
+                this.ac_1 = 8;
+                suspendResult = this.y3d_1.w3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 8:
+                throw this.c3e_1;
+              case 9:
+                this.d3e_1 = this.a3e_1;
+                this.bc_1 = 11;
+                this.ac_1 = 10;
+                suspendResult = this.y3d_1.w3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 10:
+                return this.z3d_1;
+              case 11:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 11) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $copyAndCloseCOROUTINE$Class = $;
+  }
+  return $copyAndCloseCOROUTINE$Class;
+}
+var $readAvailableCOROUTINE$Class;
+function $readAvailableCOROUTINE$() {
+  if ($readAvailableCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, buffer, offset, length, resultContinuation) {
+        super(resultContinuation);
+        this.m3e_1 = _this__u8e3s4;
+        this.n3e_1 = buffer;
+        this.o3e_1 = offset;
+        this.p3e_1 = length;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 3;
+                if (this.m3e_1.t3a())
+                  return -1;
+                if (this.m3e_1.m3a().a2r()) {
+                  this.ac_1 = 1;
+                  suspendResult = this.m3e_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 1:
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (this.m3e_1.t3a())
+                  return -1;
+                return readAvailable(this.m3e_1.m3a(), this.n3e_1, this.o3e_1, this.p3e_1);
+              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);
+      }
+    }
+    initMetadataForCoroutine($);
+    $readAvailableCOROUTINE$Class = $;
+  }
+  return $readAvailableCOROUTINE$Class;
+}
+var $readUTF8LineCOROUTINE$Class;
+function $readUTF8LineCOROUTINE$() {
+  if ($readUTF8LineCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, max, resultContinuation) {
+        super(resultContinuation);
+        this.y3e_1 = _this__u8e3s4;
+        this.z3e_1 = max;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.a3f_1 = StringBuilder().a1();
+                this.ac_1 = 1;
+                suspendResult = readUTF8LineTo(this.y3e_1, this.a3f_1, this.z3e_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var completed = suspendResult;
+                return !completed ? null : this.a3f_1.toString();
+              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($);
+    $readUTF8LineCOROUTINE$Class = $;
+  }
+  return $readUTF8LineCOROUTINE$Class;
+}
+var $toByteArrayCOROUTINE$Class;
+function $toByteArrayCOROUTINE$() {
+  if ($toByteArrayCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.j3f_1 = _this__u8e3s4;
+      }
+      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 = readBuffer(this.j3f_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var ARGUMENT = suspendResult;
+                return readBytes(ARGUMENT);
+              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($);
+    $toByteArrayCOROUTINE$Class = $;
+  }
+  return $toByteArrayCOROUTINE$Class;
+}
+var $copyToCOROUTINE$Class;
+function $copyToCOROUTINE$() {
+  if ($copyToCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, channel, limit, resultContinuation) {
+        super(resultContinuation);
+        this.s3f_1 = _this__u8e3s4;
+        this.t3f_1 = channel;
+        this.u3f_1 = limit;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 12;
+                this.v3f_1 = this.u3f_1;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 8;
+                this.bc_1 = 7;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (!(!this.s3f_1.t3a() && this.v3f_1.a2(new (Long())(0, 0)) > 0)) {
+                  this.ac_1 = 6;
+                  continue $sm;
+                }
+
+                if (this.s3f_1.m3a().a2r()) {
+                  this.ac_1 = 3;
+                  suspendResult = this.s3f_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 4;
+                  continue $sm;
+                }
+
+              case 3:
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                var tmp_0 = this;
+                var tmp0 = this.v3f_1;
+                var b = get_remaining(this.s3f_1.m3a());
+                tmp_0.x3f_1 = tmp0.a2(b) <= 0 ? tmp0 : b;
+                this.s3f_1.m3a().g2s(this.t3f_1.p3a(), this.x3f_1);
+                this.v3f_1 = this.v3f_1.q3(this.x3f_1);
+                this.ac_1 = 5;
+                suspendResult = this.t3f_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 5:
+                this.ac_1 = 2;
+                continue $sm;
+              case 6:
+                this.w3f_1 = Unit_instance;
+                this.bc_1 = 12;
+                this.ac_1 = 10;
+                continue $sm;
+              case 7:
+                this.bc_1 = 8;
+                var tmp_1 = this.dc_1;
+                if (tmp_1 instanceof Error) {
+                  this.y3f_1 = this.dc_1;
+                  var tmp_2 = this;
+                  this.s3f_1.x3a(this.y3f_1);
+                  close(this.t3f_1, this.y3f_1);
+                  throw this.y3f_1;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 8:
+                this.bc_1 = 12;
+                this.z3f_1 = this.dc_1;
+                this.ac_1 = 9;
+                suspendResult = this.t3f_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 9:
+                throw this.z3f_1;
+              case 10:
+                this.bc_1 = 12;
+                this.ac_1 = 11;
+                suspendResult = this.t3f_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 11:
+                return this.u3f_1.q3(this.v3f_1);
+              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);
+      }
+    }
+    initMetadataForCoroutine($);
+    $copyToCOROUTINE$Class = $;
+  }
+  return $copyToCOROUTINE$Class;
+}
+var $readBufferCOROUTINE$Class;
+function $readBufferCOROUTINE$() {
+  if ($readBufferCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.g3h_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                this.h3h_1 = new (Buffer())();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!!this.g3h_1.t3a()) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.h3h_1.w2s(this.g3h_1.m3a());
+                this.ac_1 = 2;
+                suspendResult = this.g3h_1.v3a(VOID, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                var tmp0_safe_receiver = this.g3h_1.r3a();
+                if (tmp0_safe_receiver == null)
+                  null;
+                else {
+                  throw tmp0_safe_receiver;
+                }
+
+                return this.h3h_1;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $readBufferCOROUTINE$Class = $;
+  }
+  return $readBufferCOROUTINE$Class;
+}
+var $readUTF8LineToCOROUTINE$Class;
+function $readUTF8LineToCOROUTINE$() {
+  if ($readUTF8LineToCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, out, max, lineEnding, resultContinuation) {
+        super(resultContinuation);
+        this.q3h_1 = _this__u8e3s4;
+        this.r3h_1 = out;
+        this.s3h_1 = max;
+        this.t3h_1 = lineEnding;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 21;
+                if (this.q3h_1.m3a().a2r()) {
+                  this.ac_1 = 1;
+                  suspendResult = this.q3h_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 1:
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (this.q3h_1.t3a())
+                  return false;
+                var tmp_0 = this;
+                tmp_0.u3h_1 = new (Buffer())();
+                this.ac_1 = 3;
+                continue $sm;
+              case 3:
+                this.w3h_1 = this.u3h_1;
+                this.x3h_1 = null;
+                this.ac_1 = 4;
+                continue $sm;
+              case 4:
+                this.ac_1 = 5;
+                continue $sm;
+              case 5:
+                this.ac_1 = 6;
+                continue $sm;
+              case 6:
+                this.bc_1 = 18;
+                this.bc_1 = 17;
+                var tmp_1 = this;
+                tmp_1.z3h_1 = this.w3h_1;
+                this.a3i_1 = this.z3h_1;
+                this.ac_1 = 7;
+                continue $sm;
+              case 7:
+                if (!!this.q3h_1.t3a()) {
+                  this.ac_1 = 14;
+                  continue $sm;
+                }
+
+                this.ac_1 = 8;
+                continue $sm;
+              case 8:
+                if (!!this.q3h_1.m3a().a2r()) {
+                  this.ac_1 = 12;
+                  continue $sm;
+                }
+
+                this.b3i_1 = this.q3h_1.m3a().d2r();
+                if (this.b3i_1 === 13) {
+                  if (this.q3h_1.m3a().a2r()) {
+                    this.ac_1 = 10;
+                    suspendResult = this.q3h_1.v3a(VOID, this);
+                    if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                      return suspendResult;
+                    }
+                    continue $sm;
+                  } else {
+                    this.ac_1 = 11;
+                    continue $sm;
+                  }
+                } else {
+                  if (this.b3i_1 === 10) {
+                    readUTF8LineTo$checkLineEndingAllowed(this.t3h_1, Companion_getInstance().u3g_1);
+                    this.r3h_1.b1(readString(this.a3i_1));
+                    this.y3h_1 = true;
+                    this.bc_1 = 21;
+                    this.ac_1 = 15;
+                    continue $sm;
+                  } else {
+                    this.a3i_1.x2s(this.b3i_1);
+                    this.ac_1 = 9;
+                    continue $sm;
+                  }
+                }
+
+              case 9:
+                this.ac_1 = 8;
+                continue $sm;
+              case 10:
+                this.ac_1 = 11;
+                continue $sm;
+              case 11:
+                if (this.q3h_1.m3a().z2q().z2r(new (Long())(0, 0)) === 10) {
+                  readUTF8LineTo$checkLineEndingAllowed(this.t3h_1, Companion_getInstance().v3g_1);
+                  discard(this.q3h_1.m3a(), new (Long())(1, 0));
+                } else {
+                  readUTF8LineTo$checkLineEndingAllowed(this.t3h_1, Companion_getInstance().t3g_1);
+                }
+
+                this.r3h_1.b1(readString(this.a3i_1));
+                this.y3h_1 = true;
+                this.bc_1 = 21;
+                this.ac_1 = 15;
+                continue $sm;
+              case 12:
+                if (this.a3i_1.i1().a2(toLong(this.s3h_1)) >= 0) {
+                  throw TooLongLineException().i3m('Line exceeds limit of ' + this.s3h_1 + ' characters');
+                }
+
+                this.ac_1 = 13;
+                suspendResult = this.q3h_1.v3a(VOID, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 13:
+                this.ac_1 = 7;
+                continue $sm;
+              case 14:
+                var tmp_2 = this;
+                var this_0 = this.a3i_1.i1().a2(new (Long())(0, 0)) > 0;
+                if (this_0) {
+                  this.r3h_1.b1(readString(this.a3i_1));
+                }
+
+                tmp_2.y3h_1 = this_0;
+                this.bc_1 = 21;
+                this.ac_1 = 15;
+                var tmp_3 = this;
+                continue $sm;
+              case 15:
+                var tmp_4 = this.y3h_1;
+                this.bc_1 = 21;
+                closeFinally(this.w3h_1, this.x3h_1);
+                return tmp_4;
+              case 16:
+                this.bc_1 = 21;
+                var tmp_5 = this;
+                closeFinally(this.w3h_1, this.x3h_1);
+                tmp_5.v3h_1 = Unit_instance;
+                this.ac_1 = 20;
+                continue $sm;
+              case 17:
+                this.bc_1 = 18;
+                var tmp_6 = this.dc_1;
+                if (tmp_6 instanceof Error) {
+                  var e = this.dc_1;
+                  var tmp_7 = this;
+                  this.x3h_1 = e;
+                  throw e;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 18:
+                this.bc_1 = 21;
+                var t = this.dc_1;
+                closeFinally(this.w3h_1, this.x3h_1);
+                throw t;
+              case 19:
+                this.bc_1 = 21;
+                closeFinally(this.w3h_1, this.x3h_1);
+                if (false) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.ac_1 = 20;
+                continue $sm;
+              case 20:
+                return Unit_instance;
+              case 21:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e_0 = $p;
+            if (this.bc_1 === 21) {
+              throw e_0;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e_0;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $readUTF8LineToCOROUTINE$Class = $;
+  }
+  return $readUTF8LineToCOROUTINE$Class;
+}
+var $skipIfFoundCOROUTINE$Class;
+function $skipIfFoundCOROUTINE$() {
+  if ($skipIfFoundCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, byteString, resultContinuation) {
+        super(resultContinuation);
+        this.k3i_1 = _this__u8e3s4;
+        this.l3i_1 = byteString;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                this.ac_1 = 1;
+                suspendResult = peek(this.k3i_1, this.l3i_1.i1(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.m3i_1 = suspendResult;
+                if (equals(this.m3i_1, this.l3i_1)) {
+                  this.ac_1 = 3;
+                  suspendResult = discard_0(this.k3i_1, toLong(this.l3i_1.i1()), this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 2:
+                return false;
+              case 3:
+                return true;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $skipIfFoundCOROUTINE$Class = $;
+  }
+  return $skipIfFoundCOROUTINE$Class;
+}
+var $readPacketCOROUTINE$Class;
+function $readPacketCOROUTINE$() {
+  if ($readPacketCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, packet, resultContinuation) {
+        super(resultContinuation);
+        this.v3i_1 = _this__u8e3s4;
+        this.w3i_1 = packet;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 6;
+                this.x3i_1 = new (Buffer())();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!(this.x3i_1.i1().a2(toLong(this.w3i_1)) < 0)) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                }
+
+                if (this.v3i_1.m3a().a2r()) {
+                  this.ac_1 = 2;
+                  suspendResult = this.v3i_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 2:
+                this.ac_1 = 3;
+                continue $sm;
+              case 3:
+                if (this.v3i_1.t3a()) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 4;
+                  continue $sm;
+                }
+
+              case 4:
+                if (get_remaining(this.v3i_1.m3a()).a2(numberToLong(this.w3i_1).q3(this.x3i_1.i1())) > 0) {
+                  this.v3i_1.m3a().g2s(this.x3i_1, numberToLong(this.w3i_1).q3(this.x3i_1.i1()));
+                } else {
+                  this.v3i_1.m3a().h2s(this.x3i_1);
+                }
+
+                this.ac_1 = 1;
+                continue $sm;
+              case 5:
+                if (this.x3i_1.i1().a2(toLong(this.w3i_1)) < 0) {
+                  throw EOFException().y2q('Not enough data available, required ' + this.w3i_1 + ' bytes but only ' + this.x3i_1.i1().toString() + ' available');
+                }
+
+                return this.x3i_1;
+              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($);
+    $readPacketCOROUTINE$Class = $;
+  }
+  return $readPacketCOROUTINE$Class;
+}
+var $readByteCOROUTINE$Class;
+function $readByteCOROUTINE$() {
+  if ($readByteCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.g3j_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                this.h3j_1 = this.g3j_1.m3a();
+                if (this.h3j_1.a2r()) {
+                  this.ac_1 = 1;
+                  suspendResult = this.g3j_1.v3a(VOID, this);
+                  if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                    return suspendResult;
+                  }
+                  continue $sm;
+                } else {
+                  this.i3j_1 = false;
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 1:
+                var ARGUMENT = suspendResult;
+                this.i3j_1 = !ARGUMENT;
+                this.ac_1 = 2;
+                continue $sm;
+              case 2:
+                if (this.i3j_1) {
+                  throw EOFException().y2q('Not enough data available');
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 3:
+                return this.h3j_1.d2r();
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $readByteCOROUTINE$Class = $;
+  }
+  return $readByteCOROUTINE$Class;
+}
+var $readShortCOROUTINE$Class;
+function $readShortCOROUTINE$() {
+  if ($readShortCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.r3j_1 = _this__u8e3s4;
+      }
+      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 = awaitUntilReadable(this.r3j_1, 2, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return this.r3j_1.m3a().n2r();
+              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($);
+    $readShortCOROUTINE$Class = $;
+  }
+  return $readShortCOROUTINE$Class;
+}
+var $readLongCOROUTINE$Class;
+function $readLongCOROUTINE$() {
+  if ($readLongCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.a3k_1 = _this__u8e3s4;
+      }
+      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 = awaitUntilReadable(this.a3k_1, 8, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return this.a3k_1.m3a().r2r();
+              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($);
+    $readLongCOROUTINE$Class = $;
+  }
+  return $readLongCOROUTINE$Class;
+}
+var $readIntCOROUTINE$Class;
+function $readIntCOROUTINE$() {
+  if ($readIntCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.j3k_1 = _this__u8e3s4;
+      }
+      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 = awaitUntilReadable(this.j3k_1, 4, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return this.j3k_1.m3a().p2r();
+              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($);
+    $readIntCOROUTINE$Class = $;
+  }
+  return $readIntCOROUTINE$Class;
+}
+var $peekCOROUTINE$Class;
+function $peekCOROUTINE$() {
+  if ($peekCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, count, resultContinuation) {
+        super(resultContinuation);
+        this.s3k_1 = _this__u8e3s4;
+        this.t3k_1 = count;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 3;
+                if (this.s3k_1.t3a())
+                  return null;
+                this.ac_1 = 1;
+                suspendResult = this.s3k_1.u3a(this.t3k_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var ARGUMENT = suspendResult;
+                if (!ARGUMENT) {
+                  return null;
+                } else {
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 2:
+                return readByteString(this.s3k_1.m3a().i2s(), this.t3k_1);
+              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);
+      }
+    }
+    initMetadataForCoroutine($);
+    $peekCOROUTINE$Class = $;
+  }
+  return $peekCOROUTINE$Class;
+}
+var $awaitUntilReadableCOROUTINE$Class;
+function $awaitUntilReadableCOROUTINE$() {
+  if ($awaitUntilReadableCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, numberOfBytes, resultContinuation) {
+        super(resultContinuation);
+        this.c3l_1 = _this__u8e3s4;
+        this.d3l_1 = numberOfBytes;
+      }
+      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 = this.c3l_1.u3a(this.d3l_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var ARGUMENT = suspendResult;
+                if (!ARGUMENT) {
+                  throw EOFException().y2q('Not enough data available');
+                } else {
+                  this.ac_1 = 2;
+                  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);
+      }
+    }
+    initMetadataForCoroutine($);
+    $awaitUntilReadableCOROUTINE$Class = $;
+  }
+  return $awaitUntilReadableCOROUTINE$Class;
+}
+//region block: exports
+export {
+  copyAndClose as copyAndClose18m9s4thl5g8a,
+  copyTo as copyTo2vm7vz7rr51or,
+  discard_0 as discard2tnmk0ppobupv,
+  readAvailable_0 as readAvailable22vc1bmbuj93x,
+  readByte as readByte1fosf9t7rsagl,
+  readInt as readInt250esdbock5tr,
+  readLong as readLong2v440y4ztrd2,
+  readPacket as readPacket2q2gamtzwxjd1,
+  readRemaining as readRemaining1x8kk1vq7p6gm,
+  readShort as readShort2l1vgkfwlqel1,
+  readUTF8LineTo_0 as readUTF8LineTo3cgartetbq4tk,
+  readUTF8Line as readUTF8Lineygmlhrpm9syq,
+  readUntil as readUntil2jtfemvkt7z1f,
+  skipIfFound as skipIfFound1yms04v7e3tuk,
+  toByteArray as toByteArrayafjflk7yznm4,
+  ReaderScope as ReaderScope2dc8cistt42km,
+  reader as reader248c0jw1ii7vm,
+  reader_0 as reader2auqe0lq0s3fd,
+  rethrowCloseCauseIfNeeded_0 as rethrowCloseCauseIfNeededeln8lm5agg4u,
+  rethrowCloseCauseIfNeeded_1 as rethrowCloseCauseIfNeeded2q8fs9csuucwc,
+};
+//endregion
+
+//# sourceMappingURL=ByteReadChannelOperations.mjs.map