@continuous-excellence/coupling-cli 1.1.425 → 1.1.427

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/internal/CoroutineExceptionHandlerImpl.common.mjs

@@ -18,7 +18,7 @@ function handleUncaughtCoroutineException(context, exception) {
   while (_iterator__ex2g4s.r1()) {
     var handler = _iterator__ex2g4s.s1();
     try {
-      handler.c14(context, exception);
+      handler.b14(context, exception);
     } catch ($p) {
       if ($p instanceof ExceptionSuccessfullyProcessed()) {
         var _unused_var__etf5q3 = $p;
@@ -34,7 +34,7 @@ function handleUncaughtCoroutineException(context, exception) {
     }
   }
   try {
-    addSuppressed(exception, DiagnosticCoroutineContextException().h1j(context));
+    addSuppressed(exception, DiagnosticCoroutineContextException().e1j(context));
   } catch ($p) {
     if ($p instanceof Error) {
       var e = $p;

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/internal/CoroutineExceptionHandlerImpl.mjs

@@ -26,9 +26,9 @@ var DiagnosticCoroutineContextExceptionClass;
 function DiagnosticCoroutineContextException() {
   if (DiagnosticCoroutineContextExceptionClass === VOID) {
     class $ extends RuntimeException() {
-      static h1j(context) {
+      static e1j(context) {
         var $this = this.db(toString(context));
-        captureStack($this, $this.g1j_1);
+        captureStack($this, $this.d1j_1);
         return $this;
       }
     }

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/internal/DispatchedContinuation.mjs

@@ -49,27 +49,27 @@ function resumeCancellableWith(_this__u8e3s4, result) {
   if (_this__u8e3s4 instanceof DispatchedContinuation()) {
     // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeCancellableWith' call
     var state = toState(result);
-    if (safeIsDispatchNeeded(_this__u8e3s4.h11_1, _this__u8e3s4.bd())) {
-      _this__u8e3s4.j11_1 = state;
-      _this__u8e3s4.q11_1 = 1;
-      safeDispatch(_this__u8e3s4.h11_1, _this__u8e3s4.bd(), _this__u8e3s4);
+    if (safeIsDispatchNeeded(_this__u8e3s4.g11_1, _this__u8e3s4.bd())) {
+      _this__u8e3s4.i11_1 = state;
+      _this__u8e3s4.p11_1 = 1;
+      safeDispatch(_this__u8e3s4.g11_1, _this__u8e3s4.bd(), _this__u8e3s4);
     } else {
       $l$block: {
         // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
         // Inline function 'kotlinx.coroutines.assert' call
-        var eventLoop = ThreadLocalEventLoop_getInstance().v14();
-        if (false && eventLoop.q14()) {
+        var eventLoop = ThreadLocalEventLoop_getInstance().u14();
+        if (false && eventLoop.p14()) {
           break $l$block;
         }
         var tmp_0;
-        if (eventLoop.p14()) {
-          _this__u8e3s4.j11_1 = state;
-          _this__u8e3s4.q11_1 = 1;
-          eventLoop.o14(_this__u8e3s4);
+        if (eventLoop.o14()) {
+          _this__u8e3s4.i11_1 = state;
+          _this__u8e3s4.p11_1 = 1;
+          eventLoop.n14(_this__u8e3s4);
           tmp_0 = true;
         } else {
           // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
-          eventLoop.r14(true);
+          eventLoop.q14(true);
           try {
             var tmp$ret$4;
             $l$block_0: {
@@ -77,7 +77,7 @@ function resumeCancellableWith(_this__u8e3s4, result) {
               var job = _this__u8e3s4.bd().rd(Key_instance);
               if (!(job == null) && !job.kw()) {
                 var cause = job.jx();
-                _this__u8e3s4.n12(state, cause);
+                _this__u8e3s4.m12(state, cause);
                 // Inline function 'kotlin.coroutines.resumeWithException' call
                 // Inline function 'kotlin.Companion.failure' call
                 var tmp$ret$2 = _Result___init__impl__xyqfz8(createFailure(cause));
@@ -89,23 +89,23 @@ function resumeCancellableWith(_this__u8e3s4, result) {
             }
             if (!tmp$ret$4) {
               // Inline function 'kotlinx.coroutines.internal.DispatchedContinuation.resumeUndispatchedWith' call
-              _this__u8e3s4.i11_1;
+              _this__u8e3s4.h11_1;
               // Inline function 'kotlinx.coroutines.withContinuationContext' call
-              _this__u8e3s4.k11_1;
-              _this__u8e3s4.i11_1.dd(result);
+              _this__u8e3s4.j11_1;
+              _this__u8e3s4.h11_1.dd(result);
             }
-            $l$loop: while (eventLoop.n14()) {
+            $l$loop: while (eventLoop.m14()) {
             }
           } catch ($p) {
             if ($p instanceof Error) {
               var e = $p;
-              _this__u8e3s4.h13(e);
+              _this__u8e3s4.g13(e);
             } else {
               throw $p;
             }
           }
           finally {
-            eventLoop.s14(true);
+            eventLoop.r14(true);
           }
           tmp_0 = false;
         }
@@ -119,7 +119,7 @@ function resumeCancellableWith(_this__u8e3s4, result) {
   return tmp;
 }
 function _get_reusableCancellableContinuation__9qex09($this) {
-  var tmp = $this.l11_1.kotlinx$atomicfu$value;
+  var tmp = $this.k11_1.kotlinx$atomicfu$value;
   return tmp instanceof CancellableContinuationImpl() ? tmp : null;
 }
 var DispatchedContinuationClass;
@@ -128,43 +128,43 @@ function DispatchedContinuation() {
     class $ extends DispatchedTask() {
       constructor(dispatcher, continuation) {
         super(-1);
-        this.h11_1 = dispatcher;
-        this.i11_1 = continuation;
-        this.j11_1 = get_UNDEFINED();
-        this.k11_1 = threadContextElements(this.bd());
-        this.l11_1 = atomic$ref$1(null);
+        this.g11_1 = dispatcher;
+        this.h11_1 = continuation;
+        this.i11_1 = get_UNDEFINED();
+        this.j11_1 = threadContextElements(this.bd());
+        this.k11_1 = atomic$ref$1(null);
       }
-      p11() {
-        return !(this.l11_1.kotlinx$atomicfu$value == null);
+      o11() {
+        return !(this.k11_1.kotlinx$atomicfu$value == null);
       }
-      i1j() {
+      f1j() {
         // Inline function 'kotlinx.atomicfu.loop' call
-        var this_0 = this.l11_1;
+        var this_0 = this.k11_1;
         while (true) {
           if (!(this_0.kotlinx$atomicfu$value === get_REUSABLE_CLAIMED()))
             return Unit_instance;
         }
       }
-      y13() {
-        this.i1j();
+      x13() {
+        this.f1j();
         var tmp0_safe_receiver = _get_reusableCancellableContinuation__9qex09(this);
         if (tmp0_safe_receiver == null)
           null;
         else {
-          tmp0_safe_receiver.k12();
+          tmp0_safe_receiver.j12();
         }
       }
-      m11() {
+      l11() {
         // Inline function 'kotlinx.atomicfu.loop' call
-        var this_0 = this.l11_1;
+        var this_0 = this.k11_1;
         while (true) {
           var state = this_0.kotlinx$atomicfu$value;
           if (state === null) {
-            this.l11_1.kotlinx$atomicfu$value = get_REUSABLE_CLAIMED();
+            this.k11_1.kotlinx$atomicfu$value = get_REUSABLE_CLAIMED();
             return null;
           } else {
             if (state instanceof CancellableContinuationImpl()) {
-              if (this.l11_1.atomicfu$compareAndSet(state, get_REUSABLE_CLAIMED())) {
+              if (this.k11_1.atomicfu$compareAndSet(state, get_REUSABLE_CLAIMED())) {
                 return state instanceof CancellableContinuationImpl() ? state : THROW_CCE();
               }
             } else {
@@ -179,19 +179,19 @@ function DispatchedContinuation() {
           }
         }
       }
-      v12(continuation) {
+      u12(continuation) {
         // Inline function 'kotlinx.atomicfu.loop' call
-        var this_0 = this.l11_1;
+        var this_0 = this.k11_1;
         while (true) {
           var state = this_0.kotlinx$atomicfu$value;
           if (state === get_REUSABLE_CLAIMED()) {
-            if (this.l11_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), continuation))
+            if (this.k11_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), continuation))
               return null;
           } else {
             if (state instanceof Error) {
               // Inline function 'kotlin.require' call
               // Inline function 'kotlin.require' call
-              if (!this.l11_1.atomicfu$compareAndSet(state, null)) {
+              if (!this.k11_1.atomicfu$compareAndSet(state, null)) {
                 var message = 'Failed requirement.';
                 throw IllegalArgumentException().r2(toString_0(message));
               }
@@ -204,73 +204,73 @@ function DispatchedContinuation() {
           }
         }
       }
-      r11(cause) {
+      q11(cause) {
         // Inline function 'kotlinx.atomicfu.loop' call
-        var this_0 = this.l11_1;
+        var this_0 = this.k11_1;
         while (true) {
           var state = this_0.kotlinx$atomicfu$value;
           if (equals(state, get_REUSABLE_CLAIMED())) {
-            if (this.l11_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), cause))
+            if (this.k11_1.atomicfu$compareAndSet(get_REUSABLE_CLAIMED(), cause))
               return true;
           } else {
             if (state instanceof Error)
               return true;
             else {
-              if (this.l11_1.atomicfu$compareAndSet(state, null))
+              if (this.k11_1.atomicfu$compareAndSet(state, null))
                 return false;
             }
           }
         }
       }
-      m12() {
-        var state = this.j11_1;
+      l12() {
+        var state = this.i11_1;
         // Inline function 'kotlinx.coroutines.assert' call
-        this.j11_1 = get_UNDEFINED();
+        this.i11_1 = get_UNDEFINED();
         return state;
       }
-      l12() {
+      k12() {
         return this;
       }
       dd(result) {
         var state = toState(result);
-        if (safeIsDispatchNeeded(this.h11_1, this.bd())) {
-          this.j11_1 = state;
-          this.q11_1 = 0;
-          safeDispatch(this.h11_1, this.bd(), this);
+        if (safeIsDispatchNeeded(this.g11_1, this.bd())) {
+          this.i11_1 = state;
+          this.p11_1 = 0;
+          safeDispatch(this.g11_1, this.bd(), this);
         } else {
           $l$block: {
             // Inline function 'kotlinx.coroutines.internal.executeUnconfined' call
             // Inline function 'kotlinx.coroutines.assert' call
-            var eventLoop = ThreadLocalEventLoop_getInstance().v14();
-            if (false && eventLoop.q14()) {
+            var eventLoop = ThreadLocalEventLoop_getInstance().u14();
+            if (false && eventLoop.p14()) {
               break $l$block;
             }
             var tmp;
-            if (eventLoop.p14()) {
-              this.j11_1 = state;
-              this.q11_1 = 0;
-              eventLoop.o14(this);
+            if (eventLoop.o14()) {
+              this.i11_1 = state;
+              this.p11_1 = 0;
+              eventLoop.n14(this);
               tmp = true;
             } else {
               // Inline function 'kotlinx.coroutines.runUnconfinedEventLoop' call
-              eventLoop.r14(true);
+              eventLoop.q14(true);
               try {
                 this.bd();
                 // Inline function 'kotlinx.coroutines.withCoroutineContext' call
-                this.k11_1;
-                this.i11_1.dd(result);
-                $l$loop: while (eventLoop.n14()) {
+                this.j11_1;
+                this.h11_1.dd(result);
+                $l$loop: while (eventLoop.m14()) {
                 }
               } catch ($p) {
                 if ($p instanceof Error) {
                   var e = $p;
-                  this.h13(e);
+                  this.g13(e);
                 } else {
                   throw $p;
                 }
               }
               finally {
-                eventLoop.s14(true);
+                eventLoop.r14(true);
               }
               tmp = false;
             }
@@ -278,10 +278,10 @@ function DispatchedContinuation() {
         }
       }
       toString() {
-        return 'DispatchedContinuation[' + this.h11_1.toString() + ', ' + toDebugString(this.i11_1) + ']';
+        return 'DispatchedContinuation[' + this.g11_1.toString() + ', ' + toDebugString(this.h11_1) + ']';
       }
       bd() {
-        return this.i11_1.bd();
+        return this.h11_1.bd();
       }
     }
     initMetadataForClass($, 'DispatchedContinuation', VOID, VOID, [DispatchedTask(), Continuation()]);
@@ -292,11 +292,11 @@ function DispatchedContinuation() {
 function safeDispatch(_this__u8e3s4, context, runnable) {
   _init_properties_DispatchedContinuation_kt__tnmqc0();
   try {
-    _this__u8e3s4.x13(context, runnable);
+    _this__u8e3s4.w13(context, runnable);
   } catch ($p) {
     if ($p instanceof Error) {
       var e = $p;
-      throw DispatchException().j1j(e, _this__u8e3s4, context);
+      throw DispatchException().g1j(e, _this__u8e3s4, context);
     } else {
       throw $p;
     }
@@ -305,11 +305,11 @@ function safeDispatch(_this__u8e3s4, context, runnable) {
 function safeIsDispatchNeeded(_this__u8e3s4, context) {
   _init_properties_DispatchedContinuation_kt__tnmqc0();
   try {
-    return _this__u8e3s4.u13(context);
+    return _this__u8e3s4.t13(context);
   } catch ($p) {
     if ($p instanceof Error) {
       var e = $p;
-      throw DispatchException().j1j(e, _this__u8e3s4, context);
+      throw DispatchException().g1j(e, _this__u8e3s4, context);
     } else {
       throw $p;
     }

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/internal/LimitedDispatcher.mjs

@@ -33,23 +33,23 @@ function checkParallelism(_this__u8e3s4) {
 function tryAllocateWorker($this) {
   // Inline function 'kotlinx.coroutines.internal.synchronized' call
   // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
-  $this.r1j_1;
-  if ($this.p1j_1.kotlinx$atomicfu$value >= $this.n1j_1)
+  $this.o1j_1;
+  if ($this.m1j_1.kotlinx$atomicfu$value >= $this.k1j_1)
     return false;
-  $this.p1j_1.atomicfu$incrementAndGet();
+  $this.m1j_1.atomicfu$incrementAndGet();
   return true;
 }
 function obtainTaskOrDeallocateWorker($this) {
   while (true) {
-    var nextTask = $this.q1j_1.il();
+    var nextTask = $this.n1j_1.il();
     if (nextTask == null) {
       // Inline function 'kotlinx.coroutines.internal.synchronized' call
       // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
-      $this.r1j_1;
-      $this.p1j_1.atomicfu$decrementAndGet();
-      if ($this.q1j_1.v2() === 0)
+      $this.o1j_1;
+      $this.m1j_1.atomicfu$decrementAndGet();
+      if ($this.n1j_1.v2() === 0)
         return null;
-      $this.p1j_1.atomicfu$incrementAndGet();
+      $this.m1j_1.atomicfu$incrementAndGet();
     } else
       return nextTask;
   }
@@ -59,15 +59,15 @@ function Worker() {
   if (WorkerClass === VOID) {
     class $ {
       constructor($outer, currentTask) {
-        this.u1j_1 = $outer;
-        this.t1j_1 = currentTask;
+        this.r1j_1 = $outer;
+        this.q1j_1 = currentTask;
       }
-      g13() {
+      f13() {
         try {
           var fairnessCounter = 0;
           while (true) {
             try {
-              this.t1j_1.g13();
+              this.q1j_1.f13();
             } catch ($p) {
               if ($p instanceof Error) {
                 var e = $p;
@@ -77,23 +77,23 @@ function Worker() {
               }
             }
             var tmp = this;
-            var tmp0_elvis_lhs = obtainTaskOrDeallocateWorker(this.u1j_1);
+            var tmp0_elvis_lhs = obtainTaskOrDeallocateWorker(this.r1j_1);
             var tmp_0;
             if (tmp0_elvis_lhs == null) {
               return Unit_instance;
             } else {
               tmp_0 = tmp0_elvis_lhs;
             }
-            tmp.t1j_1 = tmp_0;
+            tmp.q1j_1 = tmp_0;
             var tmp_1;
             fairnessCounter = fairnessCounter + 1 | 0;
             if (fairnessCounter >= 16) {
-              tmp_1 = safeIsDispatchNeeded(this.u1j_1.m1j_1, this.u1j_1);
+              tmp_1 = safeIsDispatchNeeded(this.r1j_1.j1j_1, this.r1j_1);
             } else {
               tmp_1 = false;
             }
             if (tmp_1) {
-              safeDispatch(this.u1j_1.m1j_1, this.u1j_1, this);
+              safeDispatch(this.r1j_1.j1j_1, this.r1j_1, this);
               return Unit_instance;
             }
           }
@@ -102,8 +102,8 @@ function Worker() {
             var e_0 = $p;
             // Inline function 'kotlinx.coroutines.internal.synchronized' call
             // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
-            this.u1j_1.r1j_1;
-            this.u1j_1.p1j_1.atomicfu$decrementAndGet();
+            this.r1j_1.o1j_1;
+            this.r1j_1.m1j_1.atomicfu$decrementAndGet();
             throw e_0;
           } else {
             throw $p;
@@ -124,25 +124,25 @@ function LimitedDispatcher() {
         super();
         var tmp = this;
         var tmp0_elvis_lhs = isInterface(dispatcher, Delay()) ? dispatcher : null;
-        tmp.l1j_1 = tmp0_elvis_lhs == null ? get_DefaultDelay() : tmp0_elvis_lhs;
-        this.m1j_1 = dispatcher;
-        this.n1j_1 = parallelism;
-        this.o1j_1 = name;
-        this.p1j_1 = atomic$int$1(0);
-        this.q1j_1 = new (LockFreeTaskQueue())(false);
-        this.r1j_1 = new (SynchronizedObject())();
+        tmp.i1j_1 = tmp0_elvis_lhs == null ? get_DefaultDelay() : tmp0_elvis_lhs;
+        this.j1j_1 = dispatcher;
+        this.k1j_1 = parallelism;
+        this.l1j_1 = name;
+        this.m1j_1 = atomic$int$1(0);
+        this.n1j_1 = new (LockFreeTaskQueue())(false);
+        this.o1j_1 = new (SynchronizedObject())();
       }
-      v13(parallelism, name) {
+      u13(parallelism, name) {
         checkParallelism(parallelism);
-        if (parallelism >= this.n1j_1)
+        if (parallelism >= this.k1j_1)
           return namedOrThis(this, name);
-        return super.v13(parallelism, name);
+        return super.u13(parallelism, name);
       }
-      x13(context, block) {
+      w13(context, block) {
         $l$block_1: {
           // Inline function 'kotlinx.coroutines.internal.LimitedDispatcher.dispatchInternal' call
-          this.q1j_1.v1j(block);
-          if (this.p1j_1.kotlinx$atomicfu$value >= this.n1j_1) {
+          this.n1j_1.s1j(block);
+          if (this.m1j_1.kotlinx$atomicfu$value >= this.k1j_1) {
             break $l$block_1;
           }
           if (!tryAllocateWorker(this)) {
@@ -158,11 +158,11 @@ function LimitedDispatcher() {
           var task = tmp;
           try {
             var worker = new (Worker())(this, task);
-            safeDispatch(this.m1j_1, this, worker);
+            safeDispatch(this.j1j_1, this, worker);
           } catch ($p) {
             if ($p instanceof Error) {
               var e = $p;
-              this.p1j_1.atomicfu$decrementAndGet();
+              this.m1j_1.atomicfu$decrementAndGet();
               throw e;
             } else {
               throw $p;
@@ -171,14 +171,14 @@ function LimitedDispatcher() {
         }
       }
       toString() {
-        var tmp0_elvis_lhs = this.o1j_1;
-        return tmp0_elvis_lhs == null ? this.m1j_1.toString() + '.limitedParallelism(' + this.n1j_1 + ')' : tmp0_elvis_lhs;
+        var tmp0_elvis_lhs = this.l1j_1;
+        return tmp0_elvis_lhs == null ? this.j1j_1.toString() + '.limitedParallelism(' + this.k1j_1 + ')' : tmp0_elvis_lhs;
       }
-      g14(timeMillis, continuation) {
-        this.l1j_1.g14(timeMillis, continuation);
+      f14(timeMillis, continuation) {
+        this.i1j_1.f14(timeMillis, continuation);
       }
-      h14(timeMillis, block, context) {
-        return this.l1j_1.h14(timeMillis, block, context);
+      g14(timeMillis, block, context) {
+        return this.i1j_1.g14(timeMillis, block, context);
       }
     }
     initMetadataForClass($, 'LimitedDispatcher', VOID, VOID, [CoroutineDispatcher(), Delay()], [1]);

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/internal/LinkedList.mjs

@@ -12,41 +12,41 @@ function LockFreeLinkedListNode() {
     class $ {
       constructor($box) {
         boxApply(this, $box);
+        this.nz_1 = this;
         this.oz_1 = this;
-        this.pz_1 = this;
-        this.qz_1 = false;
+        this.pz_1 = false;
       }
-      rz(node, permissionsBitmask) {
-        var prev = this.pz_1;
+      qz(node, permissionsBitmask) {
+        var prev = this.oz_1;
         var tmp;
         if (prev instanceof ListClosed()) {
-          tmp = ((prev.m1n_1 & permissionsBitmask) === 0 && prev.rz(node, permissionsBitmask));
+          tmp = ((prev.j1n_1 & permissionsBitmask) === 0 && prev.qz(node, permissionsBitmask));
         } else {
-          node.oz_1 = this;
-          node.pz_1 = prev;
-          prev.oz_1 = node;
-          this.pz_1 = node;
+          node.nz_1 = this;
+          node.oz_1 = prev;
+          prev.nz_1 = node;
+          this.oz_1 = node;
           tmp = true;
         }
         return tmp;
       }
-      b16(forbiddenElementsBit) {
-        this.rz(new (ListClosed())(forbiddenElementsBit), forbiddenElementsBit);
+      u15(forbiddenElementsBit) {
+        this.qz(new (ListClosed())(forbiddenElementsBit), forbiddenElementsBit);
       }
-      sz() {
-        if (this.qz_1)
+      rz() {
+        if (this.pz_1)
           return false;
-        var prev = this.pz_1;
-        var next = this.oz_1;
-        prev.oz_1 = next;
-        next.pz_1 = prev;
-        this.qz_1 = true;
+        var prev = this.oz_1;
+        var next = this.nz_1;
+        prev.nz_1 = next;
+        next.oz_1 = prev;
+        this.pz_1 = true;
         return true;
       }
-      tz(node) {
-        if (!(this.oz_1 === this))
+      sz(node) {
+        if (!(this.nz_1 === this))
           return false;
-        this.rz(node, -2147483648);
+        this.qz(node, -2147483648);
         return true;
       }
     }
@@ -70,7 +70,7 @@ function ListClosed() {
     class $ extends LockFreeLinkedListNode() {
       constructor(forbiddenElementsBitmask) {
         super();
-        this.m1n_1 = forbiddenElementsBitmask;
+        this.j1n_1 = forbiddenElementsBitmask;
       }
     }
     initMetadataForClass($, 'ListClosed');