@continuous-excellence/coupling-cli 1.1.509 → 1.1.510

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

@@ -37,7 +37,7 @@ var NO_CALLBACK;
 function *writeFully(_this__u8e3s4, value, startIndex, endIndex, $completion) {
   startIndex = startIndex === VOID ? 0 : startIndex;
   endIndex = endIndex === VOID ? value.length : endIndex;
-  _this__u8e3s4.r1t().m1q(value, startIndex, endIndex);
+  _this__u8e3s4.l1t().g1q(value, startIndex, endIndex);
   yield* flushIfNeeded(_this__u8e3s4, $completion);
   return Unit_instance;
 }
@@ -46,11 +46,11 @@ function WriterJob() {
   if (WriterJobClass === VOID) {
     class $ {
       constructor(channel, job) {
-        this.z1u_1 = channel;
-        this.a1v_1 = job;
+        this.t1u_1 = channel;
+        this.u1u_1 = job;
       }
-      i10() {
-        return this.a1v_1;
+      d10() {
+        return this.u1u_1;
       }
     }
     initMetadataForClass($, 'WriterJob');
@@ -69,11 +69,11 @@ function WriterScope() {
   if (WriterScopeClass === VOID) {
     class $ {
       constructor(channel, coroutineContext) {
-        this.b1v_1 = channel;
-        this.c1v_1 = coroutineContext;
+        this.v1u_1 = channel;
+        this.w1u_1 = coroutineContext;
       }
-      gx() {
-        return this.c1v_1;
+      bx() {
+        return this.w1u_1;
       }
     }
     initMetadataForClass($, 'WriterScope', VOID, VOID, [CoroutineScope()]);
@@ -83,19 +83,19 @@ function WriterScope() {
 }
 function invokeOnCompletion(_this__u8e3s4, block) {
   _init_properties_ByteWriteChannelOperations_kt__i7slrs();
-  return _this__u8e3s4.i10().jy(block);
+  return _this__u8e3s4.d10().ey(block);
 }
 function close(_this__u8e3s4, cause) {
   _init_properties_ByteWriteChannelOperations_kt__i7slrs();
   if (cause == null) {
     fireAndForget(ByteWriteChannel$flushAndClose$ref_0(_this__u8e3s4));
   } else {
-    _this__u8e3s4.g1u(cause);
+    _this__u8e3s4.a1u(cause);
   }
 }
 function *writePacket(_this__u8e3s4, source, $completion) {
-  while (!source.d1p()) {
-    _this__u8e3s4.r1t().q1q(source, get_remaining(source));
+  while (!source.x1o()) {
+    _this__u8e3s4.l1t().k1q(source, get_remaining(source));
     yield* flushIfNeeded(_this__u8e3s4, $completion);
   }
   return Unit_instance;
@@ -105,7 +105,7 @@ function writer_0(_this__u8e3s4, coroutineContext, channel, block) {
   _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.jy(writer$lambda(channel));
+  this_0.ey(writer$lambda(channel));
   var job = this_0;
   return new (WriterJob())(channel, job);
 }
@@ -114,7 +114,7 @@ function fireAndForget(_this__u8e3s4) {
   startCoroutineCancellable(_this__u8e3s4, get_NO_CALLBACK());
 }
 function *writeByte(_this__u8e3s4, value, $completion) {
-  _this__u8e3s4.r1t().w1q(value);
+  _this__u8e3s4.l1t().q1q(value);
   yield* flushIfNeeded(_this__u8e3s4, $completion);
   return Unit_instance;
 }
@@ -123,10 +123,10 @@ function NO_CALLBACK$1() {
   if (NO_CALLBACK$1Class === VOID) {
     class $ {
       constructor() {
-        this.d1v_1 = EmptyCoroutineContext_getInstance();
+        this.x1u_1 = EmptyCoroutineContext_getInstance();
       }
       wc() {
-        return this.d1v_1;
+        return this.x1u_1;
       }
       xc(result) {
         return Unit_instance;
@@ -145,13 +145,13 @@ function ByteWriteChannel$flushAndClose$ref() {
   if (ByteWriteChannel$flushAndClose$refClass === VOID) {
     class $ {
       constructor(p0) {
-        this.e1v_1 = p0;
+        this.y1u_1 = p0;
       }
-      *f1v($completion) {
-        return yield* this.e1v_1.f1u($completion);
+      *z1u($completion) {
+        return yield* this.y1u_1.z1t($completion);
       }
       ud($completion) {
-        return this.f1v($completion);
+        return this.z1u($completion);
       }
     }
     initMetadataForFunctionReference($, VOID, VOID, [0]);
@@ -161,7 +161,7 @@ function ByteWriteChannel$flushAndClose$ref() {
 }
 function ByteWriteChannel$flushAndClose$ref_0(p0) {
   var i = new (ByteWriteChannel$flushAndClose$ref())(p0);
-  var l = ($completion) => i.f1v($completion);
+  var l = ($completion) => i.z1u($completion);
   l.callableName = 'flushAndClose';
   l.$arity = 0;
   return l;
@@ -171,32 +171,32 @@ function writer$slambda() {
   if (writer$slambdaClass === VOID) {
     class $ {
       constructor($block, $channel) {
-        this.g1v_1 = $block;
-        this.h1v_1 = $channel;
+        this.a1v_1 = $block;
+        this.b1v_1 = $channel;
       }
-      *w1h($this$launch, $completion) {
-        var nested = Job(get_job($this$launch.gx()));
+      *r1h($this$launch, $completion) {
+        var nested = Job(get_job($this$launch.bx()));
         try {
-          yield* this.g1v_1(new (WriterScope())(this.h1v_1, $this$launch.gx().po(nested)), $completion);
-          nested.p14();
-          if (get_job($this$launch.gx()).dy()) {
-            this.h1v_1.g1u(get_job($this$launch.gx()).gy());
+          yield* this.a1v_1(new (WriterScope())(this.b1v_1, $this$launch.bx().oo(nested)), $completion);
+          nested.k14();
+          if (get_job($this$launch.bx()).yx()) {
+            this.b1v_1.a1u(get_job($this$launch.bx()).by());
           }
         } catch ($p) {
           if ($p instanceof Error) {
             var cause = $p;
             cancel(nested, 'Exception thrown while writing to channel', cause);
-            this.h1v_1.g1u(cause);
+            this.b1v_1.a1u(cause);
           } else {
             throw $p;
           }
         }
         finally {
-          yield* nested.ny($completion);
+          yield* nested.iy($completion);
           // Inline function 'kotlin.runCatching' call
           var tmp;
           try {
-            yield* this.h1v_1.f1u($completion);
+            yield* this.b1v_1.z1t($completion);
             // Inline function 'kotlin.Companion.success' call
             tmp = _Result___init__impl__xyqfz8(Unit_instance);
           } catch ($p) {
@@ -214,7 +214,7 @@ function writer$slambda() {
         return Unit_instance;
       }
       vd(p1, $completion) {
-        return this.w1h((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+        return this.r1h((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
       }
     }
     initMetadataForLambda($, VOID, VOID, [1]);
@@ -224,15 +224,15 @@ function writer$slambda() {
 }
 function writer$slambda_0($block, $channel) {
   var i = new (writer$slambda())($block, $channel);
-  var l = ($this$launch, $completion) => i.w1h($this$launch, $completion);
+  var l = ($this$launch, $completion) => i.r1h($this$launch, $completion);
   l.$arity = 1;
   return l;
 }
 function writer$lambda($channel) {
   return (it) => {
     var tmp;
-    if (!(it == null) && !$channel.s1t()) {
-      $channel.g1u(it);
+    if (!(it == null) && !$channel.m1t()) {
+      $channel.a1u(it);
       tmp = Unit_instance;
     }
     return Unit_instance;

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

@@ -14,7 +14,7 @@ function get_CLOSED() {
 }
 var CLOSED;
 function ClosedByteChannelException$_init_$ref_yjp351() {
-  var l = (p0) => ClosedByteChannelException().l1v(p0);
+  var l = (p0) => ClosedByteChannelException().f1v(p0);
   l.callableName = '<init>';
   return l;
 }
@@ -23,27 +23,27 @@ function CloseToken() {
   if (CloseTokenClass === VOID) {
     class $ {
       constructor(origin) {
-        this.p1t_1 = origin;
+        this.j1t_1 = origin;
       }
-      m1v(wrap) {
-        var tmp0_subject = this.p1t_1;
+      g1v(wrap) {
+        var tmp0_subject = this.j1t_1;
         var tmp;
         if (tmp0_subject == null) {
           tmp = null;
         } else {
           if (isInterface(tmp0_subject, CopyableThrowable())) {
-            tmp = this.p1t_1.c15();
+            tmp = this.j1t_1.x14();
           } else {
             if (tmp0_subject instanceof CancellationException()) {
-              tmp = CancellationException().p(this.p1t_1.message, this.p1t_1);
+              tmp = CancellationException().p(this.j1t_1.message, this.j1t_1);
             } else {
-              tmp = wrap(this.p1t_1);
+              tmp = wrap(this.j1t_1);
             }
           }
         }
         return tmp;
       }
-      u1t(wrap, $super) {
+      o1t(wrap, $super) {
         var tmp;
         if (wrap === VOID) {
           tmp = ClosedByteChannelException$_init_$ref_yjp351();
@@ -51,10 +51,10 @@ function CloseToken() {
           tmp = wrap;
         }
         wrap = tmp;
-        return $super === VOID ? this.m1v(wrap) : $super.m1v.call(this, wrap);
+        return $super === VOID ? this.g1v(wrap) : $super.g1v.call(this, wrap);
       }
-      q1t(wrap) {
-        var tmp0_safe_receiver = this.m1v(wrap);
+      k1t(wrap) {
+        var tmp0_safe_receiver = this.g1v(wrap);
         var tmp;
         if (tmp0_safe_receiver == null) {
           tmp = null;

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

@@ -19,53 +19,53 @@ import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/k
 //endregion
 function transferFromDelegate($this) {
   updateConsumed($this);
-  var appended = $this.o1v_1.v1q($this.n1v_1.o1t());
-  $this.p1v_1 = add($this.p1v_1, appended);
+  var appended = $this.i1v_1.p1q($this.h1v_1.i1t());
+  $this.j1v_1 = add($this.j1v_1, appended);
 }
 function updateConsumed($this) {
-  $this.q1v_1 = add($this.q1v_1, subtract($this.p1v_1, $this.o1v_1.q2()));
-  $this.p1v_1 = $this.o1v_1.q2();
+  $this.k1v_1 = add($this.k1v_1, subtract($this.j1v_1, $this.i1v_1.q2()));
+  $this.j1v_1 = $this.i1v_1.q2();
 }
 var CountedByteReadChannelClass;
 function CountedByteReadChannel() {
   if (CountedByteReadChannelClass === VOID) {
     class $ {
       constructor(delegate) {
-        this.n1v_1 = delegate;
-        this.o1v_1 = new (Buffer())();
-        this.p1v_1 = new (Long())(0, 0);
-        this.q1v_1 = new (Long())(0, 0);
+        this.h1v_1 = delegate;
+        this.i1v_1 = new (Buffer())();
+        this.j1v_1 = new (Long())(0, 0);
+        this.k1v_1 = new (Long())(0, 0);
       }
-      r1v() {
+      l1v() {
         updateConsumed(this);
-        return this.q1v_1;
+        return this.k1v_1;
       }
-      t1t() {
-        return this.n1v_1.t1t();
+      n1t() {
+        return this.h1v_1.n1t();
       }
-      v1t() {
-        return this.o1v_1.d1p() && this.n1v_1.v1t();
+      p1t() {
+        return this.i1v_1.x1o() && this.h1v_1.p1t();
       }
-      o1t() {
+      i1t() {
         transferFromDelegate(this);
-        return this.o1v_1;
+        return this.i1v_1;
       }
-      *w1t(min, $completion) {
-        if (compare(this.o1t().q2(), fromInt(min)) >= 0) {
+      *q1t(min, $completion) {
+        if (compare(this.i1t().q2(), fromInt(min)) >= 0) {
           return true;
         }
-        if (yield* this.n1v_1.w1t(min, $completion)) {
+        if (yield* this.h1v_1.q1t(min, $completion)) {
           transferFromDelegate(this);
           return true;
         }
         return false;
       }
-      g1u(cause) {
-        this.n1v_1.g1u(cause);
-        this.o1v_1.j6();
+      a1u(cause) {
+        this.h1v_1.a1u(cause);
+        this.i1v_1.j6();
       }
     }
-    protoOf($).c1u = awaitContent$default;
+    protoOf($).w1t = awaitContent$default;
     initMetadataForClass($, 'CountedByteReadChannel', VOID, VOID, [ByteReadChannel()], [1]);
     CountedByteReadChannelClass = $;
   }

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

@@ -10,14 +10,14 @@ var ClosedByteChannelExceptionClass;
 function ClosedByteChannelException() {
   if (ClosedByteChannelExceptionClass === VOID) {
     class $ extends IOException() {
-      static l1v(cause) {
+      static f1v(cause) {
         cause = cause === VOID ? null : cause;
-        var $this = this.h1s(cause == null ? null : cause.message, cause);
-        captureStack($this, $this.k1v_1);
+        var $this = this.b1s(cause == null ? null : cause.message, cause);
+        captureStack($this, $this.e1v_1);
         return $this;
       }
     }
-    initMetadataForClass($, 'ClosedByteChannelException', $.l1v);
+    initMetadataForClass($, 'ClosedByteChannelException', $.f1v);
     ClosedByteChannelExceptionClass = $;
   }
   return ClosedByteChannelExceptionClass;
@@ -26,14 +26,14 @@ var ClosedReadChannelExceptionClass;
 function ClosedReadChannelException() {
   if (ClosedReadChannelExceptionClass === VOID) {
     class $ extends ClosedByteChannelException() {
-      static h1t(cause) {
+      static b1t(cause) {
         cause = cause === VOID ? null : cause;
-        var $this = this.l1v(cause);
-        captureStack($this, $this.g1t_1);
+        var $this = this.f1v(cause);
+        captureStack($this, $this.a1t_1);
         return $this;
       }
     }
-    initMetadataForClass($, 'ClosedReadChannelException', $.h1t);
+    initMetadataForClass($, 'ClosedReadChannelException', $.b1t);
     ClosedReadChannelExceptionClass = $;
   }
   return ClosedReadChannelExceptionClass;
@@ -42,14 +42,14 @@ var ClosedWriteChannelExceptionClass;
 function ClosedWriteChannelException() {
   if (ClosedWriteChannelExceptionClass === VOID) {
     class $ extends ClosedByteChannelException() {
-      static m1t(cause) {
+      static g1t(cause) {
         cause = cause === VOID ? null : cause;
-        var $this = this.l1v(cause);
-        captureStack($this, $this.l1t_1);
+        var $this = this.f1v(cause);
+        captureStack($this, $this.f1t_1);
         return $this;
       }
     }
-    initMetadataForClass($, 'ClosedWriteChannelException', $.m1t);
+    initMetadataForClass($, 'ClosedWriteChannelException', $.g1t);
     ClosedWriteChannelExceptionClass = $;
   }
   return ClosedWriteChannelExceptionClass;

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

@@ -4,7 +4,7 @@ import { Dispatchers_getInstance2p2r3ndn98nn as Dispatchers_getInstance } from '
 //region block: pre-declaration
 //endregion
 function ioDispatcher() {
-  return Dispatchers_getInstance().a19_1;
+  return Dispatchers_getInstance().v18_1;
 }
 //region block: exports
 export {

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

@@ -25,21 +25,21 @@ function LineEndingMode__plus_impl_ttpz2j($this, other) {
 }
 function LineEndingMode__toString_impl_j4h76r($this) {
   var tmp;
-  if ($this === Companion_getInstance().s1v_1) {
+  if ($this === Companion_getInstance().m1v_1) {
     tmp = 'CR';
-  } else if ($this === Companion_getInstance().t1v_1) {
+  } else if ($this === Companion_getInstance().n1v_1) {
     tmp = 'LF';
-  } else if ($this === Companion_getInstance().u1v_1) {
+  } else if ($this === Companion_getInstance().o1v_1) {
     tmp = 'CRLF';
   } else {
     // Inline function 'kotlin.collections.filter' call
-    var tmp0 = Companion_getInstance().w1v_1;
+    var tmp0 = Companion_getInstance().q1v_1;
     // Inline function 'kotlin.collections.filterTo' call
     var destination = ArrayList().i2();
     var _iterator__ex2g4s = tmp0.l1();
     while (_iterator__ex2g4s.m1()) {
       var element = _iterator__ex2g4s.n1();
-      var it = element.x1v_1;
+      var it = element.r1v_1;
       if (LineEndingMode__contains_impl_q5pr68($this, it)) {
         destination.o2(element);
       }
@@ -54,11 +54,11 @@ function Companion() {
     class $ {
       constructor() {
         Companion_instance = this;
-        this.s1v_1 = _LineEndingMode___init__impl__jo5bul(1);
-        this.t1v_1 = _LineEndingMode___init__impl__jo5bul(2);
-        this.u1v_1 = _LineEndingMode___init__impl__jo5bul(4);
-        this.v1v_1 = _LineEndingMode___init__impl__jo5bul(7);
-        this.w1v_1 = listOf([new (LineEndingMode())(this.s1v_1), new (LineEndingMode())(this.t1v_1), new (LineEndingMode())(this.u1v_1)]);
+        this.m1v_1 = _LineEndingMode___init__impl__jo5bul(1);
+        this.n1v_1 = _LineEndingMode___init__impl__jo5bul(2);
+        this.o1v_1 = _LineEndingMode___init__impl__jo5bul(4);
+        this.p1v_1 = _LineEndingMode___init__impl__jo5bul(7);
+        this.q1v_1 = listOf([new (LineEndingMode())(this.m1v_1), new (LineEndingMode())(this.n1v_1), new (LineEndingMode())(this.o1v_1)]);
       }
     }
     initMetadataForCompanion($);
@@ -78,7 +78,7 @@ function LineEndingMode__hashCode_impl_2mopm4($this) {
 function LineEndingMode__equals_impl_qyr4nk($this, other) {
   if (!(other instanceof LineEndingMode()))
     return false;
-  if (!($this === other.x1v_1))
+  if (!($this === other.r1v_1))
     return false;
   return true;
 }
@@ -88,16 +88,16 @@ function LineEndingMode() {
     class $ {
       constructor(mode) {
         Companion_getInstance();
-        this.x1v_1 = mode;
+        this.r1v_1 = mode;
       }
       toString() {
-        return LineEndingMode__toString_impl_j4h76r(this.x1v_1);
+        return LineEndingMode__toString_impl_j4h76r(this.r1v_1);
       }
       hashCode() {
-        return LineEndingMode__hashCode_impl_2mopm4(this.x1v_1);
+        return LineEndingMode__hashCode_impl_2mopm4(this.r1v_1);
       }
       equals(other) {
-        return LineEndingMode__equals_impl_qyr4nk(this.x1v_1, other);
+        return LineEndingMode__equals_impl_qyr4nk(this.r1v_1, other);
       }
     }
     initMetadataForClass($, 'LineEndingMode');

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

@@ -18,46 +18,46 @@ function SourceByteReadChannel() {
   if (SourceByteReadChannelClass === VOID) {
     class $ {
       constructor(source) {
-        this.y1v_1 = source;
-        this.z1v_1 = null;
+        this.s1v_1 = source;
+        this.t1v_1 = null;
       }
-      t1t() {
-        var tmp0_safe_receiver = this.z1v_1;
-        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.u1t();
+      n1t() {
+        var tmp0_safe_receiver = this.t1v_1;
+        return tmp0_safe_receiver == null ? null : tmp0_safe_receiver.o1t();
       }
-      v1t() {
-        return this.y1v_1.d1p();
+      p1t() {
+        return this.s1v_1.x1o();
       }
-      o1t() {
-        var tmp0_safe_receiver = this.t1t();
+      i1t() {
+        var tmp0_safe_receiver = this.n1t();
         if (tmp0_safe_receiver == null)
           null;
         else {
           // Inline function 'kotlin.let' call
           throw tmp0_safe_receiver;
         }
-        return this.y1v_1.c1p();
+        return this.s1v_1.w1o();
       }
-      *w1t(min, $completion) {
-        var tmp0_safe_receiver = this.t1t();
+      *q1t(min, $completion) {
+        var tmp0_safe_receiver = this.n1t();
         if (tmp0_safe_receiver == null)
           null;
         else {
           // Inline function 'kotlin.let' call
           throw tmp0_safe_receiver;
         }
-        return this.y1v_1.f1p(fromInt(min));
+        return this.s1v_1.z1o(fromInt(min));
       }
-      g1u(cause) {
-        if (!(this.z1v_1 == null))
+      a1u(cause) {
+        if (!(this.t1v_1 == null))
           return Unit_instance;
-        this.y1v_1.j6();
+        this.s1v_1.j6();
         var tmp = this;
         var tmp1_elvis_lhs = cause == null ? null : cause.message;
-        tmp.z1v_1 = new (CloseToken())(IOException().h1s(tmp1_elvis_lhs == null ? 'Channel was cancelled' : tmp1_elvis_lhs, cause));
+        tmp.t1v_1 = new (CloseToken())(IOException().b1s(tmp1_elvis_lhs == null ? 'Channel was cancelled' : tmp1_elvis_lhs, cause));
       }
     }
-    protoOf($).c1u = awaitContent$default;
+    protoOf($).w1t = awaitContent$default;
     initMetadataForClass($, 'SourceByteReadChannel', VOID, VOID, [ByteReadChannel()], [1]);
     SourceByteReadChannelClass = $;
   }