@attocash/commons-test 6.0.0

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/ByteReadChannelOperations.kt","js/src/generated/_ComparisonsJs.kt","js/src/kotlin/AutoCloseableJs.kt","src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<generator-readUTF8Line>","<this>","max","$completion","result","completed","readUTF8Line","<generator-readAvailable>","buffer","offset","length","readAvailable","<generator-readRemaining>","readRemaining","<generator-toByteArray>","toByteArray","<generator-copyTo>","channel","limit","remaining","count","cause","copyTo","<generator-discard>","discard","<generator-skipIfFound>","byteString","skipIfFound","<generator-readPacket>","packet","readPacket","readUntil","matchString","writeChannel","ignoreMissing","<generator-readUTF8LineTo>","out","lineEnding","exception","b","e","readUTF8LineTo","rethrowCloseCauseIfNeeded","<generator-readBuffer>","readBuffer","<get-availableForRead>","<generator-peek>","peek","readUTF8LineTo$checkLineEndingAllowed","$lineEnding","lineEndingToCheck"],"mappings":"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"}

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

@@ -0,0 +1,43 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { rethrowCloseCauseIfNeeded2q8fs9csuucwc as rethrowCloseCauseIfNeeded } from './ByteReadChannelOperations.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { get_size2imoy2jq11jxl as get_size } from './core/BytePacketBuilder.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_autoFlush() {
+  return false;
+}
+var ByteWriteChannelClass;
+function ByteWriteChannel() {
+  if (ByteWriteChannelClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'ByteWriteChannel', VOID, VOID, VOID, [0]);
+    ByteWriteChannelClass = $;
+  }
+  return ByteWriteChannelClass;
+}
+function *_generator_flushIfNeeded__xji6le(_this__u8e3s4, $completion) {
+  rethrowCloseCauseIfNeeded(_this__u8e3s4);
+  if (_this__u8e3s4.n1p() || get_size(_this__u8e3s4.r1p()) >= 1048576) {
+    var tmp = _this__u8e3s4.c1p($completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+  }
+  return Unit_instance;
+}
+function flushIfNeeded(_this__u8e3s4, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_flushIfNeeded__xji6le.bind(VOID, _this__u8e3s4), $completion);
+}
+//region block: exports
+export {
+  flushIfNeeded as flushIfNeeded2ae8rmpc1excy,
+  ByteWriteChannel as ByteWriteChannel3jkhlhzuuoxp1,
+};
+//endregion
+
+//# sourceMappingURL=ByteWriteChannel.mjs.map

package/ktor-ktor-io/io/ktor/utils/io/ByteWriteChannel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-io/common/src/io/ktor/utils/io/ByteWriteChannel.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-autoFlush>","<generator-flushIfNeeded>","<this>","$completion","flushIfNeeded"],"mappings":";;;;;;;;;;;sBAsBQA,CAAAA,EAAQ;A,EAAK,OAAL,K;AAAI,C;;;;;;;;;;0CAuCLC,CAAIC,a,EAAJC,WAAAF,EAAqC;A,EAChD,wC;EAEI,2BAAyB,SAAZ,mBAAY,CAAZ,IAAoB,OAAjC,C;QAAmD,oC;;;;EAC3D,oB;AAAA,C;sBAJeG,CAAIF,a,EAAJC,WAAAC,E;;C;;;;;"}

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

@@ -0,0 +1,271 @@
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { flushIfNeeded2ae8rmpc1excy as flushIfNeeded } from './ByteWriteChannel.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.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_instance2qpebg1xogbvt as EmptyCoroutineContext_instance } 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 { 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_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 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) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  endIndex = endIndex === VOID ? value.length : endIndex;
+  _this__u8e3s4.r1p().b1m(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.x1q_1 = channel;
+        this.y1q_1 = job;
+      }
+      yy() {
+        return this.y1q_1;
+      }
+    }
+    initMetadataForClass($, 'WriterJob');
+    WriterJobClass = $;
+  }
+  return WriterJobClass;
+}
+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);
+}
+var WriterScopeClass;
+function WriterScope() {
+  if (WriterScopeClass === VOID) {
+    class $ {
+      constructor(channel, coroutineContext) {
+        this.z1q_1 = channel;
+        this.a1r_1 = coroutineContext;
+      }
+      bt() {
+        return this.a1r_1;
+      }
+    }
+    initMetadataForClass($, 'WriterScope', VOID, VOID, [CoroutineScope()]);
+    WriterScopeClass = $;
+  }
+  return WriterScopeClass;
+}
+function invokeOnCompletion(_this__u8e3s4, block) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  return _this__u8e3s4.yy().eu(block);
+}
+function close(_this__u8e3s4, cause) {
+  _init_properties_ByteWriteChannelOperations_kt__i7slrs();
+  if (cause == null) {
+    fireAndForget(ByteWriteChannel$flushAndClose$ref_0(_this__u8e3s4));
+  } else {
+    _this__u8e3s4.z1p(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_0(block, channel));
+  this_0.eu(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.r1p().k1m(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.b1r_1 = EmptyCoroutineContext_instance;
+      }
+      tb() {
+        return this.b1r_1;
+      }
+      ub(result) {
+        return Unit_instance;
+      }
+      vb(result) {
+        return this.ub(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.c1r_1 = p0;
+      }
+      dd($completion) {
+        return this.c1r_1.y1p($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.dd($completion);
+  l.callableName = 'flushAndClose';
+  l.$arity = 0;
+  return l;
+}
+function *_generator_invoke__zhh2q8($this, $this$launch, $completion) {
+  var nested = Job(get_job($this$launch.bt()));
+  try {
+    var tmp = $this.d1r_1(new (WriterScope())($this.e1r_1, $this$launch.bt().cl(nested)), $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+    nested.kz();
+    if (get_job($this$launch.bt()).yt()) {
+      $this.e1r_1.z1p(get_job($this$launch.bt()).bu());
+    }
+  } catch ($p) {
+    if ($p instanceof Error) {
+      var cause = $p;
+      cancel(nested, 'Exception thrown while writing to channel', cause);
+      $this.e1r_1.z1p(cause);
+    } else {
+      throw $p;
+    }
+  }
+  finally {
+    var tmp_0 = nested.iu($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.e1r_1.y1p($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.d1r_1 = $block;
+        this.e1r_1 = $channel;
+      }
+      b1c($this$launch, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, $this$launch), $completion);
+      }
+      bd(p1, $completion) {
+        return this.b1c((!(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.b1c($this$launch, $completion);
+  l.$arity = 1;
+  return l;
+}
+function writer$lambda($channel) {
+  return (it) => {
+    var tmp;
+    if (!(it == null) && !$channel.s1p()) {
+      $channel.z1p(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 writeByte32j1f6pu0p5dj,
+  writeFully as writeFully3gv1ab611t04k,
+  WriterScope as WriterScope3b0bo1enaee6b,
+  close as close3semq7pafb42g,
+  invokeOnCompletion as invokeOnCompletion1ziuxzoag0iwj,
+  writer as writer1eia5its2a1fh,
+};
+//endregion
+
+//# sourceMappingURL=ByteWriteChannelOperations.mjs.map

package/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","src/kotlin/util/Standard.kt","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","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/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().i1r(p0);
+  l.callableName = '<init>';
+  return l;
+}
+var CloseTokenClass;
+function CloseToken() {
+  if (CloseTokenClass === VOID) {
+    class $ {
+      constructor(origin) {
+        this.p1p_1 = origin;
+      }
+      j1r(wrap) {
+        var tmp0_subject = this.p1p_1;
+        var tmp;
+        if (tmp0_subject == null) {
+          tmp = null;
+        } else {
+          if (isInterface(tmp0_subject, CopyableThrowable())) {
+            tmp = this.p1p_1.xz();
+          } else {
+            if (tmp0_subject instanceof CancellationException()) {
+              tmp = CancellationException().wc(this.p1p_1.message, this.p1p_1);
+            } else {
+              tmp = wrap(this.p1p_1);
+            }
+          }
+        }
+        return tmp;
+      }
+      u1p(wrap, $super) {
+        var tmp;
+        if (wrap === VOID) {
+          tmp = ClosedByteChannelException$_init_$ref_yjp351();
+        } else {
+          tmp = wrap;
+        }
+        wrap = tmp;
+        return $super === VOID ? this.j1r(wrap) : $super.j1r.call(this, wrap);
+      }
+      q1p(wrap) {
+        var tmp0_safe_receiver = this.j1r(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/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","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,K;;YAClC,oD;+CAAkD,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/ktor-ktor-io/io/ktor/utils/io/CountedByteReadChannel.mjs

@@ -0,0 +1,89 @@
+import {
+  fromInt2ii0rejb1w62w as fromInt,
+  add2suhfggl4zvkk as add,
+  subtract2orl8z9upxd9l as subtract,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.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 { 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$default62rpipafmnr4 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 ($this.o1p().n1() >= fromInt(min)) {
+    return true;
+  }
+  var tmp = $this.k1r_1.w1p(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.l1r_1.j1m($this.k1r_1.o1p());
+  $this.m1r_1 = add($this.m1r_1, appended);
+}
+function updateConsumed($this) {
+  $this.n1r_1 = add($this.n1r_1, subtract($this.m1r_1, $this.l1r_1.n1()));
+  $this.m1r_1 = $this.l1r_1.n1();
+}
+var CountedByteReadChannelClass;
+function CountedByteReadChannel() {
+  if (CountedByteReadChannelClass === VOID) {
+    class $ {
+      constructor(delegate) {
+        this.k1r_1 = delegate;
+        this.l1r_1 = new (Buffer())();
+        this.m1r_1 = 0n;
+        this.n1r_1 = 0n;
+      }
+      o1r() {
+        updateConsumed(this);
+        return this.n1r_1;
+      }
+      t1p() {
+        return this.k1r_1.t1p();
+      }
+      v1p() {
+        return this.l1r_1.o1k() && this.k1r_1.v1p();
+      }
+      o1p() {
+        transferFromDelegate(this);
+        return this.l1r_1;
+      }
+      w1p(min, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_awaitContent__vf28kb.bind(VOID, this, min), $completion);
+      }
+      z1p(cause) {
+        this.k1r_1.z1p(cause);
+        this.l1r_1.a6();
+      }
+    }
+    protoOf($).x1p = 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/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,IAAA,WAAW,KAAX,IAAmB,YAAnB,C,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,e;QACC,e;;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/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/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/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 i1r(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.a1o(cause == null ? null : cause.message, cause);
+        captureStack($this, $this.h1r_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedByteChannelException', $.i1r);
+    ClosedByteChannelExceptionClass = $;
+  }
+  return ClosedByteChannelExceptionClass;
+}
+var ClosedReadChannelExceptionClass;
+function ClosedReadChannelException() {
+  if (ClosedReadChannelExceptionClass === VOID) {
+    class $ extends ClosedByteChannelException() {
+      static h1p(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.i1r(cause);
+        captureStack($this, $this.g1p_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedReadChannelException', $.h1p);
+    ClosedReadChannelExceptionClass = $;
+  }
+  return ClosedReadChannelExceptionClass;
+}
+var ClosedWriteChannelExceptionClass;
+function ClosedWriteChannelException() {
+  if (ClosedWriteChannelExceptionClass === VOID) {
+    class $ extends ClosedByteChannelException() {
+      static m1p(cause) {
+        cause = cause === VOID ? null : cause;
+        var $this = this.i1r(cause);
+        captureStack($this, $this.l1p_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ClosedWriteChannelException', $.m1p);
+    ClosedWriteChannelExceptionClass = $;
+  }
+  return ClosedWriteChannelExceptionClass;
+}
+//region block: exports
+export {
+  ClosedByteChannelException as ClosedByteChannelException3il8gfpye60w,
+  ClosedReadChannelException as ClosedReadChannelException9jdpzh6uy12w,
+  ClosedWriteChannelException as ClosedWriteChannelException1eeenxj0c4bxu,
+};
+//endregion
+
+//# sourceMappingURL=Exceptions.mjs.map

package/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/ktor-ktor-io/io/ktor/utils/io/IODispatcher.jsAndWasmShared.mjs

@@ -0,0 +1,15 @@
+import { Dispatchers_getInstanceitgtkvqfcnx3 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().o13_1;
+}
+//region block: exports
+export {
+  ioDispatcher as ioDispatcher3b9pa3x0duop,
+};
+//endregion
+
+//# sourceMappingURL=IODispatcher.jsAndWasmShared.mjs.map

package/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;;;;;"}