@attocash/commons-js 5.0.0

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

@@ -0,0 +1,700 @@
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+  Result3t1vadv16kmzk as Result,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { toString30pk9tzaqopn as toString } from '../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  newThrowablezl37abp36p5f as newThrowable,
+  protoOf180f3jzyo7rfj as protoOf,
+  captureStack1fzi4aczwc4hg as captureStack,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { toString1h6jjoch8cjt8 as toString_0 } from '../../../../../kotlin-kotlin-stdlib/kotlin/text/numberConversions.mjs';
+import { stackTraceToString2670q6lbhdojj as stackTraceToString } from '../../../../../kotlin-kotlin-stdlib/kotlin/throwableExtensions.mjs';
+import { get_DEVELOPMENT_MODE18ax9b1n971lk as get_DEVELOPMENT_MODE } from './ByteChannel.jsAndWasmShared.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  ClosedReadChannelException9jdpzh6uy12w as ClosedReadChannelException,
+  ClosedWriteChannelException1eeenxj0c4bxu as ClosedWriteChannelException,
+} from './Exceptions.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { rethrowCloseCauseIfNeededeln8lm5agg4u as rethrowCloseCauseIfNeeded } from './ByteReadChannelOperations.mjs';
+import {
+  toLongw1zpgk99d84b as toLong,
+  numberToLong1a4cndvg6c52s as numberToLong,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CancellableContinuationImpl.mjs';
+import { returnIfSuspendedqak8u4r448cu as returnIfSuspended } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coroutineInternalJS.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import {
+  get_CLOSED3uiwvc5y98ftj as get_CLOSED,
+  CloseToken4utf44psnuyc as CloseToken,
+} from './CloseToken.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { atomic$ref$130aurmcwdfdf1 as atomic$ref$1 } from '../../../../../kotlinx-atomicfu/kotlinx/atomicfu/AtomicFU.mjs';
+import {
+  awaitContent$default62rpipafmnr4 as awaitContent$default,
+  ByteReadChannel2wzou76jce72d as ByteReadChannel,
+} from './ByteReadChannel.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance_0 = this;
+        this.p37_1 = new (Closed())(null);
+        var tmp = this;
+        // Inline function 'kotlin.Companion.success' call
+        tmp.q37_1 = _Result___init__impl__xyqfz8(Unit_instance);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  if (Companion_instance_0 === VOID)
+    new (Companion())();
+  return Companion_instance_0;
+}
+var EmptyClass;
+function Empty() {
+  if (EmptyClass === VOID) {
+    class $ {
+      toString() {
+        return 'Empty';
+      }
+      hashCode() {
+        return -231472095;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Empty()))
+          return false;
+        other instanceof Empty() || THROW_CCE();
+        return true;
+      }
+    }
+    initMetadataForObject($, 'Empty');
+    EmptyClass = $;
+  }
+  return EmptyClass;
+}
+var Empty_instance;
+function Empty_getInstance() {
+  return Empty_instance;
+}
+var ClosedClass;
+function Closed() {
+  if (ClosedClass === VOID) {
+    class $ {
+      constructor(cause) {
+        this.r37_1 = cause;
+      }
+      toString() {
+        return 'Closed(cause=' + toString(this.r37_1) + ')';
+      }
+      hashCode() {
+        return this.r37_1 == null ? 0 : hashCode(this.r37_1);
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Closed()))
+          return false;
+        var tmp0_other_with_cast = other instanceof Closed() ? other : THROW_CCE();
+        if (!equals(this.r37_1, tmp0_other_with_cast.r37_1))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'Closed');
+    ClosedClass = $;
+  }
+  return ClosedClass;
+}
+function resume() {
+  return this.t37().lc(Companion_getInstance().q37_1);
+}
+function resume_0(throwable) {
+  var tmp = this.t37();
+  var tmp_0;
+  if (throwable == null) {
+    tmp_0 = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(throwable));
+    tmp_0 = new (Result())(tmp$ret$2);
+  }
+  var tmp1_elvis_lhs = tmp_0;
+  return tmp.lc(tmp1_elvis_lhs == null ? Companion_getInstance().q37_1 : tmp1_elvis_lhs.wq_1);
+}
+var TaskClass;
+function Task() {
+  if (TaskClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'Task');
+    TaskClass = $;
+  }
+  return TaskClass;
+}
+var ReadClass;
+function Read() {
+  if (ReadClass === VOID) {
+    class $ {
+      constructor(continuation) {
+        this.x37_1 = continuation;
+        this.y37_1 = null;
+        if (get_DEVELOPMENT_MODE()) {
+          var tmp = this;
+          // Inline function 'kotlin.also' call
+          var this_0 = newThrowable('ReadTask 0x' + toString_0(hashCode(this.x37_1), 16));
+          stackTraceToString(this_0);
+          tmp.y37_1 = this_0;
+        }
+      }
+      t37() {
+        return this.x37_1;
+      }
+      s37() {
+        return this.y37_1;
+      }
+      u37() {
+        return 'read';
+      }
+    }
+    protoOf($).v37 = resume;
+    protoOf($).w37 = resume_0;
+    initMetadataForClass($, 'Read', VOID, VOID, [Task()]);
+    ReadClass = $;
+  }
+  return ReadClass;
+}
+var WriteClass;
+function Write() {
+  if (WriteClass === VOID) {
+    class $ {
+      constructor(continuation) {
+        this.z37_1 = continuation;
+        this.a38_1 = null;
+        if (get_DEVELOPMENT_MODE()) {
+          var tmp = this;
+          // Inline function 'kotlin.also' call
+          var this_0 = newThrowable('WriteTask 0x' + toString_0(hashCode(this.z37_1), 16));
+          stackTraceToString(this_0);
+          tmp.a38_1 = this_0;
+        }
+      }
+      t37() {
+        return this.z37_1;
+      }
+      s37() {
+        return this.a38_1;
+      }
+      u37() {
+        return 'write';
+      }
+    }
+    protoOf($).v37 = resume;
+    protoOf($).w37 = resume_0;
+    initMetadataForClass($, 'Write', VOID, VOID, [Task()]);
+    WriteClass = $;
+  }
+  return WriteClass;
+}
+function moveFlushToReadBuffer($this) {
+  // Inline function 'io.ktor.utils.io.locks.synchronized' call
+  $this.e38_1;
+  $this.c38_1.h2s($this.g38_1);
+  $this.d38_1 = 0;
+  // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+  var current = $this.f38_1.kotlinx$atomicfu$value;
+  var tmp;
+  if (current instanceof Write()) {
+    tmp = $this.f38_1.atomicfu$compareAndSet(current, Empty_instance);
+  } else {
+    tmp = false;
+  }
+  if (tmp) {
+    current.v37();
+  }
+}
+function closeSlot($this, cause) {
+  var closeContinuation = !(cause == null) ? new (Closed())(cause) : Companion_getInstance().p37_1;
+  var continuation = $this.f38_1.atomicfu$getAndSet(closeContinuation);
+  if (isInterface(continuation, Task())) {
+    continuation.w37(cause);
+  }
+}
+function ClosedReadChannelException$_init_$ref_ix0089() {
+  var l = function (p0) {
+    return ClosedReadChannelException().n38(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function ClosedWriteChannelException$_init_$ref_ef15ty() {
+  var l = function (p0) {
+    return ClosedWriteChannelException().s38(p0);
+  };
+  l.callableName = '<init>';
+  return l;
+}
+var $awaitContentCOROUTINE$Class;
+function $awaitContentCOROUTINE$() {
+  if ($awaitContentCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, min, resultContinuation) {
+        super(resultContinuation);
+        this.b39_1 = _this__u8e3s4;
+        this.c39_1 = min;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                rethrowCloseCauseIfNeeded(this.b39_1);
+                if (this.b39_1.g38_1.i1().a2(toLong(this.c39_1)) >= 0)
+                  return true;
+                var tmp_0 = this;
+                tmp_0.d39_1 = this.b39_1;
+                this.e39_1 = this.d39_1;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!(numberToLong(this.b39_1.d38_1).p3(this.b39_1.g38_1.i1()).a2(toLong(this.c39_1)) < 0 && this.b39_1.i38_1.kotlinx$atomicfu$value == null)) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.ac_1 = 2;
+                var cancellable = new (CancellableContinuationImpl())(intercepted(this), 1);
+                cancellable.a23();
+                var tmp0 = this.e39_1;
+                var tmp2 = new (Read())(cancellable);
+                l$ret$1: do {
+                  var previous = tmp0.f38_1.kotlinx$atomicfu$value;
+                  if (!(previous instanceof Closed())) {
+                    if (!tmp0.f38_1.atomicfu$compareAndSet(previous, tmp2)) {
+                      tmp2.v37();
+                      break l$ret$1;
+                    }
+                  }
+                  if (previous instanceof Read()) {
+                    previous.w37(ConcurrentIOException().j39(tmp2.u37(), previous.s37()));
+                  } else {
+                    if (isInterface(previous, Task())) {
+                      previous.v37();
+                    } else {
+                      if (previous instanceof Closed()) {
+                        tmp2.w37(previous.r37_1);
+                        break l$ret$1;
+                      } else {
+                        if (!equals(previous, Empty_instance)) {
+                          noWhenBranchMatchedException();
+                        }
+                      }
+                    }
+                  }
+                  if (!(numberToLong(this.b39_1.d38_1).p3(this.b39_1.g38_1.i1()).a2(toLong(this.c39_1)) < 0 && this.b39_1.i38_1.kotlinx$atomicfu$value == null)) {
+                    var current = tmp0.f38_1.kotlinx$atomicfu$value;
+                    var tmp_1;
+                    if (current instanceof Read()) {
+                      tmp_1 = tmp0.f38_1.atomicfu$compareAndSet(current, Empty_instance);
+                    } else {
+                      tmp_1 = false;
+                    }
+                    if (tmp_1) {
+                      current.v37();
+                    }
+                  }
+                }
+                 while (false);
+                suspendResult = returnIfSuspended(cancellable.b20(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                if (this.b39_1.g38_1.i1().a2(new (Long())(1048576, 0)) < 0) {
+                  moveFlushToReadBuffer(this.b39_1);
+                }
+
+                return this.b39_1.g38_1.i1().a2(toLong(this.c39_1)) >= 0;
+              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($);
+    $awaitContentCOROUTINE$Class = $;
+  }
+  return $awaitContentCOROUTINE$Class;
+}
+var $flushCOROUTINE$Class;
+function $flushCOROUTINE$() {
+  if ($flushCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.s39_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;
+                rethrowCloseCauseIfNeeded(this.s39_1);
+                this.s39_1.v39();
+                if (this.s39_1.d38_1 < 1048576)
+                  return Unit_instance;
+                var tmp_0 = this;
+                tmp_0.t39_1 = this.s39_1;
+                this.u39_1 = this.t39_1;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!(this.s39_1.d38_1 >= 1048576 && this.s39_1.i38_1.kotlinx$atomicfu$value == null)) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.ac_1 = 2;
+                var cancellable = new (CancellableContinuationImpl())(intercepted(this), 1);
+                cancellable.a23();
+                var tmp0 = this.u39_1;
+                var tmp2 = new (Write())(cancellable);
+                l$ret$1: do {
+                  var previous = tmp0.f38_1.kotlinx$atomicfu$value;
+                  if (!(previous instanceof Closed())) {
+                    if (!tmp0.f38_1.atomicfu$compareAndSet(previous, tmp2)) {
+                      tmp2.v37();
+                      break l$ret$1;
+                    }
+                  }
+                  if (previous instanceof Write()) {
+                    previous.w37(ConcurrentIOException().j39(tmp2.u37(), previous.s37()));
+                  } else {
+                    if (isInterface(previous, Task())) {
+                      previous.v37();
+                    } else {
+                      if (previous instanceof Closed()) {
+                        tmp2.w37(previous.r37_1);
+                        break l$ret$1;
+                      } else {
+                        if (!equals(previous, Empty_instance)) {
+                          noWhenBranchMatchedException();
+                        }
+                      }
+                    }
+                  }
+                  if (!(this.s39_1.d38_1 >= 1048576 && this.s39_1.i38_1.kotlinx$atomicfu$value == null)) {
+                    var current = tmp0.f38_1.kotlinx$atomicfu$value;
+                    var tmp_1;
+                    if (current instanceof Write()) {
+                      tmp_1 = tmp0.f38_1.atomicfu$compareAndSet(current, Empty_instance);
+                    } else {
+                      tmp_1 = false;
+                    }
+                    if (tmp_1) {
+                      current.v37();
+                    }
+                  }
+                }
+                 while (false);
+                suspendResult = returnIfSuspended(cancellable.b20(), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                return Unit_instance;
+              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($);
+    $flushCOROUTINE$Class = $;
+  }
+  return $flushCOROUTINE$Class;
+}
+var $flushAndCloseCOROUTINE$Class;
+function $flushAndCloseCOROUTINE$() {
+  if ($flushAndCloseCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.e3a_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;
+                var tmp_0 = this;
+                tmp_0.f3a_1 = this.e3a_1;
+                this.g3a_1 = this.f3a_1;
+                this.bc_1 = 2;
+                var tmp_1 = this;
+                tmp_1.i3a_1 = Companion_instance;
+                var tmp_2 = this;
+                tmp_2.j3a_1 = this.g3a_1;
+                this.k3a_1 = this.j3a_1;
+                this.ac_1 = 1;
+                suspendResult = this.k3a_1.l3a(this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var tmp_3 = this;
+                this.i3a_1;
+                tmp_3.h3a_1 = _Result___init__impl__xyqfz8(Unit_instance);
+                this.bc_1 = 4;
+                this.ac_1 = 3;
+                continue $sm;
+              case 2:
+                this.bc_1 = 4;
+                var tmp_4 = this.dc_1;
+                if (tmp_4 instanceof Error) {
+                  var e = this.dc_1;
+                  var tmp_5 = this;
+                  tmp_5.h3a_1 = _Result___init__impl__xyqfz8(createFailure(e));
+                  this.ac_1 = 3;
+                  continue $sm;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 3:
+                this.bc_1 = 4;
+                if (!this.e3a_1.i38_1.atomicfu$compareAndSet(null, get_CLOSED()))
+                  return Unit_instance;
+                closeSlot(this.e3a_1, null);
+                return Unit_instance;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e_0 = $p;
+            if (this.bc_1 === 4) {
+              throw e_0;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e_0;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $flushAndCloseCOROUTINE$Class = $;
+  }
+  return $flushAndCloseCOROUTINE$Class;
+}
+var ByteChannelClass;
+function ByteChannel() {
+  if (ByteChannelClass === VOID) {
+    class $ {
+      constructor(autoFlush) {
+        autoFlush = autoFlush === VOID ? false : autoFlush;
+        this.b38_1 = autoFlush;
+        this.c38_1 = new (Buffer())();
+        this.d38_1 = 0;
+        this.e38_1 = new Object();
+        this.f38_1 = atomic$ref$1(Empty_instance);
+        this.g38_1 = new (Buffer())();
+        this.h38_1 = new (Buffer())();
+        this.i38_1 = atomic$ref$1(null);
+      }
+      m3a() {
+        var tmp0_safe_receiver = this.i38_1.kotlinx$atomicfu$value;
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          tmp0_safe_receiver.o3a(ClosedReadChannelException$_init_$ref_ix0089());
+        }
+        if (this.g38_1.a2r()) {
+          moveFlushToReadBuffer(this);
+        }
+        return this.g38_1;
+      }
+      p3a() {
+        if (this.q3a()) {
+          var tmp0_safe_receiver = this.i38_1.kotlinx$atomicfu$value;
+          var tmp;
+          if (tmp0_safe_receiver == null) {
+            tmp = null;
+          } else {
+            tmp = tmp0_safe_receiver.o3a(ClosedWriteChannelException$_init_$ref_ef15ty());
+          }
+          if (tmp == null)
+            throw ClosedWriteChannelException().s38();
+        }
+        return this.h38_1;
+      }
+      r3a() {
+        var tmp0_safe_receiver = this.i38_1.kotlinx$atomicfu$value;
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.s3a();
+      }
+      q3a() {
+        return !(this.i38_1.kotlinx$atomicfu$value == null);
+      }
+      t3a() {
+        return !(this.r3a() == null) || (this.q3a() && this.d38_1 === 0 && this.g38_1.a2r());
+      }
+      u3a(min, $completion) {
+        var tmp = new ($awaitContentCOROUTINE$())(this, min, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      l3a($completion) {
+        var tmp = new ($flushCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      v39() {
+        if (this.h38_1.a2r())
+          return Unit_instance;
+        // Inline function 'io.ktor.utils.io.locks.synchronized' call
+        this.e38_1;
+        var count = this.h38_1.i1().c2();
+        this.c38_1.w2s(this.h38_1);
+        this.d38_1 = this.d38_1 + count | 0;
+        // Inline function 'io.ktor.utils.io.ByteChannel.resumeSlot' call
+        var current = this.f38_1.kotlinx$atomicfu$value;
+        var tmp;
+        if (current instanceof Read()) {
+          tmp = this.f38_1.atomicfu$compareAndSet(current, Empty_instance);
+        } else {
+          tmp = false;
+        }
+        if (tmp) {
+          current.v37();
+        }
+      }
+      v5() {
+        this.v39();
+        if (!this.i38_1.atomicfu$compareAndSet(null, get_CLOSED()))
+          return Unit_instance;
+        closeSlot(this, null);
+      }
+      w3a($completion) {
+        var tmp = new ($flushAndCloseCOROUTINE$())(this, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      x3a(cause) {
+        if (!(this.i38_1.kotlinx$atomicfu$value == null))
+          return Unit_instance;
+        var closedToken = new (CloseToken())(cause);
+        this.i38_1.atomicfu$compareAndSet(null, closedToken);
+        var wrappedCause = closedToken.s3a();
+        closeSlot(this, wrappedCause);
+      }
+      toString() {
+        return 'ByteChannel[' + hashCode(this) + ']';
+      }
+    }
+    protoOf($).v3a = awaitContent$default;
+    initMetadataForClass($, 'ByteChannel', ByteChannel, VOID, [ByteReadChannel()], [1, 0]);
+    ByteChannelClass = $;
+  }
+  return ByteChannelClass;
+}
+var ConcurrentIOExceptionClass;
+function ConcurrentIOException() {
+  if (ConcurrentIOExceptionClass === VOID) {
+    class $ extends IllegalStateException() {
+      static j39(taskName, cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.ed('Concurrent ' + taskName + ' attempts', cause);
+        captureStack($this, $this.i39_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ConcurrentIOException');
+    ConcurrentIOExceptionClass = $;
+  }
+  return ConcurrentIOExceptionClass;
+}
+//region block: init
+Empty_instance = new (Empty())();
+//endregion
+//region block: exports
+export {
+  ByteChannel as ByteChannel3cxdguezl3lu7,
+};
+//endregion
+
+//# sourceMappingURL=ByteChannel.mjs.map