@continuous-excellence/coupling-cli 0.0.0

package/kotlin/ktor-ktor-io/io/ktor/utils/io/ByteWriteChannelOperations.mjs

@@ -0,0 +1,283 @@
+import { flushIfNeededyux8o68tvpw5 as flushIfNeeded } from './ByteWriteChannel.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForFunctionReferencen3g5fpj34t8u as initMetadataForFunctionReference,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { EmptyCoroutineContext_getInstance10e98b8bnsvr1 as EmptyCoroutineContext_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import { ByteChannel3cxdguezl3lu7 as ByteChannel } from './ByteChannel.mjs';
+import { CoroutineScopefcb5f5dwqcas as CoroutineScope } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { get_remaining1lapv95kcmm0y as get_remaining } from './core/ByteReadPacket.mjs';
+import { launch1c91vkjzdi9sd as launch } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs';
+import { startCoroutineCancellable18shtfwdieib as startCoroutineCancellable } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/intrinsics/Cancellable.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/Continuation.mjs';
+import {
+  get_job2zvlvce9o9a29 as get_job,
+  Job13y4jkazwjho0 as Job,
+  cancel1xim2hrvjmwpn as cancel,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Job.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_NO_CALLBACK() {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return NO_CALLBACK;
+}
+var NO_CALLBACK;
+function *_generator_writeFully__hb5mir(_this__u8e3s4, value, startIndex, endIndex, $completion) {
+  _this__u8e3s4.b1t().p1p(value, startIndex, endIndex);
+  var tmp = flushIfNeeded(_this__u8e3s4, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function writeFully(_this__u8e3s4, value, startIndex, endIndex, $completion) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? value.length : endIndex;
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_writeFully__hb5mir.bind(VOID, _this__u8e3s4, value, startIndex, endIndex), $completion);
+}
+var WriterJobClass;
+function WriterJob() {
+  if (WriterJobClass === VOID) {
+    class $ {
+      constructor(channel, job) {
+        this.h1u_1 = channel;
+        this.i1u_1 = job;
+      }
+      lz() {
+        return this.i1u_1;
+      }
+    }
+    initMetadataForClass($, 'WriterJob');
+    WriterJobClass = $;
+  }
+  return WriterJobClass;
+}
+function writer(_this__u8e3s4, coroutineContext, autoFlush, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_getInstance() : coroutineContext;
+  autoFlush = autoFlush === VOID ? false : autoFlush;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return writer_0(_this__u8e3s4, coroutineContext, new (ByteChannel())(), block);
+}
+var WriterScopeClass;
+function WriterScope() {
+  if (WriterScopeClass === VOID) {
+    class $ {
+      constructor(channel, coroutineContext) {
+        this.j1u_1 = channel;
+        this.k1u_1 = coroutineContext;
+      }
+      iw() {
+        return this.k1u_1;
+      }
+    }
+    initMetadataForClass($, 'WriterScope', VOID, VOID, [CoroutineScope()]);
+    WriterScopeClass = $;
+  }
+  return WriterScopeClass;
+}
+function invokeOnCompletion(_this__u8e3s4, block) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return _this__u8e3s4.lz().lx(block);
+}
+function close(_this__u8e3s4, cause) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  if (cause == null) {
+    fireAndForget(ByteWriteChannel$flushAndClose$ref_0(_this__u8e3s4));
+  } else {
+    _this__u8e3s4.j1t(cause);
+  }
+}
+function *_generator_writePacket__qqx68d(_this__u8e3s4, source, $completion) {
+  while (!source.g1o()) {
+    _this__u8e3s4.b1t().t1p(source, get_remaining(source));
+    var tmp = flushIfNeeded(_this__u8e3s4, $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+  }
+  return Unit_instance;
+}
+function writePacket(_this__u8e3s4, source, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_writePacket__qqx68d.bind(VOID, _this__u8e3s4, source), $completion);
+}
+function writer_0(_this__u8e3s4, coroutineContext, channel, block) {
+  coroutineContext = coroutineContext === VOID ? EmptyCoroutineContext_getInstance() : coroutineContext;
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  // Inline function 'kotlin.apply' call
+  var this_0 = launch(_this__u8e3s4, coroutineContext, VOID, writer$slambda_0(block, channel));
+  this_0.lx(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 *_generator_writeByte__k05tl9(_this__u8e3s4, value, $completion) {
+  _this__u8e3s4.b1t().z1p(value);
+  var tmp = flushIfNeeded(_this__u8e3s4, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function writeByte(_this__u8e3s4, value, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_writeByte__k05tl9.bind(VOID, _this__u8e3s4, value), $completion);
+}
+var NO_CALLBACK$1Class;
+function NO_CALLBACK$1() {
+  if (NO_CALLBACK$1Class === VOID) {
+    class $ {
+      constructor() {
+        this.l1u_1 = EmptyCoroutineContext_getInstance();
+      }
+      bd() {
+        return this.l1u_1;
+      }
+      cd(result) {
+        return Unit_instance;
+      }
+      dd(result) {
+        return this.cd(result);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, [Continuation()]);
+    NO_CALLBACK$1Class = $;
+  }
+  return NO_CALLBACK$1Class;
+}
+var ByteWriteChannel$flushAndClose$refClass;
+function ByteWriteChannel$flushAndClose$ref() {
+  if (ByteWriteChannel$flushAndClose$refClass === VOID) {
+    class $ {
+      constructor(p0) {
+        this.m1u_1 = p0;
+      }
+      fe($completion) {
+        return this.m1u_1.i1t($completion);
+      }
+    }
+    initMetadataForFunctionReference($, VOID, VOID, [0]);
+    ByteWriteChannel$flushAndClose$refClass = $;
+  }
+  return ByteWriteChannel$flushAndClose$refClass;
+}
+function ByteWriteChannel$flushAndClose$ref_0(p0) {
+  var i = new (ByteWriteChannel$flushAndClose$ref())(p0);
+  var l = ($completion) => i.fe($completion);
+  l.callableName = 'flushAndClose';
+  l.$arity = 0;
+  return l;
+}
+function *_generator_invoke__zhh2q8($this, $this$launch, $completion) {
+  var nested = Job(get_job($this$launch.iw()));
+  try {
+    var tmp = $this.n1u_1(new (WriterScope())($this.o1u_1, $this$launch.iw().wo(nested)), $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+    nested.r13();
+    if (get_job($this$launch.iw()).fx()) {
+      $this.o1u_1.j1t(get_job($this$launch.iw()).ix());
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var cause = $p;
+      cancel(nested, 'Exception thrown while writing to channel', cause);
+      $this.o1u_1.j1t(cause);
+    } else {
+      throw $p;
+    }
+  }
+  finally {
+    var tmp_0 = nested.px($completion);
+    if (tmp_0 === get_COROUTINE_SUSPENDED())
+      tmp_0 = yield tmp_0;
+    // Inline function 'kotlin.runCatching' call
+    var tmp_1;
+    try {
+      var tmp_2 = $this.o1u_1.i1t($completion);
+      if (tmp_2 === get_COROUTINE_SUSPENDED())
+        tmp_2 = yield tmp_2;
+      // Inline function 'kotlin.Companion.success' call
+      tmp_1 = _Result___init__impl__xyqfz8(Unit_instance);
+    } catch ($p) {
+      var tmp_3;
+      if ($p instanceof Error) {
+        var e = $p;
+        // Inline function 'kotlin.Companion.failure' call
+        tmp_3 = _Result___init__impl__xyqfz8(createFailure(e));
+      } else {
+        throw $p;
+      }
+      tmp_1 = tmp_3;
+    }
+  }
+  return Unit_instance;
+}
+var writer$slambdaClass;
+function writer$slambda() {
+  if (writer$slambdaClass === VOID) {
+    class $ {
+      constructor($block, $channel) {
+        this.n1u_1 = $block;
+        this.o1u_1 = $channel;
+      }
+      z1g($this$launch, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, $this$launch), $completion);
+      }
+      de(p1, $completion) {
+        return this.z1g((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    writer$slambdaClass = $;
+  }
+  return writer$slambdaClass;
+}
+function writer$slambda_0($block, $channel) {
+  var i = new (writer$slambda())($block, $channel);
+  var l = ($this$launch, $completion) => i.z1g($this$launch, $completion);
+  l.$arity = 1;
+  return l;
+}
+function writer$lambda($channel) {
+  return (it) => {
+    var tmp;
+    if (!(it == null) && !$channel.c1t()) {
+      $channel.j1t(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())();
+  }
+}
+//region block: exports
+export {
+  writeByte as writeByte1kdn4bvj0qg04,
+  writeFully as writeFully3jo5sennkizsh,
+  writePacket as writePacket2q073y706j8ob,
+  WriterScope as WriterScope3b0bo1enaee6b,
+  close as close3semq7pafb42g,
+  invokeOnCompletion as invokeOnCompletion1ziuxzoag0iwj,
+  writer as writer1eia5its2a1fh,
+};
+//endregion
+
+//# sourceMappingURL=ByteWriteChannelOperations.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/ByteWriteChannelOperations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/ByteWriteChannelOperations.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-io/io/ktor/utils/io/src/kotlin/util/Standard.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-io/io/ktor/utils/io/src/kotlin/util/Result.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-NO_CALLBACK>","<generator-writeFully>","<this>","value","startIndex","endIndex","$completion","writeFully","channel","job","<get-job>","writer","coroutineContext","autoFlush","block","<get-coroutineContext>","invokeOnCompletion","close","cause","<generator-writePacket>","source","writePacket","fireAndForget","<generator-writeByte>","writeByte","<get-context>","resumeWith","result","p0","invoke","ByteWriteChannel$flushAndClose$ref","ByteWriteChannel$flushAndClose$ref$lambda","<generator-invoke>","nested","e","$block","$channel","writer$slambda","writer$slambda$lambda","writer$lambda","writer$lambda$lambda","<init properties ByteWriteChannelOperations.kt>"],"mappings":"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"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/CloseToken.mjs

@@ -0,0 +1,87 @@
+import { ClosedByteChannelException3il8gfpye60w as ClosedByteChannelException } from './Exceptions.mjs';
+import { CancellationException3b36o9qz53rgr as CancellationException } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs';
+import { CopyableThrowable1mvc99jcyvivf as CopyableThrowable } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Debug.common.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_CLOSED() {
+  _init_properties_CloseToken_kt__9ucr41();
+  return CLOSED;
+}
+var CLOSED;
+function ClosedByteChannelException$_init_$ref_yjp351() {
+  var l = (p0) => ClosedByteChannelException().s1u(p0);
+  l.callableName = '<init>';
+  return l;
+}
+var CloseTokenClass;
+function CloseToken() {
+  if (CloseTokenClass === VOID) {
+    class $ {
+      constructor(origin) {
+        this.z1s_1 = origin;
+      }
+      t1u(wrap) {
+        var tmp0_subject = this.z1s_1;
+        var tmp;
+        if (tmp0_subject == null) {
+          tmp = null;
+        } else {
+          if (isInterface(tmp0_subject, CopyableThrowable())) {
+            tmp = this.z1s_1.e14();
+          } else {
+            if (tmp0_subject instanceof CancellationException()) {
+              tmp = CancellationException().p(this.z1s_1.message, this.z1s_1);
+            } else {
+              tmp = wrap(this.z1s_1);
+            }
+          }
+        }
+        return tmp;
+      }
+      e1t(wrap, $super) {
+        var tmp;
+        if (wrap === VOID) {
+          tmp = ClosedByteChannelException$_init_$ref_yjp351();
+        } else {
+          tmp = wrap;
+        }
+        wrap = tmp;
+        return $super === VOID ? this.t1u(wrap) : $super.t1u.call(this, wrap);
+      }
+      a1t(wrap) {
+        var tmp0_safe_receiver = this.t1u(wrap);
+        var tmp;
+        if (tmp0_safe_receiver == null) {
+          tmp = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          throw tmp0_safe_receiver;
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'CloseToken');
+    CloseTokenClass = $;
+  }
+  return CloseTokenClass;
+}
+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);
+  }
+}
+//region block: exports
+export {
+  get_CLOSED as get_CLOSED3uiwvc5y98ftj,
+  CloseToken as CloseToken4utf44psnuyc,
+};
+//endregion
+
+//# sourceMappingURL=CloseToken.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/CloseToken.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/CloseToken.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-io/io/ktor/utils/io/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-CLOSED>","ClosedByteChannelException$<init>$ref","ClosedByteChannelException$<init>$ref$lambda","origin","wrapCause","wrap","wrapCause$default","throwOrNull","<init properties CloseToken.kt>"],"mappings":";;;;;;;;;;mBAUSA,CAAAA,EAAA;A;EAAA,a;AAAS,C;;qDAKiCC,CAAAA,E;UAAAC,C,EAAAA,yC;;;C;;;;;kBAFjBC,M;QAAR,mB;;SAEtBC,CAAcC,IAAdD,EAAyF;A,YACxE,yB;;QACT,yB;gBAAQ,I;;UACR,mD;kBAA2B,IAAO,CAAP,KAAO,M;;YAClC,oD;8CAAkD,I,CAAA,K,CAAO,O,EAAS,I,CAAA,K;;oBAC1D,KAAK,IAAL,CAAK,KAAL,C;;;;QAJZ,U;MAMJ,C;SAPAE,CAAcD,I,QAAdC,E;;;gBAA+C,8C;;;;;;O;SAS/CC,CAAgBF,IAAhBE,EACI;A,YAAA,8BAAU,IAAV,C;;QAAiB,+B;gBAAA,I;;;UCGnB,MDHE,kB;;QAAiC,U;MAAD,C;;;;;;;;+CAzBxCC,CAAAA,E;;;gCAUiC,I;;C;;;;;"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/CountedByteReadChannel.mjs

@@ -0,0 +1,91 @@
+import {
+  fromInt1lka3ktyu79a4 as fromInt,
+  compare2uud5j30pw5xc as compare,
+  add85si75olwt6n as add,
+  subtract16cg4lfi29fq9 as subtract,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  awaitContent$default12h4qgz8umrzx as awaitContent$default,
+  ByteReadChannel2wzou76jce72d as ByteReadChannel,
+} from './ByteReadChannel.mjs';
+import { protoOf180f3jzyo7rfj as protoOf } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function *_generator_awaitContent__vf28kb($this, min, $completion) {
+  if (compare($this.y1s().v2(), fromInt(min)) >= 0) {
+    return true;
+  }
+  var tmp = $this.u1u_1.g1t(min, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  if (tmp) {
+    transferFromDelegate($this);
+    return true;
+  }
+  return false;
+}
+function transferFromDelegate($this) {
+  updateConsumed($this);
+  var appended = $this.v1u_1.y1p($this.u1u_1.y1s());
+  $this.w1u_1 = add($this.w1u_1, appended);
+}
+function updateConsumed($this) {
+  $this.x1u_1 = add($this.x1u_1, subtract($this.w1u_1, $this.v1u_1.v2()));
+  $this.w1u_1 = $this.v1u_1.v2();
+}
+var CountedByteReadChannelClass;
+function CountedByteReadChannel() {
+  if (CountedByteReadChannelClass === VOID) {
+    class $ {
+      constructor(delegate) {
+        this.u1u_1 = delegate;
+        this.v1u_1 = new (Buffer())();
+        this.w1u_1 = new (Long())(0, 0);
+        this.x1u_1 = new (Long())(0, 0);
+      }
+      y1u() {
+        updateConsumed(this);
+        return this.x1u_1;
+      }
+      d1t() {
+        return this.u1u_1.d1t();
+      }
+      f1t() {
+        return this.v1u_1.g1o() && this.u1u_1.f1t();
+      }
+      y1s() {
+        transferFromDelegate(this);
+        return this.v1u_1;
+      }
+      g1t(min, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_awaitContent__vf28kb.bind(VOID, this, min), $completion);
+      }
+      j1t(cause) {
+        this.u1u_1.j1t(cause);
+        this.v1u_1.o6();
+      }
+    }
+    protoOf($).h1t = awaitContent$default;
+    initMetadataForClass($, 'CountedByteReadChannel', VOID, VOID, [ByteReadChannel()], [1]);
+    CountedByteReadChannelClass = $;
+  }
+  return CountedByteReadChannelClass;
+}
+function counted(_this__u8e3s4) {
+  return new (CountedByteReadChannel())(_this__u8e3s4);
+}
+//region block: exports
+export {
+  counted as counted3iniv3aql3f9n,
+};
+//endregion
+
+//# sourceMappingURL=CountedByteReadChannel.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/CountedByteReadChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/CountedByteReadChannel.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<generator-awaitContent>","min","$completion","transferFromDelegate","appended","updateConsumed","delegate","<get-totalBytesRead>","<get-closedCause>","<get-isClosedForRead>","<get-readBuffer>","awaitContent","cancel","cause","counted","<this>"],"mappings":";;;;;;;;;;;;;;;;;;;;;yCA2CqBA,CAAA,K,EAAiBC,G,EAAjBC,WAAAF,EAAoC;A,EAC7C,YAAA,WAAW,KAAX,EAAmB,YAAnB,O,CAAwB;A,IACxB,OAAO,I;EACX,C;MACa,MAAT,KAAS,CAAT,KAAS,KAAa,GAAb,c;;;EAAT,Q,CAA4B;A,IAC5B,2B;IACA,OAAO,I;EACX,C;EACA,OAAO,K;AACX,C;6BAGQG,CAAA,KAAAA,EAA2B;A,EAC/B,qB;MACAC,WAAe,KAAO,CAAP,KAAO,KAAa,KAAS,CAAT,KAAS,MAAtB,C;EACtB,+BAAW,QAAX,C;AACJ,C;uBAOQC,CAAA,KAAAA,EAAqB;A,EACzB,+BAAY,sBAAU,KAAO,CAAP,KAAO,KAAjB,CAAZ,C;EACA,cAAU,KAAO,CAAP,KAAO,K;AACrB,C;;;;;kBAnDuCC,Q;QAAP,qB;QACX,6B;QACC,+B;QACC,+B;;SAGnBC,CAAAA,EAAM;A,QACF,oB;QACA,OAAO,IAAP,CAAO,K;MACX,C;SAGAC,CAAAA,EAAQ;A,QAAoB,OAApB,IAAS,CAAT,KAAS,M;MAAU,C;SAG3BC,CAAAA,EAAQ;A,QAA8C,OAA9C,IAAO,CAAP,KAAO,MAAuC,IAAxB,IAAS,CAAT,KAAS,M;MAAc,C;SAIrDC,CAAAA,EAAM;A,QACF,0B;QACA,OAAO,IAAP,CAAO,K;MACX,C;SAGaC,CAAiBV,G,EAAjBC,WAAAS,E;;O;SAkBRC,CAAWC,KAAXD,EAA8B;A,QACnC,IAAS,CAAT,KAAS,KAAO,KAAP,C;QACT,IAAO,CAAP,KAAO,K;MACX,C;;;;;;;;gBAhDGE,CAAIC,aAAJD,EAAwD;A,EAA4B,sCAAL,aAAK,C;AAAD,C;;;;;"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/Deprecation.mjs

@@ -0,0 +1,15 @@
+import { readString2nvggcfaijfhd as readString } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Utf8.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function readText(_this__u8e3s4) {
+  return readString(_this__u8e3s4);
+}
+//region block: exports
+export {
+  readText as readText3frapgncbqrcg,
+};
+//endregion
+
+//# sourceMappingURL=Deprecation.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/Deprecation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/Deprecation.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["readText","<this>"],"mappings":";;;;;iBAeOA,CAAIC,aAAJD,EAA8B;A,EACjC,OAAO,yB;AACX,C;;;;;"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/Exceptions.mjs

@@ -0,0 +1,65 @@
+import { IOException1wyutdmfe71nu as IOException } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/-PlatformJs.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { captureStack1fzi4aczwc4hg as captureStack } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var ClosedByteChannelExceptionClass;
+function ClosedByteChannelException() {
+  if (ClosedByteChannelExceptionClass === VOID) {
+    class $ extends IOException() {
+      static s1u(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.k1r(cause == null ? null : cause.message, cause);
+        captureStack($this, $this.r1u_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedByteChannelException', $.s1u);
+    ClosedByteChannelExceptionClass = $;
+  }
+  return ClosedByteChannelExceptionClass;
+}
+var ClosedReadChannelExceptionClass;
+function ClosedReadChannelException() {
+  if (ClosedReadChannelExceptionClass === VOID) {
+    class $ extends ClosedByteChannelException() {
+      static r1s(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.s1u(cause);
+        captureStack($this, $this.q1s_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedReadChannelException', $.r1s);
+    ClosedReadChannelExceptionClass = $;
+  }
+  return ClosedReadChannelExceptionClass;
+}
+var ClosedWriteChannelExceptionClass;
+function ClosedWriteChannelException() {
+  if (ClosedWriteChannelExceptionClass === VOID) {
+    class $ extends ClosedByteChannelException() {
+      static w1s(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.s1u(cause);
+        captureStack($this, $this.v1s_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedWriteChannelException', $.w1s);
+    ClosedWriteChannelExceptionClass = $;
+  }
+  return ClosedWriteChannelExceptionClass;
+}
+//region block: exports
+export {
+  ClosedByteChannelException as ClosedByteChannelException3il8gfpye60w,
+  ClosedReadChannelException as ClosedReadChannelException9jdpzh6uy12w,
+  ClosedWriteChannelException as ClosedWriteChannelException1eeenxj0c4bxu,
+};
+//endregion
+
+//# sourceMappingURL=Exceptions.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/Exceptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/Exceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["cause"],"mappings":";;;;;;;;;;;;iBAe6CA,K;iCAAoB,I;6BAAoB,KAAO,kBAAP,KAAO,Q,EAAS,K;;;;;;;;;;;;;;iBAc7DA,K;iCAAoB,I;6BAAmC,K;;;;;;;;;;;;;;iBAPtDA,K;iCAAoB,I;6BAAmC,K;;;;;;;;;;;;;;"}

package/kotlin/ktor-ktor-io/io/ktor/utils/io/IODispatcher.jsAndWasmShared.mjs

@@ -0,0 +1,15 @@
+import { Dispatchers_getInstancewbokwrm9sosb as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function ioDispatcher() {
+  return Dispatchers_getInstance().e18_1;
+}
+//region block: exports
+export {
+  ioDispatcher as ioDispatcher3b9pa3x0duop,
+};
+//endregion
+
+//# sourceMappingURL=IODispatcher.jsAndWasmShared.mjs.map

package/kotlin/ktor-ktor-io/io/ktor/utils/io/IODispatcher.jsAndWasmShared.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/jsAndWasmShared/src/io/ktor/utils/io/IODispatcher.jsAndWasmShared.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["ioDispatcher"],"mappings":";;;;;qBAScA,CAAAA,EAA0C;A,EAAmB,iCAAP,K;AAAM,C;;;;;"}