@attocash/cli 0.1.0

package/node_modules/@attocash/commons-transport/ktor-ktor-io.mjs

@@ -0,0 +1,2290 @@
+import {
+  Companion_instance1co2nkledm2ru as Companion_instance,
+  Unit_instance3vdlo4e4f5ggx as Unit_instance,
+  _Result___init__impl__xyqfz810za1hm0unrcw as _Result___init__impl__xyqfz8,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  VOID3gxj6tk5isa35 as VOID,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  toString30pk9tzaqopn as toString,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  createFailure8paxfkfa5dc7 as createFailure,
+  Result3t1vadv16kmzk as Result,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  toString1h6jjoch8cjt8 as toString_0,
+  newThrowablezl37abp36p5f as newThrowable,
+  stackTraceToString2670q6lbhdojj as stackTraceToString,
+  protoOf180f3jzyo7rfj as protoOf,
+  isInterface3d6p8outrmvmk as isInterface,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  CancellationException3b36o9qz53rgr as CancellationException,
+  fromInt2ii0rejb1w62w as fromInt,
+  numberToLong2pakxeg38estk as numberToLong,
+  add2suhfggl4zvkk as add,
+  intercepted2ogpsikxxj4u0 as intercepted,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  convertToInty04h231mmjoh as convertToInt,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  toString1pkumu07cwy4m as toString_1,
+  captureStack1fzi4aczwc4hg as captureStack,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+  replace3le3ie7l9k8aq as replace,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  StringBuildermazzzhj6kkai as StringBuilder,
+  subtract2orl8z9upxd9l as subtract,
+  constructCallableReference23y65rf941mch as constructCallableReference,
+  EmptyCoroutineContext_instancegbhtm9svfl3r as EmptyCoroutineContext_instance,
+  Continuation1aa2oekvx7jm7 as Continuation,
+  Enum3alwj03lh1n41 as Enum,
+  ArrayList3it5z8td81qkl as ArrayList,
+  listOf1jh22dvmctj1r as listOf,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  encodeToByteArray22651fhg4p67t as encodeToByteArray,
+  AutoCloseable1l5p57f9lp7kv as AutoCloseable,
+  _Char___init__impl__6a9atx2yltdocdrxs4d as _Char___init__impl__6a9atx,
+  replaceqbix900hl8kl as replace_0,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  isCharSequence1ju9jr1w86plq as isCharSequence,
+  trim11nh7r46at6sx as trim,
+  toByte4i43936u611k as toByte,
+  decodeToString1x4faah2liw2p as decodeToString,
+  setOf45ia9pnfhe90 as setOf,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  Char__toInt_impl_vasixd1ka89vowck9tn as Char__toInt_impl_vasixd,
+} from '@attocash/commons-core/kotlin-kotlin-stdlib.mjs';
+import {
+  DisposableHandle1uzxt8frdchxn as DisposableHandle,
+  CopyableThrowable1mvc99jcyvivf as CopyableThrowable,
+  CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl,
+  launch1c91vkjzdi9sd as launch,
+  startCoroutineCancellable18shtfwdieib as startCoroutineCancellable,
+  get_job2zvlvce9o9a29 as get_job,
+  Job13y4jkazwjho0 as Job,
+  cancel1xim2hrvjmwpn as cancel,
+  Dispatchers_getInstance20p7pyqnrepag as Dispatchers_getInstance,
+} from './kotlinx-coroutines-core.mjs';
+import {
+  Buffergs925ekssbch as Buffer,
+  indexOf29nspdgx2e3ap as indexOf,
+  IOException1wyutdmfe71nu as IOException,
+  EOFExceptionh831u25jcq9n as EOFException,
+  readByteString2hnsbql6t4ads as readByteString,
+  readString3v6duspiz33tv as readString,
+  readString2nvggcfaijfhd as readString_0,
+  readByteArray1fhzfwi2j014k as readByteArray,
+  writeString33ca4btrgctw7 as writeString,
+  readByteArray1ri21h2rciakw as readByteArray_0,
+} from '@attocash/commons-core/kotlinx-io-kotlinx-io-core.mjs';
+import { atomic$ref$130aurmcwdfdf1 as atomic$ref$1 } from './kotlinx-atomicfu.mjs';
+import { decodeToString2ede220pr5xir as decodeToString_0 } from '@attocash/commons-core/kotlinx-io-kotlinx-io-bytestring.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+class Companion {
+  constructor() {
+    Companion_instance_0 = this;
+    this.w3w_1 = new Closed(null);
+    var tmp = this;
+    // Inline function 'kotlin.Companion.success' call
+    tmp.x3w_1 = _Result___init__impl__xyqfz8(Unit_instance);
+  }
+}
+class Empty {
+  toString() {
+    return 'Empty';
+  }
+  hashCode() {
+    return -231472095;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Empty))
+      return false;
+    return true;
+  }
+}
+class Closed {
+  constructor(cause) {
+    this.y3w_1 = cause;
+  }
+  toString() {
+    return 'Closed(cause=' + toString(this.y3w_1) + ')';
+  }
+  hashCode() {
+    return this.y3w_1 == null ? 0 : hashCode(this.y3w_1);
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Closed))
+      return false;
+    if (!equals(this.y3w_1, other.y3w_1))
+      return false;
+    return true;
+  }
+}
+class Task {}
+function resume() {
+  return this.a3x().uc(Companion_getInstance().x3w_1);
+}
+function resume_0(throwable) {
+  var tmp = this.a3x();
+  var tmp_0;
+  if (throwable == null) {
+    tmp_0 = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(throwable));
+    tmp_0 = new Result(tmp$ret$0);
+  }
+  var tmp1_elvis_lhs = tmp_0;
+  return tmp.uc(tmp1_elvis_lhs == null ? Companion_getInstance().x3w_1 : tmp1_elvis_lhs.os_1);
+}
+class Read {
+  constructor(continuation) {
+    this.e3x_1 = continuation;
+    this.f3x_1 = null;
+    if (get_DEVELOPMENT_MODE()) {
+      var tmp = this;
+      // Inline function 'kotlin.also' call
+      var this_0 = newThrowable('ReadTask 0x' + toString_0(hashCode(this.e3x_1), 16));
+      stackTraceToString(this_0);
+      tmp.f3x_1 = this_0;
+    }
+  }
+  a3x() {
+    return this.e3x_1;
+  }
+  z3w() {
+    return this.f3x_1;
+  }
+  b3x() {
+    return 'read';
+  }
+}
+class Write {
+  constructor(continuation) {
+    this.g3x_1 = continuation;
+    this.h3x_1 = null;
+    if (get_DEVELOPMENT_MODE()) {
+      var tmp = this;
+      // Inline function 'kotlin.also' call
+      var this_0 = newThrowable('WriteTask 0x' + toString_0(hashCode(this.g3x_1), 16));
+      stackTraceToString(this_0);
+      tmp.h3x_1 = this_0;
+    }
+  }
+  a3x() {
+    return this.g3x_1;
+  }
+  z3w() {
+    return this.h3x_1;
+  }
+  b3x() {
+    return 'write';
+  }
+}
+class sam$kotlinx_coroutines_DisposableHandle$0 {
+  constructor(function_0) {
+    this.r3x_1 = function_0;
+  }
+  d2v() {
+    return this.r3x_1();
+  }
+  b5() {
+    return this.r3x_1;
+  }
+  equals(other) {
+    var tmp;
+    if (!(other == null) ? isInterface(other, DisposableHandle) : false) {
+      var tmp_0;
+      if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+        tmp_0 = equals(this.b5(), other.b5());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  hashCode() {
+    return hashCode(this.b5());
+  }
+}
+class ByteReadChannel {}
+function awaitContent$default(min, $completion, $super) {
+  min = min === VOID ? 1 : min;
+  return $super === VOID ? this.n3y(min, $completion) : $super.n3y.call(this, min, $completion);
+}
+class ByteWriteChannel {}
+function get_autoFlush() {
+  return false;
+}
+class ByteChannel {
+  constructor(autoFlush) {
+    autoFlush = autoFlush === VOID ? false : autoFlush;
+    this.i3x_1 = autoFlush;
+    this.j3x_1 = new Buffer();
+    this.k3x_1 = 0;
+    this.l3x_1 = new Object();
+    this.m3x_1 = atomic$ref$1(Empty_instance);
+    this.n3x_1 = new Buffer();
+    this.o3x_1 = new Buffer();
+    this.p3x_1 = atomic$ref$1(null);
+    this.q3x_1 = atomic$ref$1(null);
+  }
+  s3x() {
+    return this.i3x_1;
+  }
+  t3x() {
+    return this.k3x_1 < 1048576;
+  }
+  u3x() {
+    var tmp0_safe_receiver = this.p3x_1.kotlinx$atomicfu$value;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'io.ktor.utils.io.Companion.throwOrNull' call
+      // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+      var tmp0_subject = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+      var tmp;
+      if (tmp0_subject == null) {
+        tmp = null;
+      } else {
+        if (isInterface(tmp0_subject, CopyableThrowable)) {
+          tmp = access$_get_origin__hdh1qz(tmp0_safe_receiver).s2y();
+        } else {
+          if (tmp0_subject instanceof CancellationException) {
+            tmp = CancellationException.p(access$_get_origin__hdh1qz(tmp0_safe_receiver).message, access$_get_origin__hdh1qz(tmp0_safe_receiver));
+          } else {
+            var p0 = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+            tmp = ClosedReadChannelException.z3x(p0);
+          }
+        }
+      }
+      var tmp0_safe_receiver_0 = tmp;
+      var tmp_0;
+      if (tmp0_safe_receiver_0 == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.let' call
+        throw tmp0_safe_receiver_0;
+      }
+    }
+    if (this.n3x_1.n1s()) {
+      moveFlushToReadBuffer(this);
+    }
+    return this.n3x_1;
+  }
+  a3y() {
+    if (this.g3y()) {
+      var tmp0_safe_receiver = this.p3x_1.kotlinx$atomicfu$value;
+      var tmp;
+      if (tmp0_safe_receiver == null) {
+        tmp = null;
+      } else {
+        // Inline function 'io.ktor.utils.io.Companion.throwOrNull' call
+        // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+        var tmp0_subject = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+        var tmp_0;
+        if (tmp0_subject == null) {
+          tmp_0 = null;
+        } else {
+          if (isInterface(tmp0_subject, CopyableThrowable)) {
+            tmp_0 = access$_get_origin__hdh1qz(tmp0_safe_receiver).s2y();
+          } else {
+            if (tmp0_subject instanceof CancellationException) {
+              tmp_0 = CancellationException.p(access$_get_origin__hdh1qz(tmp0_safe_receiver).message, access$_get_origin__hdh1qz(tmp0_safe_receiver));
+            } else {
+              var p0 = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+              tmp_0 = ClosedWriteChannelException.f3y(p0);
+            }
+          }
+        }
+        var tmp0_safe_receiver_0 = tmp_0;
+        var tmp_1;
+        if (tmp0_safe_receiver_0 == null) {
+          tmp_1 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          throw tmp0_safe_receiver_0;
+        }
+        tmp = tmp_1;
+      }
+      if (tmp == null)
+        throw ClosedWriteChannelException.f3y();
+    }
+    return this.o3x_1;
+  }
+  h3y() {
+    var tmp0_safe_receiver = this.p3x_1.kotlinx$atomicfu$value;
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+      var tmp0_subject = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+      var tmp_0;
+      if (tmp0_subject == null) {
+        tmp_0 = null;
+      } else {
+        if (isInterface(tmp0_subject, CopyableThrowable)) {
+          tmp_0 = access$_get_origin__hdh1qz(tmp0_safe_receiver).s2y();
+        } else {
+          if (tmp0_subject instanceof CancellationException) {
+            tmp_0 = CancellationException.p(access$_get_origin__hdh1qz(tmp0_safe_receiver).message, access$_get_origin__hdh1qz(tmp0_safe_receiver));
+          } else {
+            var p0 = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+            tmp_0 = ClosedByteChannelException.l3y(p0);
+          }
+        }
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  g3y() {
+    return !(this.p3x_1.kotlinx$atomicfu$value == null);
+  }
+  m3y() {
+    return !(this.h3y() == null) || (this.g3y() && this.k3x_1 === 0 && this.n3x_1.n1s());
+  }
+  *n3y(min, $completion) {
+    rethrowCloseCauseIfNeeded_0(this);
+    if (this.n3x_1.p2() >= fromInt(min))
+      return true;
+    // Inline function 'io.ktor.utils.io.ByteChannel.sleepWhile' call
+    var this_0 = this;
+    $l$loop: while (add(numberToLong(this.k3x_1), this.n3x_1.p2()) < fromInt(min) && this.p3x_1.kotlinx$atomicfu$value == null) {
+      // Inline function 'kotlinx.coroutines.suspendCancellableCoroutine' call
+      // Inline function 'kotlin.js.suspendCoroutineUninterceptedOrReturnJS' call
+      (yield () => {
+        var uCont = $completion;
+        var cancellable = new CancellableContinuationImpl(intercepted(uCont), 1);
+        cancellable.k2w();
+        var tmp0 = this_0;
+        var tmp2 = new Read(cancellable);
+        $l$block_0: {
+          // Inline function 'io.ktor.utils.io.ByteChannel.trySuspend' call
+          var previous = tmp0.m3x_1.kotlinx$atomicfu$value;
+          if (!(previous instanceof Closed)) {
+            if (!tmp0.m3x_1.atomicfu$compareAndSet(previous, tmp2)) {
+              tmp2.c3x();
+              break $l$block_0;
+            }
+          }
+          if (previous instanceof Read) {
+            previous.d3x(ConcurrentIOException.s3y(tmp2.b3x(), previous.z3w()));
+          } else {
+            if (isInterface(previous, Task)) {
+              previous.c3x();
+            } else {
+              if (previous instanceof Closed) {
+                tmp2.d3x(previous.y3w_1);
+                break $l$block_0;
+              } else {
+                if (!equals(previous, Empty_instance)) {
+                  noWhenBranchMatchedException();
+                }
+              }
+            }
+          }
+          if (!(add(numberToLong(this.k3x_1), this.n3x_1.p2()) < fromInt(min) && this.p3x_1.kotlinx$atomicfu$value == null)) {
+            // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+            var current = tmp0.m3x_1.kotlinx$atomicfu$value;
+            var tmp;
+            if (current instanceof Read) {
+              tmp = tmp0.m3x_1.atomicfu$compareAndSet(current, Empty_instance);
+            } else {
+              tmp = false;
+            }
+            if (tmp) {
+              current.c3x();
+            }
+          }
+        }
+        return cancellable.t2t();
+      });
+    }
+    if (this.n3x_1.p2() < 1048576n) {
+      moveFlushToReadBuffer(this);
+    }
+    return this.n3x_1.p2() >= fromInt(min);
+  }
+  *u3y($completion) {
+    rethrowCloseCauseIfNeeded_0(this);
+    this.v3y();
+    if (this.t3x())
+      return Unit_instance;
+    // Inline function 'io.ktor.utils.io.ByteChannel.sleepWhile' call
+    var this_0 = this;
+    $l$loop: while (!this.t3x() && this.p3x_1.kotlinx$atomicfu$value == null) {
+      // Inline function 'kotlinx.coroutines.suspendCancellableCoroutine' call
+      // Inline function 'kotlin.js.suspendCoroutineUninterceptedOrReturnJS' call
+      (yield () => {
+        var uCont = $completion;
+        var cancellable = new CancellableContinuationImpl(intercepted(uCont), 1);
+        cancellable.k2w();
+        var tmp0 = this_0;
+        var tmp2 = new Write(cancellable);
+        $l$block_0: {
+          // Inline function 'io.ktor.utils.io.ByteChannel.trySuspend' call
+          var previous = tmp0.m3x_1.kotlinx$atomicfu$value;
+          if (!(previous instanceof Closed)) {
+            if (!tmp0.m3x_1.atomicfu$compareAndSet(previous, tmp2)) {
+              tmp2.c3x();
+              break $l$block_0;
+            }
+          }
+          if (previous instanceof Write) {
+            previous.d3x(ConcurrentIOException.s3y(tmp2.b3x(), previous.z3w()));
+          } else {
+            if (isInterface(previous, Task)) {
+              previous.c3x();
+            } else {
+              if (previous instanceof Closed) {
+                tmp2.d3x(previous.y3w_1);
+                break $l$block_0;
+              } else {
+                if (!equals(previous, Empty_instance)) {
+                  noWhenBranchMatchedException();
+                }
+              }
+            }
+          }
+          if (!(!this.t3x() && this.p3x_1.kotlinx$atomicfu$value == null)) {
+            // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+            var current = tmp0.m3x_1.kotlinx$atomicfu$value;
+            var tmp;
+            if (current instanceof Write) {
+              tmp = tmp0.m3x_1.atomicfu$compareAndSet(current, Empty_instance);
+            } else {
+              tmp = false;
+            }
+            if (tmp) {
+              current.c3x();
+            }
+          }
+        }
+        return cancellable.t2t();
+      });
+    }
+    return Unit_instance;
+  }
+  v3y() {
+    if (this.o3x_1.n1s())
+      return Unit_instance;
+    // Inline function 'io.ktor.utils.io.locks.synchronized' call
+    this.l3x_1;
+    var count = convertToInt(this.o3x_1.p2());
+    this.j3x_1.i1u(this.o3x_1);
+    this.k3x_1 = this.k3x_1 + count | 0;
+    // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+    var current = this.m3x_1.kotlinx$atomicfu$value;
+    var tmp;
+    if (current instanceof Read) {
+      tmp = this.m3x_1.atomicfu$compareAndSet(current, Empty_instance);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      current.c3x();
+    }
+  }
+  q6() {
+    this.v3y();
+    if (!this.p3x_1.atomicfu$compareAndSet(null, get_CLOSED()))
+      return Unit_instance;
+    closeSlot(this, null);
+  }
+  *w3y($completion) {
+    // Inline function 'kotlin.runCatching' call
+    var tmp;
+    try {
+      yield* this.u3y($completion);
+      // Inline function 'kotlin.Companion.success' call
+      tmp = _Result___init__impl__xyqfz8(Unit_instance);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        // Inline function 'kotlin.Companion.failure' call
+        tmp_0 = _Result___init__impl__xyqfz8(createFailure(e));
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    if (!this.p3x_1.atomicfu$compareAndSet(null, get_CLOSED()))
+      return Unit_instance;
+    closeSlot(this, null);
+    return Unit_instance;
+  }
+  x3y(cause) {
+    if (!(this.p3x_1.kotlinx$atomicfu$value == null))
+      return Unit_instance;
+    var closedToken = new CloseToken(cause);
+    this.p3x_1.atomicfu$compareAndSet(null, closedToken);
+    // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+    var tmp0_subject = access$_get_origin__hdh1qz(closedToken);
+    var tmp;
+    if (tmp0_subject == null) {
+      tmp = null;
+    } else {
+      if (isInterface(tmp0_subject, CopyableThrowable)) {
+        tmp = access$_get_origin__hdh1qz(closedToken).s2y();
+      } else {
+        if (tmp0_subject instanceof CancellationException) {
+          tmp = CancellationException.p(access$_get_origin__hdh1qz(closedToken).message, access$_get_origin__hdh1qz(closedToken));
+        } else {
+          var p0 = access$_get_origin__hdh1qz(closedToken);
+          tmp = ClosedByteChannelException.l3y(p0);
+        }
+      }
+    }
+    var wrappedCause = tmp;
+    closeSlot(this, wrappedCause);
+  }
+  y3y(handler) {
+    var existingCause = this.p3x_1.kotlinx$atomicfu$value;
+    if (!(existingCause == null)) {
+      // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+      var tmp0_subject = access$_get_origin__hdh1qz(existingCause);
+      var tmp;
+      if (tmp0_subject == null) {
+        tmp = null;
+      } else {
+        if (isInterface(tmp0_subject, CopyableThrowable)) {
+          tmp = access$_get_origin__hdh1qz(existingCause).s2y();
+        } else {
+          if (tmp0_subject instanceof CancellationException) {
+            tmp = CancellationException.p(access$_get_origin__hdh1qz(existingCause).message, access$_get_origin__hdh1qz(existingCause));
+          } else {
+            var p0 = access$_get_origin__hdh1qz(existingCause);
+            tmp = ClosedByteChannelException.l3y(p0);
+          }
+        }
+      }
+      handler(tmp);
+      var tmp_0 = ByteChannel$invokeOnClose$lambda;
+      return new sam$kotlinx_coroutines_DisposableHandle$0(tmp_0);
+    }
+    if (!this.q3x_1.atomicfu$compareAndSet(null, handler)) {
+      // Inline function 'kotlin.error' call
+      var message = 'Only one invokeOnClose handler is supported per channel';
+      throw IllegalStateException.o(toString_1(message));
+    }
+    var cause = this.p3x_1.kotlinx$atomicfu$value;
+    if (!(cause == null) && this.q3x_1.atomicfu$compareAndSet(handler, null)) {
+      // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+      var tmp0_subject_0 = access$_get_origin__hdh1qz(cause);
+      var tmp_1;
+      if (tmp0_subject_0 == null) {
+        tmp_1 = null;
+      } else {
+        if (isInterface(tmp0_subject_0, CopyableThrowable)) {
+          tmp_1 = access$_get_origin__hdh1qz(cause).s2y();
+        } else {
+          if (tmp0_subject_0 instanceof CancellationException) {
+            tmp_1 = CancellationException.p(access$_get_origin__hdh1qz(cause).message, access$_get_origin__hdh1qz(cause));
+          } else {
+            var p0_0 = access$_get_origin__hdh1qz(cause);
+            tmp_1 = ClosedByteChannelException.l3y(p0_0);
+          }
+        }
+      }
+      handler(tmp_1);
+      var tmp_2 = ByteChannel$invokeOnClose$lambda_0;
+      return new sam$kotlinx_coroutines_DisposableHandle$0(tmp_2);
+    }
+    var tmp_3 = ByteChannel$invokeOnClose$lambda_1(this, handler);
+    return new sam$kotlinx_coroutines_DisposableHandle$0(tmp_3);
+  }
+  toString() {
+    return 'ByteChannel[' + hashCode(this) + ']';
+  }
+}
+class ConcurrentIOException extends IllegalStateException {
+  constructor(taskName, cause) {
+    return new.target.s3y(taskName, cause);
+  }
+  static s3y(taskName, cause) {
+    cause = cause === VOID ? null : cause;
+    var $this = this.q('Concurrent ' + taskName + ' attempts', cause);
+    captureStack($this, $this.r3y_1);
+    return $this;
+  }
+}
+class ByteChannelScanner {
+  constructor(channel, matchString, writeChannel, limit) {
+    limit = limit === VOID ? 9223372036854775807n : limit;
+    this.z3y_1 = channel;
+    this.a3z_1 = matchString;
+    this.b3z_1 = writeChannel;
+    this.c3z_1 = limit;
+    // Inline function 'kotlin.require' call
+    if (!(this.a3z_1.p2() > 0)) {
+      var message = 'Empty match string not permitted for scanning';
+      throw IllegalArgumentException.n2(toString_1(message));
+    }
+    this.d3z_1 = this.z3y_1.u3x();
+    this.e3z_1 = buildPartialMatchTable(this);
+    this.f3z_1 = new Buffer();
+    this.g3z_1 = 0n;
+    this.h3z_1 = 0;
+  }
+  *i3z(ignoreMissing, $completion) {
+    this.g3z_1 = 0n;
+    while (!this.d3z_1.n1s() || (yield* this.z3y_1.t3y(VOID, $completion))) {
+      yield* /*#__NOINLINE__*/advanceToNextPotentialMatch(this, $completion);
+      if (yield* /*#__NOINLINE__*/checkFullMatch(this, $completion)) {
+        return this.g3z_1;
+      }
+    }
+    if (!ignoreMissing) {
+      throw IOException.x1v('Expected "' + toSingleLineString(this, this.a3z_1) + '" but encountered end of input');
+    }
+    this.g3z_1 = add(this.g3z_1, this.f3z_1.u1t(this.b3z_1.a3y()));
+    yield* this.b3z_1.u3y($completion);
+    return this.g3z_1;
+  }
+}
+class ByteReadChannel$Companion$Empty$1 {
+  constructor() {
+    this.l3z_1 = null;
+    this.m3z_1 = new Buffer();
+  }
+  h3y() {
+    return this.l3z_1;
+  }
+  m3y() {
+    return true;
+  }
+  u3x() {
+    return this.m3z_1;
+  }
+  *n3y(min, $completion) {
+    return false;
+  }
+  x3y(cause) {
+  }
+}
+class Companion_0 {
+  constructor() {
+    Companion_instance_1 = this;
+    var tmp = this;
+    tmp.n3z_1 = new ByteReadChannel$Companion$Empty$1();
+  }
+}
+class WriterJob {
+  constructor(channel, job) {
+    this.j3z_1 = channel;
+    this.k3z_1 = job;
+  }
+  s2x() {
+    return this.k3z_1;
+  }
+}
+class WriterScope {
+  constructor(channel, coroutineContext) {
+    this.t3z_1 = channel;
+    this.u3z_1 = coroutineContext;
+  }
+  o2r() {
+    return this.u3z_1;
+  }
+}
+class NO_CALLBACK$1 {
+  constructor() {
+    this.v3z_1 = EmptyCoroutineContext_instance;
+  }
+  sc() {
+    return this.v3z_1;
+  }
+  tc(result) {
+    return Unit_instance;
+  }
+  uc(result) {
+    return this.tc(result);
+  }
+}
+class Companion_1 {}
+class CloseToken {
+  constructor(origin) {
+    this.w3z_1 = origin;
+  }
+}
+class CountedByteReadChannel {
+  constructor(delegate) {
+    this.x3z_1 = delegate;
+    this.y3z_1 = new Buffer();
+    this.z3z_1 = 0n;
+    this.a40_1 = 0n;
+  }
+  b40() {
+    updateConsumed(this);
+    return this.a40_1;
+  }
+  h3y() {
+    return this.x3z_1.h3y();
+  }
+  m3y() {
+    return this.y3z_1.n1s() && this.x3z_1.m3y();
+  }
+  u3x() {
+    transferFromDelegate(this);
+    return this.y3z_1;
+  }
+  *n3y(min, $completion) {
+    if (this.u3x().p2() >= fromInt(min)) {
+      return true;
+    }
+    if (yield* this.x3z_1.n3y(min, $completion)) {
+      transferFromDelegate(this);
+      return true;
+    }
+    return false;
+  }
+  x3y(cause) {
+    this.x3z_1.x3y(cause);
+    this.y3z_1.q6();
+  }
+}
+class ClosedByteChannelException extends IOException {
+  constructor(cause) {
+    return new.target.l3y(cause);
+  }
+  static l3y(cause) {
+    cause = cause === VOID ? null : cause;
+    var $this = this.y1v(cause == null ? null : cause.message, cause);
+    captureStack($this, $this.k3y_1);
+    return $this;
+  }
+}
+class ClosedReadChannelException extends ClosedByteChannelException {
+  constructor(cause) {
+    return new.target.z3x(cause);
+  }
+  static z3x(cause) {
+    cause = cause === VOID ? null : cause;
+    var $this = this.l3y(cause);
+    captureStack($this, $this.y3x_1);
+    return $this;
+  }
+}
+class ClosedWriteChannelException extends ClosedByteChannelException {
+  constructor(cause) {
+    return new.target.f3y(cause);
+  }
+  static f3y(cause) {
+    cause = cause === VOID ? null : cause;
+    var $this = this.l3y(cause);
+    captureStack($this, $this.e3y_1);
+    return $this;
+  }
+}
+class LineEnding extends Enum {}
+class Companion_2 {
+  constructor() {
+    Companion_instance_3 = this;
+    this.c40_1 = _LineEndingMode___init__impl__jo5bul(1);
+    this.d40_1 = _LineEndingMode___init__impl__jo5bul(2);
+    this.e40_1 = _LineEndingMode___init__impl__jo5bul(4);
+    this.f40_1 = _LineEndingMode___init__impl__jo5bul(7);
+    this.g40_1 = listOf([new LineEndingMode(this.c40_1), new LineEndingMode(this.d40_1), new LineEndingMode(this.e40_1)]);
+  }
+}
+class LineEndingMode {
+  constructor(mode) {
+    Companion_getInstance_2();
+    this.h40_1 = mode;
+  }
+  toString() {
+    return LineEndingMode__toString_impl_j4h76r(this.h40_1);
+  }
+  hashCode() {
+    return LineEndingMode__hashCode_impl_2mopm4(this.h40_1);
+  }
+  equals(other) {
+    return LineEndingMode__equals_impl_qyr4nk(this.h40_1, other);
+  }
+}
+class SourceByteReadChannel {
+  constructor(source) {
+    this.i40_1 = source;
+    this.j40_1 = null;
+  }
+  h3y() {
+    var tmp0_safe_receiver = this.j40_1;
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'io.ktor.utils.io.Companion.wrapCause' call
+      var tmp0_subject = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+      var tmp_0;
+      if (tmp0_subject == null) {
+        tmp_0 = null;
+      } else {
+        if (isInterface(tmp0_subject, CopyableThrowable)) {
+          tmp_0 = access$_get_origin__hdh1qz(tmp0_safe_receiver).s2y();
+        } else {
+          if (tmp0_subject instanceof CancellationException) {
+            tmp_0 = CancellationException.p(access$_get_origin__hdh1qz(tmp0_safe_receiver).message, access$_get_origin__hdh1qz(tmp0_safe_receiver));
+          } else {
+            var p0 = access$_get_origin__hdh1qz(tmp0_safe_receiver);
+            tmp_0 = ClosedByteChannelException.l3y(p0);
+          }
+        }
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  m3y() {
+    return this.i40_1.n1s();
+  }
+  u3x() {
+    var tmp0_safe_receiver = this.h3y();
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      throw tmp0_safe_receiver;
+    }
+    return this.i40_1.m1s();
+  }
+  *n3y(min, $completion) {
+    var tmp0_safe_receiver = this.h3y();
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      throw tmp0_safe_receiver;
+    }
+    return this.i40_1.p1s(fromInt(min));
+  }
+  x3y(cause) {
+    if (!(this.j40_1 == null))
+      return Unit_instance;
+    this.i40_1.q6();
+    var tmp = this;
+    var tmp1_elvis_lhs = cause == null ? null : cause.message;
+    tmp.j40_1 = new CloseToken(IOException.y1v(tmp1_elvis_lhs == null ? 'Channel was cancelled' : tmp1_elvis_lhs, cause));
+  }
+}
+class MalformedInputException extends IOException {
+  constructor(message) {
+    return new.target.n40(message);
+  }
+  static n40(message) {
+    var $this = this.x1v(message);
+    captureStack($this, $this.m40_1);
+    return $this;
+  }
+}
+class TooLongLineException extends MalformedInputException {
+  constructor(message) {
+    return new.target.s3z(message);
+  }
+  static s3z(message) {
+    var $this = this.n40(message);
+    captureStack($this, $this.r3z_1);
+    return $this;
+  }
+}
+class ObjectPool {}
+function close() {
+  this.d2v();
+}
+class DefaultPool {
+  constructor(capacity) {
+    this.x40_1 = capacity;
+    var tmp = this;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = this.x40_1;
+    tmp.y40_1 = Array(size);
+    this.z40_1 = 0;
+  }
+  a41(instance) {
+  }
+  b41(instance) {
+    return instance;
+  }
+  c41(instance) {
+  }
+  d41() {
+    if (this.z40_1 === 0)
+      return this.w40();
+    this.z40_1 = this.z40_1 - 1 | 0;
+    var idx = this.z40_1;
+    var tmp = this.y40_1[idx];
+    var instance = !(tmp == null) ? tmp : THROW_CCE();
+    this.y40_1[idx] = null;
+    return this.b41(instance);
+  }
+  e41(instance) {
+    this.c41(instance);
+    if (this.z40_1 === this.x40_1) {
+      this.a41(instance);
+    } else {
+      var _unary__edvuaz = this.z40_1;
+      this.z40_1 = _unary__edvuaz + 1 | 0;
+      this.y40_1[_unary__edvuaz] = instance;
+    }
+  }
+  d2v() {
+    var inductionVariable = 0;
+    var last = this.z40_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = this.y40_1[i];
+        var instance = !(tmp == null) ? tmp : THROW_CCE();
+        this.y40_1[i] = null;
+        this.a41(instance);
+      }
+       while (inductionVariable < last);
+    this.z40_1 = 0;
+  }
+}
+class ByteArrayPool$1 extends DefaultPool {
+  constructor() {
+    super(128);
+  }
+  w40() {
+    return new Int8Array(4096);
+  }
+}
+class NoPoolImpl {
+  e41(instance) {
+    return Unit_instance;
+  }
+  d2v() {
+    return Unit_instance;
+  }
+}
+class Companion_3 {
+  f41(name) {
+    switch (name) {
+      case 'UTF-8':
+      case 'utf-8':
+      case 'UTF8':
+      case 'utf8':
+        return Charsets_getInstance().o40_1;
+    }
+    var tmp;
+    var tmp_0;
+    switch (name) {
+      case 'ISO-8859-1':
+      case 'iso-8859-1':
+        tmp_0 = true;
+        break;
+      default:
+        // Inline function 'kotlin.let' call
+
+        var it = replace_0(name, _Char___init__impl__6a9atx(95), _Char___init__impl__6a9atx(45));
+        var tmp_1;
+        if (it === 'iso-8859-1') {
+          tmp_1 = true;
+        } else {
+          // Inline function 'kotlin.text.lowercase' call
+          // Inline function 'kotlin.js.asDynamic' call
+          tmp_1 = it.toLowerCase() === 'iso-8859-1';
+        }
+
+        tmp_0 = tmp_1;
+        break;
+    }
+    if (tmp_0) {
+      tmp = true;
+    } else {
+      tmp = name === 'latin1' || name === 'Latin1';
+    }
+    if (tmp) {
+      return Charsets_getInstance().p40_1;
+    }
+    throw IllegalArgumentException.n2('Charset ' + name + ' is not supported');
+  }
+}
+class Charset {
+  constructor(_name) {
+    this.q40_1 = _name;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (other == null || !(this.constructor == other.constructor))
+      return false;
+    if (!(other instanceof Charset))
+      THROW_CCE();
+    return this.q40_1 === other.q40_1;
+  }
+  hashCode() {
+    return getStringHashCode(this.q40_1);
+  }
+  toString() {
+    return this.q40_1;
+  }
+}
+class Charsets {
+  constructor() {
+    Charsets_instance = this;
+    this.o40_1 = new CharsetImpl('UTF-8');
+    this.p40_1 = new CharsetImpl('ISO-8859-1');
+  }
+}
+class CharsetDecoder {
+  constructor(_charset) {
+    this.g41_1 = _charset;
+  }
+}
+class CharsetEncoder {
+  constructor(_charset) {
+    this.h41_1 = _charset;
+  }
+}
+class CharsetImpl extends Charset {
+  s40() {
+    return new CharsetEncoderImpl(this);
+  }
+  r40() {
+    return new CharsetDecoderImpl(this);
+  }
+}
+class CharsetEncoderImpl extends CharsetEncoder {
+  constructor(charset) {
+    super(charset);
+    this.l41_1 = charset;
+  }
+  toString() {
+    return 'CharsetEncoderImpl(charset=' + this.l41_1.toString() + ')';
+  }
+  hashCode() {
+    return this.l41_1.hashCode();
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CharsetEncoderImpl))
+      return false;
+    if (!this.l41_1.equals(other.l41_1))
+      return false;
+    return true;
+  }
+}
+class CharsetDecoderImpl extends CharsetDecoder {
+  constructor(charset) {
+    super(charset);
+    this.n41_1 = charset;
+  }
+  toString() {
+    return 'CharsetDecoderImpl(charset=' + this.n41_1.toString() + ')';
+  }
+  hashCode() {
+    return this.n41_1.hashCode();
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CharsetDecoderImpl))
+      return false;
+    if (!this.n41_1.equals(other.n41_1))
+      return false;
+    return true;
+  }
+}
+class toKtor$1 {
+  constructor($this_toKtor) {
+    this.o41_1 = $this_toKtor;
+  }
+  i41(buffer) {
+    return this.o41_1.decode(buffer);
+  }
+}
+class TextDecoderFallback {
+  constructor(encoding, fatal) {
+    this.p41_1 = fatal;
+    // Inline function 'kotlin.text.trim' call
+    // Inline function 'kotlin.text.lowercase' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var requestedEncoding = toString_1(trim(isCharSequence(encoding) ? encoding : THROW_CCE())).toLowerCase();
+    // Inline function 'kotlin.check' call
+    if (!get_ENCODING_ALIASES().j3(requestedEncoding)) {
+      var message = encoding + ' is not supported.';
+      throw IllegalStateException.o(toString_1(message));
+    }
+  }
+  i41(buffer) {
+    // Inline function 'io.ktor.utils.io.core.buildPacket' call
+    var builder = new Buffer();
+    var bytes = buffer instanceof Int8Array ? buffer : THROW_CCE();
+    var inductionVariable = 0;
+    var last = bytes.length;
+    if (inductionVariable < last)
+      $l$loop: do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'org.khronos.webgl.get' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var byte = bytes[index];
+        var point = toCodePoint(byte);
+        if (point < 0) {
+          // Inline function 'kotlin.check' call
+          if (!!this.p41_1) {
+            var message = 'Invalid character: ' + point;
+            throw IllegalStateException.o(toString_1(message));
+          }
+          writeFully_0(builder, get_REPLACEMENT());
+          continue $l$loop;
+        }
+        if (point > 255) {
+          builder.j1u(toByte(point >> 8));
+        }
+        builder.j1u(toByte(point & 255));
+      }
+       while (inductionVariable < last);
+    return decodeToString(readByteArray_0(builder));
+  }
+}
+//endregion
+var Companion_instance_0;
+function Companion_getInstance() {
+  if (Companion_instance_0 === VOID)
+    new Companion();
+  return Companion_instance_0;
+}
+var Empty_instance;
+function Empty_getInstance() {
+  return Empty_instance;
+}
+function moveFlushToReadBuffer($this) {
+  // Inline function 'io.ktor.utils.io.locks.synchronized' call
+  $this.l3x_1;
+  $this.j3x_1.u1t($this.n3x_1);
+  $this.k3x_1 = 0;
+  // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+  var current = $this.m3x_1.kotlinx$atomicfu$value;
+  var tmp;
+  if (current instanceof Write) {
+    tmp = $this.m3x_1.atomicfu$compareAndSet(current, Empty_instance);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    current.c3x();
+  }
+}
+function closeSlot($this, cause) {
+  var closeContinuation = !(cause == null) ? new Closed(cause) : Companion_getInstance().w3w_1;
+  var continuation = $this.m3x_1.atomicfu$getAndSet(closeContinuation);
+  if (isInterface(continuation, Task)) {
+    continuation.d3x(cause);
+  }
+  var tmp0_safe_receiver = $this.q3x_1.atomicfu$getAndSet(null);
+  if (tmp0_safe_receiver == null)
+    null;
+  else
+    tmp0_safe_receiver(cause);
+}
+function ByteChannel$invokeOnClose$lambda() {
+  return Unit_instance;
+}
+function ByteChannel$invokeOnClose$lambda_0() {
+  return Unit_instance;
+}
+function ByteChannel$invokeOnClose$lambda_1(this$0, $handler) {
+  return () => {
+    this$0.q3x_1.atomicfu$compareAndSet($handler, null);
+    return Unit_instance;
+  };
+}
+function ByteReadChannel_0(content, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? content.length : length;
+  // Inline function 'kotlin.also' call
+  var this_0 = new Buffer();
+  this_0.a1u(content, offset, offset + length | 0);
+  var source = this_0;
+  return ByteReadChannel_1(source);
+}
+function ByteReadChannel_1(source) {
+  return new SourceByteReadChannel(source);
+}
+function buildPartialMatchTable($this) {
+  var table = new Int32Array($this.a3z_1.p2());
+  var j = 0;
+  var inductionVariable = 1;
+  var last = $this.a3z_1.p2();
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      while (j > 0 && !($this.a3z_1.q2(i) === $this.a3z_1.q2(j))) {
+        j = table[j - 1 | 0];
+      }
+      if ($this.a3z_1.q2(i) === $this.a3z_1.q2(j)) {
+        j = j + 1 | 0;
+      }
+      table[i] = j;
+    }
+     while (inductionVariable < last);
+  return table;
+}
+function *advanceToNextPotentialMatch($this, $completion) {
+  while (!$this.d3z_1.n1s() || (yield* $this.z3y_1.t3y(VOID, $completion))) {
+    var nextMatch = indexOf($this.d3z_1, $this.a3z_1.q2(0));
+    if (nextMatch === -1n) {
+      var tmp = $this.d3z_1;
+      checkBounds($this, (tmp instanceof Buffer ? tmp : THROW_CCE()).p2());
+      $this.g3z_1 = add($this.g3z_1, $this.d3z_1.u1t($this.b3z_1.a3y()));
+      yield* flushIfNeeded($this.b3z_1, $completion);
+    } else {
+      checkBounds($this, nextMatch);
+      var tmp_0 = $this;
+      var tmp_1 = $this.g3z_1;
+      var tmp_2 = $this.b3z_1.a3y();
+      tmp_0.g3z_1 = add(tmp_1, $this.d3z_1.r1t(tmp_2 instanceof Buffer ? tmp_2 : THROW_CCE(), nextMatch));
+      yield* flushIfNeeded($this.b3z_1, $completion);
+      return Unit_instance;
+    }
+  }
+  return Unit_instance;
+}
+function *checkFullMatch($this, $completion) {
+  while (!$this.d3z_1.n1s() || (yield* $this.z3y_1.t3y(VOID, $completion))) {
+    var byte = $this.d3z_1.q1s();
+    if ($this.h3z_1 > 0 && !(byte === $this.a3z_1.q2($this.h3z_1))) {
+      var oldMatchIndex = $this.h3z_1;
+      while ($this.h3z_1 > 0 && !(byte === $this.a3z_1.q2($this.h3z_1))) {
+        $this.h3z_1 = $this.e3z_1[$this.h3z_1 - 1 | 0];
+      }
+      var retained = fromInt(oldMatchIndex - $this.h3z_1 | 0);
+      checkBounds($this, retained);
+      var tmp = $this;
+      var tmp_0 = $this.g3z_1;
+      var tmp_1 = $this.b3z_1.a3y();
+      tmp.g3z_1 = add(tmp_0, $this.f3z_1.r1t(tmp_1 instanceof Buffer ? tmp_1 : THROW_CCE(), retained));
+      if ($this.h3z_1 === 0 && !(byte === $this.a3z_1.q2($this.h3z_1))) {
+        yield* writeByte($this.b3z_1, byte, $completion);
+        var _unary__edvuaz = $this.g3z_1;
+        $this.g3z_1 = add(_unary__edvuaz, get_ONE());
+        return false;
+      }
+    }
+    $this.h3z_1 = $this.h3z_1 + 1 | 0;
+    if ($this.h3z_1 === $this.a3z_1.p2()) {
+      return true;
+    }
+    $this.f3z_1.j1u(byte);
+  }
+  return false;
+}
+function checkBounds($this, extra) {
+  if (add($this.g3z_1, extra) > $this.c3z_1) {
+    throw IOException.x1v('Limit of ' + $this.c3z_1.toString() + ' bytes exceeded ' + ('while searching for "' + toSingleLineString($this, $this.a3z_1) + '"'));
+  }
+}
+function toSingleLineString($this, $receiver) {
+  return replace(decodeToString_0($receiver), '\n', '\\n');
+}
+function attachWriterJob(_this__u8e3s4, writerJob) {
+  var tmp = writerJob.j3z_1;
+  var tmp0_safe_receiver = tmp instanceof ByteChannel ? tmp : null;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    tmp0_safe_receiver.y3y(attachWriterJob$lambda(_this__u8e3s4));
+  }
+}
+function attachWriterJob$lambda($this_attachWriterJob) {
+  return (cause) => {
+    var tmp;
+    if (!(cause == null)) {
+      $this_attachWriterJob.x3y(cause);
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+var Companion_instance_1;
+function Companion_getInstance_0() {
+  if (Companion_instance_1 === VOID)
+    new Companion_0();
+  return Companion_instance_1;
+}
+function cancel_0(_this__u8e3s4) {
+  _this__u8e3s4.x3y(IOException.x1v('Channel was cancelled'));
+}
+function *readLineStrict(_this__u8e3s4, limit, lineEnding, $completion) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  lineEnding = lineEnding === VOID ? LineEnding_Default_getInstance() : lineEnding;
+  var result = StringBuilder.h1();
+  return (yield* readLineStrictTo(_this__u8e3s4, result, limit, lineEnding, $completion)) >= 0n ? result.toString() : null;
+}
+function *readRemaining(_this__u8e3s4, $completion) {
+  var result = BytePacketBuilder();
+  while (!_this__u8e3s4.m3y()) {
+    result.i1u(_this__u8e3s4.u3x());
+    yield* _this__u8e3s4.t3y(VOID, $completion);
+  }
+  rethrowCloseCauseIfNeeded(_this__u8e3s4);
+  return result.m1s();
+}
+function *toByteArray(_this__u8e3s4, $completion) {
+  return readBytes(yield* readBuffer(_this__u8e3s4, $completion));
+}
+function *copyTo(_this__u8e3s4, channel, limit, $completion) {
+  var remaining = limit;
+  try {
+    while (!_this__u8e3s4.m3y() && remaining > 0n) {
+      if (_this__u8e3s4.u3x().n1s()) {
+        yield* _this__u8e3s4.t3y(VOID, $completion);
+      }
+      var tmp0 = remaining;
+      // Inline function 'kotlin.comparisons.minOf' call
+      var b = get_remaining(_this__u8e3s4.u3x());
+      var count = tmp0 <= b ? tmp0 : b;
+      _this__u8e3s4.u3x().t1t(channel.a3y(), count);
+      remaining = subtract(remaining, count);
+      yield* channel.u3y($completion);
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var cause = $p;
+      _this__u8e3s4.x3y(cause);
+      close_0(channel, cause);
+      throw cause;
+    } else {
+      throw $p;
+    }
+  }
+  finally {
+    yield* channel.u3y($completion);
+  }
+  return subtract(limit, remaining);
+}
+function rethrowCloseCauseIfNeeded(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.h3y();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function *discard(_this__u8e3s4, max, $completion) {
+  max = max === VOID ? 9223372036854775807n : max;
+  var remaining = max;
+  while (remaining > 0n && !_this__u8e3s4.m3y()) {
+    if (get_availableForRead(_this__u8e3s4) === 0) {
+      yield* _this__u8e3s4.t3y(VOID, $completion);
+    }
+    var tmp0 = remaining;
+    // Inline function 'kotlin.comparisons.minOf' call
+    var b = get_remaining(_this__u8e3s4.u3x());
+    var count = tmp0 <= b ? tmp0 : b;
+    discard_0(_this__u8e3s4.u3x(), count);
+    remaining = subtract(remaining, count);
+  }
+  return subtract(max, remaining);
+}
+function *readAvailable(_this__u8e3s4, buffer, offset, length, $completion) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  if (_this__u8e3s4.m3y())
+    return -1;
+  if (_this__u8e3s4.u3x().n1s()) {
+    yield* _this__u8e3s4.t3y(VOID, $completion);
+  }
+  if (_this__u8e3s4.m3y())
+    return -1;
+  return readAvailable_0(_this__u8e3s4.u3x(), buffer, offset, length);
+}
+function *skipIfFound(_this__u8e3s4, byteString, $completion) {
+  if (equals(yield* peek(_this__u8e3s4, byteString.p2(), $completion), byteString)) {
+    yield* /*#__NOINLINE__*/discard(_this__u8e3s4, fromInt(byteString.p2()), $completion);
+    return true;
+  }
+  return false;
+}
+function *readPacket(_this__u8e3s4, packet, $completion) {
+  var result = new Buffer();
+  $l$loop: while (result.p2() < fromInt(packet)) {
+    if (_this__u8e3s4.u3x().n1s()) {
+      yield* _this__u8e3s4.t3y(VOID, $completion);
+    }
+    if (_this__u8e3s4.m3y())
+      break $l$loop;
+    if (get_remaining(_this__u8e3s4.u3x()) > subtract(numberToLong(packet), result.p2())) {
+      _this__u8e3s4.u3x().t1t(result, subtract(numberToLong(packet), result.p2()));
+    } else {
+      _this__u8e3s4.u3x().u1t(result);
+    }
+  }
+  if (result.p2() < fromInt(packet)) {
+    throw EOFException.l1s('Not enough data available, required ' + packet + ' bytes but only ' + result.p2().toString() + ' available');
+  }
+  return result;
+}
+function *readUntil(_this__u8e3s4, matchString, writeChannel, limit, ignoreMissing, $completion) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  ignoreMissing = ignoreMissing === VOID ? false : ignoreMissing;
+  return yield* (new ByteChannelScanner(_this__u8e3s4, matchString, writeChannel, limit)).i3z(ignoreMissing, $completion);
+}
+function *readLineStrictTo(_this__u8e3s4, out, limit, lineEnding, $completion) {
+  limit = limit === VOID ? 9223372036854775807n : limit;
+  lineEnding = lineEnding === VOID ? LineEnding_Default_getInstance() : lineEnding;
+  // Inline function 'kotlin.require' call
+  if (!(limit >= 0n)) {
+    var message = 'Limit (' + limit.toString() + ') should be non-negative';
+    throw IllegalArgumentException.n2(toString_1(message));
+  }
+  return yield* internalReadLineTo(_this__u8e3s4, out, limit, lineEnding.equals(LineEnding_Lenient_getInstance()), true, $completion);
+}
+function rethrowCloseCauseIfNeeded_0(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.h3y();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function *readBuffer(_this__u8e3s4, $completion) {
+  var result = new Buffer();
+  while (!_this__u8e3s4.m3y()) {
+    result.i1u(_this__u8e3s4.u3x());
+    yield* _this__u8e3s4.t3y(VOID, $completion);
+  }
+  var tmp0_safe_receiver = _this__u8e3s4.h3y();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+  return result;
+}
+function get_availableForRead(_this__u8e3s4) {
+  return convertToInt(_this__u8e3s4.u3x().m1s().p2());
+}
+function *peek(_this__u8e3s4, count, $completion) {
+  if (_this__u8e3s4.m3y())
+    return null;
+  if (!(yield* _this__u8e3s4.n3y(count, $completion)))
+    return null;
+  return readByteString(_this__u8e3s4.u3x().v1t(), count);
+}
+function *internalReadLineTo(_this__u8e3s4, out, limit, lenientLineEnding, throwOnIncompleteLine, $completion) {
+  var readBuffer = _this__u8e3s4.u3x();
+  if (readBuffer.n1s()) {
+    yield* _this__u8e3s4.t3y(VOID, $completion);
+  }
+  if (_this__u8e3s4.m3y())
+    return -1n;
+  var consumed = {_v: 0n};
+  $l$loop: while (consumed._v < limit && !_this__u8e3s4.m3y()) {
+    var limitLeft = subtract(limit, consumed._v);
+    var lfIndex = indexOf(readBuffer, 10, VOID, limitLeft);
+    var crIndex = internalReadLineTo$scanForSoleCr(readBuffer, lenientLineEnding, lfIndex, limitLeft);
+    if (crIndex >= 0n) {
+      internalReadLineTo$transferString(readBuffer, out, consumed, crIndex);
+      discard_0(readBuffer, 1n);
+      return consumed._v;
+    }
+    if (lfIndex === 0n) {
+      discard_0(readBuffer, 1n);
+      return consumed._v;
+    }
+    if (lfIndex > 0n) {
+      var tmp;
+      var tmp_0 = readBuffer.m1s();
+      // Inline function 'kotlin.Long.minus' call
+      var tmp$ret$0 = subtract(lfIndex, fromInt(1));
+      if (tmp_0.m1t(tmp$ret$0) === 13) {
+        tmp = 1n;
+      } else {
+        tmp = 0n;
+      }
+      var isCrlf = tmp;
+      internalReadLineTo$transferString(readBuffer, out, consumed, subtract(lfIndex, isCrlf));
+      discard_0(readBuffer, add(numberToLong(1), isCrlf));
+      return consumed._v;
+    }
+    // Inline function 'kotlin.comparisons.minOf' call
+    var b = get_remaining(readBuffer);
+    var count = limitLeft <= b ? limitLeft : b;
+    var tmp_1 = readBuffer.m1s();
+    // Inline function 'kotlin.Long.minus' call
+    var tmp$ret$2 = subtract(count, fromInt(1));
+    if (tmp_1.m1t(tmp$ret$2) === 13) {
+      // Inline function 'kotlin.Long.minus' call
+      var tmp$ret$3 = subtract(count, fromInt(1));
+      internalReadLineTo$transferString(readBuffer, out, consumed, tmp$ret$3);
+      if (yield* internalReadLineTo$discardCrlfOrCr(readBuffer, _this__u8e3s4, lenientLineEnding, $completion))
+        return consumed._v;
+      internalReadLineTo$transferString(readBuffer, out, consumed, 1n);
+    } else {
+      internalReadLineTo$transferString(readBuffer, out, consumed, count);
+    }
+    if (consumed._v < limit && get_remaining(readBuffer) === 0n && !(yield* _this__u8e3s4.t3y(VOID, $completion)))
+      break $l$loop;
+  }
+  if (consumed._v === 0n && _this__u8e3s4.m3y())
+    return -1n;
+  // Inline function 'kotlin.check' call
+  if (!(consumed._v <= limit)) {
+    var message = 'Consumed bytes exceed the limit: ' + consumed._v.toString() + ' > ' + limit.toString() + ". It's an implementation bug, please report it.";
+    throw IllegalStateException.o(toString_1(message));
+  }
+  if (consumed._v === limit) {
+    if (limit === 9223372036854775807n)
+      throw TooLongLineException.s3z('Max line length exceeded');
+    if (get_remaining(readBuffer) === 0n && !(yield* _this__u8e3s4.t3y(VOID, $completion))) {
+      throwEndOfStreamException(consumed._v);
+    }
+    var tmp0_subject = readBuffer.m1s().m1t(0n);
+    if (tmp0_subject === 10) {
+      discard_0(readBuffer, 1n);
+      return consumed._v;
+    } else if (tmp0_subject === 13)
+      if (yield* internalReadLineTo$discardCrlfOrCr(readBuffer, _this__u8e3s4, lenientLineEnding, $completion))
+        return consumed._v;
+    throwTooLongLineException(limit);
+  }
+  if (throwOnIncompleteLine) {
+    throwEndOfStreamException(consumed._v);
+  }
+  return consumed._v;
+}
+function throwEndOfStreamException(consumed) {
+  throw EOFException.l1s('Unexpected end of stream after reading ' + consumed.toString() + ' characters');
+}
+function throwTooLongLineException(limit) {
+  throw TooLongLineException.s3z('Line exceeds limit of ' + limit.toString() + ' characters');
+}
+function rethrowCloseCauseIfNeeded_1(_this__u8e3s4) {
+  var tmp0_safe_receiver = _this__u8e3s4.h3y();
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    throw tmp0_safe_receiver;
+  }
+}
+function internalReadLineTo$transferString(readBuffer, $out, consumed, count) {
+  if (count > 0n) {
+    var string = readString(readBuffer, count);
+    $out.o2(string);
+    var tmp0 = consumed._v;
+    // Inline function 'kotlin.Long.plus' call
+    var other = string.length;
+    consumed._v = add(tmp0, fromInt(other));
+  }
+}
+function internalReadLineTo$scanForSoleCr(_this__u8e3s4, $lenientLineEnding, lfIndex, limitLeft) {
+  if (!$lenientLineEnding)
+    return -1n;
+  var tmp;
+  if (lfIndex === -1n) {
+    // Inline function 'kotlin.Long.minus' call
+    var this_0 = get_remaining(_this__u8e3s4);
+    // Inline function 'kotlin.comparisons.minOf' call
+    var b = subtract(this_0, fromInt(1));
+    tmp = limitLeft <= b ? limitLeft : b;
+  } else if (lfIndex === 0n) {
+    tmp = 0n;
+  } else {
+    // Inline function 'kotlin.Long.minus' call
+    tmp = subtract(lfIndex, fromInt(1));
+  }
+  var endIndex = tmp;
+  return indexOf(_this__u8e3s4, 13, VOID, endIndex);
+}
+function *internalReadLineTo$discardCrlfOrCr(_this__u8e3s4, $this_internalReadLineTo, $lenientLineEnding, $completion) {
+  if ((get_remaining(_this__u8e3s4) >= 2n || (yield* $this_internalReadLineTo.n3y(2, $completion))) && _this__u8e3s4.m1s().m1t(1n) === 10) {
+    discard_0(_this__u8e3s4, 2n);
+    return true;
+  }
+  if ($lenientLineEnding) {
+    discard_0(_this__u8e3s4, 1n);
+    return true;
+  }
+  return false;
+}
+function *flushIfNeeded(_this__u8e3s4, $completion) {
+  rethrowCloseCauseIfNeeded_1(_this__u8e3s4);
+  if (_this__u8e3s4.s3x() || get_size(_this__u8e3s4.a3y()) >= 1048576)
+    yield* _this__u8e3s4.u3y($completion);
+  return Unit_instance;
+}
+function ByteWriteChannel$flushAndClose$ref(p0) {
+  return constructCallableReference(function *($completion) {
+    return yield* p0.w3y($completion);
+  }, 0, 1, 79, 'flushAndClose', [p0]);
+}
+function get_NO_CALLBACK() {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return NO_CALLBACK;
+}
+var NO_CALLBACK;
+function writer(_this__u8e3s4, coroutineContext, autoFlush, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_instance : coroutineContext;
+  autoFlush = autoFlush === VOID ? false : autoFlush;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return writer_0(_this__u8e3s4, coroutineContext, new ByteChannel(), block);
+}
+function invokeOnCompletion(_this__u8e3s4, block) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return _this__u8e3s4.s2x().r2s(block);
+}
+function *writeFully(_this__u8e3s4, value, startIndex, endIndex, $completion) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? value.length : endIndex;
+  _this__u8e3s4.a3y().a1u(value, startIndex, endIndex);
+  yield* flushIfNeeded(_this__u8e3s4, $completion);
+  return Unit_instance;
+}
+function close_0(_this__u8e3s4, cause) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  if (cause == null) {
+    fireAndForget(ByteWriteChannel$flushAndClose$ref(_this__u8e3s4));
+  } else {
+    _this__u8e3s4.x3y(cause);
+  }
+}
+function writer_0(_this__u8e3s4, coroutineContext, channel, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_instance : coroutineContext;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  // Inline function 'kotlin.apply' call
+  var this_0 = launch(_this__u8e3s4, coroutineContext, VOID, writer$slambda(block, channel));
+  this_0.r2s(writer$lambda(channel));
+  var job = this_0;
+  return new WriterJob(channel, job);
+}
+function fireAndForget(_this__u8e3s4) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  startCoroutineCancellable(_this__u8e3s4, get_NO_CALLBACK());
+}
+function *writeByte(_this__u8e3s4, value, $completion) {
+  _this__u8e3s4.a3y().j1u(value);
+  yield* flushIfNeeded(_this__u8e3s4, $completion);
+  return Unit_instance;
+}
+function writer$slambda($block, $channel) {
+  return constructCallableReference(function *($this$launch, $completion) {
+    var nested = Job(get_job($this$launch.o2r()));
+    var tmp;
+    try {
+      yield* $block(new WriterScope($channel, $this$launch.o2r().xl(nested)), $completion);
+      nested.e2y();
+      var tmp_0;
+      if (get_job($this$launch.o2r()).l2s()) {
+        $channel.x3y(get_job($this$launch.o2r()).o2s());
+        tmp_0 = Unit_instance;
+      }
+      tmp = tmp_0;
+    } catch ($p) {
+      var tmp_1;
+      if ($p instanceof Error) {
+        var cause = $p;
+        cancel(nested, 'Exception thrown while writing to channel', cause);
+        $channel.x3y(cause);
+        tmp_1 = Unit_instance;
+      } else {
+        throw $p;
+      }
+      tmp = tmp_1;
+    }
+    finally {
+      yield* nested.v2s($completion);
+      // Inline function 'kotlin.runCatching' call
+      var tmp_2;
+      try {
+        yield* $channel.w3y($completion);
+        // Inline function 'kotlin.Companion.success' call
+        tmp_2 = _Result___init__impl__xyqfz8(Unit_instance);
+      } catch ($p_0) {
+        var tmp_3;
+        if ($p_0 instanceof Error) {
+          var e = $p_0;
+          // Inline function 'kotlin.Companion.failure' call
+          tmp_3 = _Result___init__impl__xyqfz8(createFailure(e));
+        } else {
+          throw $p_0;
+        }
+        tmp_2 = tmp_3;
+      }
+    }
+    return Unit_instance;
+  }, 1);
+}
+function writer$lambda($channel) {
+  return (it) => {
+    var tmp;
+    if (!(it == null) && !$channel.g3y()) {
+      $channel.x3y(it);
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+var properties_initialized_ByteWriteChannelOperations_kt_acrf6u;
+function _init_properties_ByteWriteChannelOperations_kt__i7slrs() {
+  if (!properties_initialized_ByteWriteChannelOperations_kt_acrf6u) {
+    properties_initialized_ByteWriteChannelOperations_kt_acrf6u = true;
+    NO_CALLBACK = new NO_CALLBACK$1();
+  }
+}
+function get_CLOSED() {
+  _init_properties_CloseToken_kt__9ucr41();
+  return CLOSED;
+}
+var CLOSED;
+var Companion_instance_2;
+function Companion_getInstance_1() {
+  return Companion_instance_2;
+}
+function access$_get_origin__hdh1qz($this) {
+  return $this.w3z_1;
+}
+var properties_initialized_CloseToken_kt_lgg8zn;
+function _init_properties_CloseToken_kt__9ucr41() {
+  if (!properties_initialized_CloseToken_kt_lgg8zn) {
+    properties_initialized_CloseToken_kt_lgg8zn = true;
+    CLOSED = new CloseToken(null);
+  }
+}
+function transferFromDelegate($this) {
+  updateConsumed($this);
+  var appended = $this.y3z_1.i1u($this.x3z_1.u3x());
+  $this.z3z_1 = add($this.z3z_1, appended);
+}
+function updateConsumed($this) {
+  $this.a40_1 = add($this.a40_1, subtract($this.z3z_1, $this.y3z_1.p2()));
+  $this.z3z_1 = $this.y3z_1.p2();
+}
+function counted(_this__u8e3s4) {
+  return new CountedByteReadChannel(_this__u8e3s4);
+}
+function readText(_this__u8e3s4) {
+  return readString_0(_this__u8e3s4);
+}
+var LineEnding_Default_instance;
+var LineEnding_Lenient_instance;
+var LineEnding_entriesInitialized;
+function LineEnding_initEntries() {
+  if (LineEnding_entriesInitialized)
+    return Unit_instance;
+  LineEnding_entriesInitialized = true;
+  LineEnding_Default_instance = new LineEnding('Default', 0);
+  LineEnding_Lenient_instance = new LineEnding('Lenient', 1);
+}
+function LineEnding_Default_getInstance() {
+  LineEnding_initEntries();
+  return LineEnding_Default_instance;
+}
+function LineEnding_Lenient_getInstance() {
+  LineEnding_initEntries();
+  return LineEnding_Lenient_instance;
+}
+function _LineEndingMode___init__impl__jo5bul(mode) {
+  return mode;
+}
+function _get_mode__dah3bc($this) {
+  return $this;
+}
+function LineEndingMode__contains_impl_q5pr68($this, other) {
+  return (_get_mode__dah3bc($this) | _get_mode__dah3bc(other)) === _get_mode__dah3bc($this);
+}
+function LineEndingMode__plus_impl_ttpz2j($this, other) {
+  return _LineEndingMode___init__impl__jo5bul(_get_mode__dah3bc($this) | _get_mode__dah3bc(other));
+}
+function LineEndingMode__toString_impl_j4h76r($this) {
+  var tmp;
+  if ($this === Companion_getInstance_2().c40_1) {
+    tmp = 'CR';
+  } else if ($this === Companion_getInstance_2().d40_1) {
+    tmp = 'LF';
+  } else if ($this === Companion_getInstance_2().e40_1) {
+    tmp = 'CRLF';
+  } else {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = Companion_getInstance_2().g40_1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList.f2();
+    var _iterator__ex2g4s = tmp0.l1();
+    while (_iterator__ex2g4s.m1()) {
+      var element = _iterator__ex2g4s.n1();
+      var it = element.h40_1;
+      if (LineEndingMode__contains_impl_q5pr68($this, it)) {
+        destination.e2(element);
+      }
+    }
+    tmp = toString_1(destination);
+  }
+  return tmp;
+}
+var Companion_instance_3;
+function Companion_getInstance_2() {
+  if (Companion_instance_3 === VOID)
+    new Companion_2();
+  return Companion_instance_3;
+}
+function LineEndingMode__hashCode_impl_2mopm4($this) {
+  return $this;
+}
+function LineEndingMode__equals_impl_qyr4nk($this, other) {
+  if (!(other instanceof LineEndingMode))
+    return false;
+  if (!($this === other.h40_1))
+    return false;
+  return true;
+}
+function decode(_this__u8e3s4, input, max) {
+  max = max === VOID ? 2147483647 : max;
+  var tmp0 = fromInt(max);
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = input.m1s().p2();
+  var tmp$ret$0 = tmp0 <= b ? tmp0 : b;
+  // Inline function 'kotlin.text.buildString' call
+  var capacity = convertToInt(tmp$ret$0);
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder.ec(capacity);
+  decode_0(_this__u8e3s4, input, this_0, max);
+  return this_0.toString();
+}
+function encode(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  // Inline function 'io.ktor.utils.io.core.buildPacket' call
+  var builder = new Buffer();
+  encodeToImpl(_this__u8e3s4, builder, input, fromIndex, toIndex);
+  return builder;
+}
+function encodeToImpl(_this__u8e3s4, destination, input, fromIndex, toIndex) {
+  var start = fromIndex;
+  if (start >= toIndex)
+    return Unit_instance;
+  $l$loop: while (true) {
+    var rc = encodeImpl(_this__u8e3s4, input, start, toIndex, destination);
+    // Inline function 'kotlin.check' call
+    if (!(rc >= 0)) {
+      throw IllegalStateException.o('Check failed.');
+    }
+    start = start + rc | 0;
+    if (start >= toIndex)
+      break $l$loop;
+  }
+}
+function canRead(_this__u8e3s4) {
+  return !_this__u8e3s4.n1s();
+}
+function readBytes(_this__u8e3s4, count) {
+  count = count === VOID ? convertToInt(_this__u8e3s4.p2()) : count;
+  return readByteArray(_this__u8e3s4, count);
+}
+function writeFully_0(_this__u8e3s4, buffer, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  _this__u8e3s4.a1u(buffer, offset, offset + length | 0);
+}
+function BytePacketBuilder() {
+  return new Buffer();
+}
+function build(_this__u8e3s4) {
+  return _this__u8e3s4.m1s();
+}
+function get_size(_this__u8e3s4) {
+  return convertToInt(_this__u8e3s4.m1s().p2());
+}
+var ByteReadPacketEmpty;
+function get_remaining(_this__u8e3s4) {
+  _init_properties_ByteReadPacket_kt__28475y();
+  return _this__u8e3s4.m1s().p2();
+}
+function discard_0(_this__u8e3s4, count) {
+  count = count === VOID ? 9223372036854775807n : count;
+  _init_properties_ByteReadPacket_kt__28475y();
+  _this__u8e3s4.p1s(count);
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = get_remaining(_this__u8e3s4);
+  var countToDiscard = count <= b ? count : b;
+  _this__u8e3s4.m1s().o1t(countToDiscard);
+  return countToDiscard;
+}
+function takeWhile(_this__u8e3s4, block) {
+  _init_properties_ByteReadPacket_kt__28475y();
+  while (!_this__u8e3s4.n1s() && block(_this__u8e3s4.m1s())) {
+  }
+}
+var properties_initialized_ByteReadPacket_kt_hw4st4;
+function _init_properties_ByteReadPacket_kt__28475y() {
+  if (!properties_initialized_ByteReadPacket_kt_hw4st4) {
+    properties_initialized_ByteReadPacket_kt_hw4st4 = true;
+    ByteReadPacketEmpty = new Buffer();
+  }
+}
+function readAvailable_0(_this__u8e3s4, buffer, offset, length) {
+  offset = offset === VOID ? 0 : offset;
+  length = length === VOID ? buffer.length - offset | 0 : length;
+  var result = _this__u8e3s4.p1t(buffer, offset, offset + length | 0);
+  return result === -1 ? 0 : result;
+}
+function readText_0(_this__u8e3s4, charset, max) {
+  charset = charset === VOID ? Charsets_getInstance().o40_1 : charset;
+  max = max === VOID ? 2147483647 : max;
+  if (charset.equals(Charsets_getInstance().o40_1)) {
+    if (max === 2147483647)
+      return readString_0(_this__u8e3s4);
+    var tmp0 = _this__u8e3s4.m1s().p2();
+    // Inline function 'kotlin.math.min' call
+    var b = fromInt(max);
+    var count = tmp0 <= b ? tmp0 : b;
+    return readString(_this__u8e3s4, count);
+  }
+  return decode(charset.r40(), _this__u8e3s4, max);
+}
+function toByteArray_0(_this__u8e3s4, charset) {
+  charset = charset === VOID ? Charsets_getInstance().o40_1 : charset;
+  if (charset.equals(Charsets_getInstance().o40_1))
+    return encodeToByteArray(_this__u8e3s4, VOID, VOID, true);
+  return encodeToByteArray_0(charset.s40(), _this__u8e3s4, 0, _this__u8e3s4.length);
+}
+function writeText(_this__u8e3s4, text, fromIndex, toIndex, charset) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(text) : toIndex;
+  charset = charset === VOID ? Charsets_getInstance().o40_1 : charset;
+  if (charset === Charsets_getInstance().o40_1) {
+    return writeString(_this__u8e3s4, toString_1(text), fromIndex, toIndex);
+  }
+  encodeToImpl(charset.s40(), _this__u8e3s4, text, fromIndex, toIndex);
+}
+function get_ByteArrayPool() {
+  _init_properties_ByteArrayPool_kt__kfi3uj();
+  return ByteArrayPool;
+}
+var ByteArrayPool;
+var properties_initialized_ByteArrayPool_kt_td6pfh;
+function _init_properties_ByteArrayPool_kt__kfi3uj() {
+  if (!properties_initialized_ByteArrayPool_kt_td6pfh) {
+    properties_initialized_ByteArrayPool_kt_td6pfh = true;
+    ByteArrayPool = new ByteArrayPool$1();
+  }
+}
+var Companion_instance_4;
+function Companion_getInstance_3() {
+  return Companion_instance_4;
+}
+var Charsets_instance;
+function Charsets_getInstance() {
+  if (Charsets_instance === VOID)
+    new Charsets();
+  return Charsets_instance;
+}
+function get_name(_this__u8e3s4) {
+  return _this__u8e3s4.q40_1;
+}
+function forName(_this__u8e3s4, name) {
+  return Companion_instance_4.f41(name);
+}
+function decode_0(_this__u8e3s4, input, dst, max) {
+  var decoder = Decoder(get_name(get_charset(_this__u8e3s4)), true);
+  var tmp0 = input.m1s().p2();
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = fromInt(max);
+  var count = tmp0 <= b ? tmp0 : b;
+  var array = readByteArray(input, convertToInt(count));
+  var tmp;
+  try {
+    // Inline function 'org.khronos.webgl.toInt8Array' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    tmp = decoder.i41(array);
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var cause = $p;
+      var tmp0_elvis_lhs = cause.message;
+      throw MalformedInputException.n40('Failed to decode bytes: ' + (tmp0_elvis_lhs == null ? 'no cause provided' : tmp0_elvis_lhs));
+    } else {
+      throw $p;
+    }
+  }
+  var result = tmp;
+  dst.o2(result);
+  return result.length;
+}
+function encodeImpl(_this__u8e3s4, input, fromIndex, toIndex, dst) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(fromIndex <= toIndex)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException.n2(toString_1(message));
+  }
+  if (get_charset_0(_this__u8e3s4).equals(Charsets_getInstance().p40_1)) {
+    return encodeISO88591(input, fromIndex, toIndex, dst);
+  }
+  // Inline function 'kotlin.require' call
+  if (!(get_charset_0(_this__u8e3s4) === Charsets_getInstance().o40_1)) {
+    var message_0 = 'Only UTF-8 encoding is supported in JS';
+    throw IllegalArgumentException.n2(toString_1(message_0));
+  }
+  var encoder = new TextEncoder();
+  // Inline function 'kotlin.text.substring' call
+  var tmp$ret$5 = toString_1(charSequenceSubSequence(input, fromIndex, toIndex));
+  var result = encoder.encode(tmp$ret$5);
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  dst.d1u(result);
+  return result.length;
+}
+function encodeToByteArray_0(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  return encodeToByteArrayImpl(_this__u8e3s4, input, fromIndex, toIndex);
+}
+function get_charset(_this__u8e3s4) {
+  return _this__u8e3s4.g41_1;
+}
+function get_charset_0(_this__u8e3s4) {
+  return _this__u8e3s4.h41_1;
+}
+function encodeToByteArrayImpl(_this__u8e3s4, input, fromIndex, toIndex) {
+  fromIndex = fromIndex === VOID ? 0 : fromIndex;
+  toIndex = toIndex === VOID ? charSequenceLength(input) : toIndex;
+  var start = fromIndex;
+  if (start >= toIndex)
+    return new Int8Array(0);
+  var dst = new Buffer();
+  var rc = encodeImpl(_this__u8e3s4, input, start, toIndex, dst);
+  start = start + rc | 0;
+  if (start === toIndex) {
+    return readByteArray_0(dst);
+  }
+  encodeToImpl(_this__u8e3s4, dst, input, start, toIndex);
+  return readByteArray_0(dst);
+}
+function Decoder(encoding, fatal) {
+  fatal = fatal === VOID ? true : fatal;
+  var tmp;
+  try {
+    tmp = toKtor(new TextDecoder(encoding, textDecoderOptions(fatal)));
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof Error) {
+      var cause = $p;
+      tmp_0 = new TextDecoderFallback(encoding, fatal);
+    } else {
+      throw $p;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function toKtor(_this__u8e3s4) {
+  return new toKtor$1(_this__u8e3s4);
+}
+function textDecoderOptions(fatal) {
+  fatal = fatal === VOID ? false : fatal;
+  // Inline function 'kotlin.apply' call
+  var this_0 = new Object();
+  // Inline function 'kotlin.js.asDynamic' call
+  // Inline function 'kotlin.with' call
+  this_0.fatal = fatal;
+  return this_0;
+}
+function get_ENCODING_ALIASES() {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return ENCODING_ALIASES;
+}
+var ENCODING_ALIASES;
+function get_REPLACEMENT() {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return REPLACEMENT;
+}
+var REPLACEMENT;
+function toCodePoint(_this__u8e3s4) {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  var value = _this__u8e3s4 & 255;
+  if (isASCII(value)) {
+    return value;
+  }
+  return get_WIN1252_TABLE()[value - 128 | 0];
+}
+function isASCII(_this__u8e3s4) {
+  _init_properties_TextDecoderFallback_js_kt__an7r6m();
+  return 0 <= _this__u8e3s4 ? _this__u8e3s4 <= 127 : false;
+}
+var properties_initialized_TextDecoderFallback_js_kt_6rekzk;
+function _init_properties_TextDecoderFallback_js_kt__an7r6m() {
+  if (!properties_initialized_TextDecoderFallback_js_kt_6rekzk) {
+    properties_initialized_TextDecoderFallback_js_kt_6rekzk = true;
+    ENCODING_ALIASES = setOf(['ansi_x3.4-1968', 'ascii', 'cp1252', 'cp819', 'csisolatin1', 'ibm819', 'iso-8859-1', 'iso-ir-100', 'iso8859-1', 'iso88591', 'iso_8859-1', 'iso_8859-1:1987', 'l1', 'latin1', 'us-ascii', 'windows-1252', 'x-cp1252']);
+    // Inline function 'kotlin.byteArrayOf' call
+    REPLACEMENT = new Int8Array([-17, -65, -67]);
+  }
+}
+function get_DEVELOPMENT_MODE() {
+  return false;
+}
+function ioDispatcher() {
+  return Dispatchers_getInstance().q32_1;
+}
+function encodeISO88591(input, fromIndex, toIndex, dst) {
+  if (fromIndex >= toIndex)
+    return 0;
+  var inductionVariable = fromIndex;
+  if (inductionVariable < toIndex)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.code' call
+      var this_0 = charSequenceGet(input, index);
+      var character = Char__toInt_impl_vasixd(this_0);
+      if (character > 255) {
+        failedToMapError(character);
+      }
+      dst.j1u(toByte(character));
+    }
+     while (inductionVariable < toIndex);
+  return toIndex - fromIndex | 0;
+}
+function failedToMapError(ch) {
+  throw MalformedInputException.n40('The character with unicode point ' + ch + " couldn't be mapped to ISO-8859-1 character");
+}
+function get_WIN1252_TABLE() {
+  _init_properties_Win1252Table_kt__tl0v64();
+  return WIN1252_TABLE;
+}
+var WIN1252_TABLE;
+var properties_initialized_Win1252Table_kt_pkmjoq;
+function _init_properties_Win1252Table_kt__tl0v64() {
+  if (!properties_initialized_Win1252Table_kt_pkmjoq) {
+    properties_initialized_Win1252Table_kt_pkmjoq = true;
+    // Inline function 'kotlin.intArrayOf' call
+    WIN1252_TABLE = new Int32Array([8364, -1, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, -1, 381, -1, -1, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, -1, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]);
+  }
+}
+//region block: post-declaration
+initMetadataForCompanion(Companion);
+initMetadataForObject(Empty, 'Empty');
+initMetadataForClass(Closed, 'Closed');
+initMetadataForInterface(Task, 'Task');
+protoOf(Read).c3x = resume;
+protoOf(Read).d3x = resume_0;
+initMetadataForClass(Read, 'Read', VOID, VOID, [Task]);
+protoOf(Write).c3x = resume;
+protoOf(Write).d3x = resume_0;
+initMetadataForClass(Write, 'Write', VOID, VOID, [Task]);
+initMetadataForClass(sam$kotlinx_coroutines_DisposableHandle$0, 'sam$kotlinx_coroutines_DisposableHandle$0', VOID, VOID, [DisposableHandle, FunctionAdapter]);
+initMetadataForInterface(ByteReadChannel, 'ByteReadChannel', VOID, VOID, VOID, [1]);
+initMetadataForInterface(ByteWriteChannel, 'ByteWriteChannel', VOID, VOID, VOID, [0]);
+protoOf(ByteChannel).t3y = awaitContent$default;
+initMetadataForClass(ByteChannel, 'ByteChannel', ByteChannel, VOID, [ByteReadChannel, ByteWriteChannel], [1, 0]);
+initMetadataForClass(ConcurrentIOException, 'ConcurrentIOException');
+initMetadataForClass(ByteChannelScanner, 'ByteChannelScanner', VOID, VOID, VOID, [1, 0]);
+protoOf(ByteReadChannel$Companion$Empty$1).t3y = awaitContent$default;
+initMetadataForClass(ByteReadChannel$Companion$Empty$1, VOID, VOID, VOID, [ByteReadChannel], [1]);
+initMetadataForCompanion(Companion_0);
+initMetadataForClass(WriterJob, 'WriterJob');
+initMetadataForClass(WriterScope, 'WriterScope');
+initMetadataForClass(NO_CALLBACK$1, VOID, VOID, VOID, [Continuation]);
+initMetadataForCompanion(Companion_1);
+initMetadataForClass(CloseToken, 'CloseToken');
+protoOf(CountedByteReadChannel).t3y = awaitContent$default;
+initMetadataForClass(CountedByteReadChannel, 'CountedByteReadChannel', VOID, VOID, [ByteReadChannel], [1]);
+initMetadataForClass(ClosedByteChannelException, 'ClosedByteChannelException', ClosedByteChannelException.l3y);
+initMetadataForClass(ClosedReadChannelException, 'ClosedReadChannelException', ClosedReadChannelException.z3x);
+initMetadataForClass(ClosedWriteChannelException, 'ClosedWriteChannelException', ClosedWriteChannelException.f3y);
+initMetadataForClass(LineEnding, 'LineEnding');
+initMetadataForCompanion(Companion_2);
+initMetadataForClass(LineEndingMode, 'LineEndingMode');
+protoOf(SourceByteReadChannel).t3y = awaitContent$default;
+initMetadataForClass(SourceByteReadChannel, 'SourceByteReadChannel', VOID, VOID, [ByteReadChannel], [1]);
+initMetadataForClass(MalformedInputException, 'MalformedInputException');
+initMetadataForClass(TooLongLineException, 'TooLongLineException');
+initMetadataForInterface(ObjectPool, 'ObjectPool', VOID, VOID, [AutoCloseable]);
+protoOf(DefaultPool).q6 = close;
+initMetadataForClass(DefaultPool, 'DefaultPool', VOID, VOID, [ObjectPool]);
+initMetadataForClass(ByteArrayPool$1);
+protoOf(NoPoolImpl).q6 = close;
+initMetadataForClass(NoPoolImpl, 'NoPoolImpl', VOID, VOID, [ObjectPool]);
+initMetadataForCompanion(Companion_3);
+initMetadataForClass(Charset, 'Charset');
+initMetadataForObject(Charsets, 'Charsets');
+initMetadataForClass(CharsetDecoder, 'CharsetDecoder');
+initMetadataForClass(CharsetEncoder, 'CharsetEncoder');
+initMetadataForClass(CharsetImpl, 'CharsetImpl');
+initMetadataForClass(CharsetEncoderImpl, 'CharsetEncoderImpl');
+initMetadataForClass(CharsetDecoderImpl, 'CharsetDecoderImpl');
+initMetadataForClass(toKtor$1);
+initMetadataForClass(TextDecoderFallback, 'TextDecoderFallback');
+//endregion
+//region block: init
+Empty_instance = new Empty();
+Companion_instance_2 = new Companion_1();
+Companion_instance_4 = new Companion_3();
+//endregion
+//region block: exports
+export {
+  LineEndingMode__plus_impl_ttpz2j as LineEndingMode__plus_impl_ttpz2j3u2ebrlepd29o,
+  Charsets_getInstance as Charsets_getInstance3jooo7e4x0j2x,
+  Companion_getInstance_0 as Companion_getInstance25751un9ltd4f,
+  Companion_getInstance_2 as Companion_getInstance33j3lym6q7yx7,
+  copyTo as copyTo1e8cxw3cmqjst,
+  readAvailable as readAvailable2yaaricqompas,
+  readLineStrictTo as readLineStrictTo30g42df56og5l,
+  readLineStrict as readLineStrict37pbadwlm0pk8,
+  readPacket as readPacket25aqlhslm04t6,
+  readRemaining as readRemaining1kbpbgdrq25q1,
+  readUntil as readUntil13nwpwqdlw2vo,
+  skipIfFound as skipIfFound2z2la3mzzpubl,
+  toByteArray as toByteArray1nbmiiav9igm0,
+  writeFully as writeFullyuc6cd2hh6ex3,
+  MalformedInputException as MalformedInputExceptionbvc6h5ij0ias,
+  decode as decode1t43jmuxrxpmo,
+  encode as encode35e4rpnc94tb5,
+  forName as forName2faodmskqnoz5,
+  get_name as get_name2f11g4r0d5pxp,
+  BytePacketBuilder as BytePacketBuilder2biodf4wxvlba,
+  build as buildjygoh729rhy8,
+  canRead as canRead1guo8vbveth0f,
+  discard_0 as discard3ugntd47xyll6,
+  readText_0 as readText27783kyxjxi1g,
+  get_remaining as get_remaining1lapv95kcmm0y,
+  get_size as get_size2imoy2jq11jxl,
+  takeWhile as takeWhile34751tcfg6owx,
+  toByteArray_0 as toByteArray1i3ns5jnoqlv6,
+  writeFully_0 as writeFully359t6q8kam2g5,
+  writeText as writeText19qfzm98fbm4l,
+  get_ByteArrayPool as get_ByteArrayPool3f7yrgvqxz9ct,
+  DefaultPool as DefaultPool2gb1fm4epwgu9,
+  NoPoolImpl as NoPoolImplgos9n8jphzjp,
+  ByteChannel as ByteChannel3cxdguezl3lu7,
+  ByteReadChannel_1 as ByteReadChannel2ndu7k90iil3s,
+  ByteReadChannel_0 as ByteReadChannel1cb89sbyipkce,
+  ByteReadChannel as ByteReadChannel2wzou76jce72d,
+  ClosedByteChannelException as ClosedByteChannelException3il8gfpye60w,
+  attachWriterJob as attachWriterJob2dr3tee7atoa9,
+  cancel_0 as canceldn4b3cdqcfny,
+  close_0 as close3semq7pafb42g,
+  counted as counted3iniv3aql3f9n,
+  invokeOnCompletion as invokeOnCompletion1ziuxzoag0iwj,
+  ioDispatcher as ioDispatcher3b9pa3x0duop,
+  readText as readText3frapgncbqrcg,
+  rethrowCloseCauseIfNeeded as rethrowCloseCauseIfNeeded3ixo8wl4o3bz4,
+  writer as writer1eia5its2a1fh,
+};
+//endregion
+
+//# sourceMappingURL=ktor-ktor-io.mjs.map