@continuous-excellence/coupling-cli 1.1.583 → 1.1.584

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/channels/ConflatedBufferedChannel.mjs

@@ -55,14 +55,14 @@ import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../
 //region block: pre-declaration
 //endregion
 function trySendImpl($this, element, isSendOp) {
-  return $this.h1e_1 === BufferOverflow_DROP_LATEST_getInstance() ? trySendDropLatest($this, element, isSendOp) : trySendDropOldest($this, element);
+  return $this.h1f_1 === BufferOverflow_DROP_LATEST_getInstance() ? trySendDropLatest($this, element, isSendOp) : trySendDropOldest($this, element);
 }
 function trySendDropLatest($this, element, isSendOp) {
-  var result = protoOf(BufferedChannel()).t1c.call($this, element);
+  var result = protoOf(BufferedChannel()).t1d.call($this, element);
   if (_ChannelResult___get_isSuccess__impl__odq1z9(result) || _ChannelResult___get_isClosed__impl__mg7kuu(result))
     return result;
   if (isSendOp) {
-    var tmp0_safe_receiver = $this.k1a_1;
+    var tmp0_safe_receiver = $this.k1b_1;
     var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : callUndeliveredElementCatchingException(tmp0_safe_receiver, element);
     if (tmp1_safe_receiver == null)
       null;
@@ -71,7 +71,7 @@ function trySendDropLatest($this, element, isSendOp) {
       throw tmp1_safe_receiver;
     }
   }
-  return Companion_getInstance().v1b(Unit_instance);
+  return Companion_getInstance().v1c(Unit_instance);
 }
 function trySendDropOldest($this, element) {
   var tmp4 = get_BUFFERED();
@@ -90,13 +90,13 @@ function trySendDropOldest($this, element) {
       var other_0 = get_SEGMENT_SIZE();
       var tmp$ret$3 = modulo(s, fromInt(other_0));
       var i = convertToInt(tmp$ret$3);
-      if (!equalsLong(segment.m12_1, id)) {
+      if (!equalsLong(segment.m13_1, id)) {
         var tmp0_elvis_lhs = access$findSegmentSend($this, id, segment);
         var tmp;
         if (tmp0_elvis_lhs == null) {
           var tmp_0;
           if (closed) {
-            return Companion_getInstance().o1c($this.p1b());
+            return Companion_getInstance().o1d($this.p1c());
           } else {
             continue $l$loop_0;
           }
@@ -107,14 +107,14 @@ function trySendDropOldest($this, element) {
       }
       switch (access$updateCellSend($this, segment, i, element, s, tmp4, closed)) {
         case 0:
-          segment.h1b();
-          return Companion_getInstance().v1b(Unit_instance);
+          segment.h1c();
+          return Companion_getInstance().v1c(Unit_instance);
         case 1:
-          return Companion_getInstance().v1b(Unit_instance);
+          return Companion_getInstance().v1c(Unit_instance);
         case 2:
           if (closed) {
-            segment.x1a();
-            return Companion_getInstance().o1c($this.p1b());
+            segment.x1b();
+            return Companion_getInstance().o1d($this.p1c());
           }
 
           var tmp2_safe_receiver = (!(tmp4 == null) ? isInterface(tmp4, Waiter()) : false) ? tmp4 : null;
@@ -124,7 +124,7 @@ function trySendDropOldest($this, element) {
             access$prepareSenderForSuspension($this, tmp2_safe_receiver, segment, i);
           }
 
-          var tmp0 = segment.m12_1;
+          var tmp0 = segment.m13_1;
           // Inline function 'kotlin.Long.times' call
 
           var other_1 = get_SEGMENT_SIZE();
@@ -132,16 +132,16 @@ function trySendDropOldest($this, element) {
 
           var this_0 = multiply(tmp0, fromInt(other_1));
           var tmp$ret$10 = add(this_0, fromInt(i));
-          $this.m1c(tmp$ret$10);
-          return Companion_getInstance().v1b(Unit_instance);
+          $this.m1d(tmp$ret$10);
+          return Companion_getInstance().v1c(Unit_instance);
         case 4:
-          if (compare(s, $this.q1b()) < 0) {
-            segment.h1b();
+          if (compare(s, $this.q1c()) < 0) {
+            segment.h1c();
           }
 
-          return Companion_getInstance().o1c($this.p1b());
+          return Companion_getInstance().o1d($this.p1c());
         case 5:
-          segment.h1b();
+          segment.h1c();
           continue $l$loop_0;
         case 3:
           // Inline function 'kotlin.error' call
@@ -160,42 +160,42 @@ function ConflatedBufferedChannel() {
       constructor(capacity, onBufferOverflow, onUndeliveredElement) {
         onUndeliveredElement = onUndeliveredElement === VOID ? null : onUndeliveredElement;
         super(capacity, onUndeliveredElement);
-        this.g1e_1 = capacity;
-        this.h1e_1 = onBufferOverflow;
+        this.g1f_1 = capacity;
+        this.h1f_1 = onBufferOverflow;
         // Inline function 'kotlin.require' call
-        if (!!(this.h1e_1 === BufferOverflow_SUSPEND_getInstance())) {
+        if (!!(this.h1f_1 === BufferOverflow_SUSPEND_getInstance())) {
           var message = 'This implementation does not support suspension for senders, use ' + getKClass(BufferedChannel()).f1() + ' instead';
           throw IllegalArgumentException().m2(toString(message));
         }
         // Inline function 'kotlin.require' call
-        if (!(this.g1e_1 >= 1)) {
-          var message_0 = 'Buffered channel capacity must be at least 1, but ' + this.g1e_1 + ' was specified';
+        if (!(this.g1f_1 >= 1)) {
+          var message_0 = 'Buffered channel capacity must be at least 1, but ' + this.g1f_1 + ' was specified';
           throw IllegalArgumentException().m2(toString(message_0));
         }
       }
-      n1c() {
-        return this.h1e_1.equals(BufferOverflow_DROP_OLDEST_getInstance());
+      n1d() {
+        return this.h1f_1.equals(BufferOverflow_DROP_OLDEST_getInstance());
       }
-      *s1c(element, $completion) {
+      *s1d(element, $completion) {
         // Inline function 'kotlinx.coroutines.channels.onClosed' call
         var this_0 = trySendImpl(this, element, true);
         var tmp = _ChannelResult___get_holder__impl__pm9gzw(this_0);
         if (tmp instanceof Closed()) {
           ChannelResult__exceptionOrNull_impl_16ei30(this_0);
-          var tmp0_safe_receiver = this.k1a_1;
+          var tmp0_safe_receiver = this.k1b_1;
           var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : callUndeliveredElementCatchingException(tmp0_safe_receiver, element);
           if (tmp1_safe_receiver == null)
             null;
           else {
             // Inline function 'kotlin.let' call
-            addSuppressed(tmp1_safe_receiver, this.p1b());
+            addSuppressed(tmp1_safe_receiver, this.p1c());
             throw tmp1_safe_receiver;
           }
-          throw this.p1b();
+          throw this.p1c();
         }
         return Unit_instance;
       }
-      t1c(element) {
+      t1d(element) {
         return trySendImpl(this, element, false);
       }
     }

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/channels/Produce.mjs

@@ -56,9 +56,9 @@ function produce_0(_this__u8e3s4, context, capacity, onBufferOverflow, start, on
   var newContext = newCoroutineContext(_this__u8e3s4, context);
   var coroutine = new (ProducerCoroutine())(newContext, channel);
   if (!(onCompletion == null)) {
-    coroutine.ey(onCompletion);
+    coroutine.ez(onCompletion);
   }
-  coroutine.px(start, coroutine, block);
+  coroutine.py(start, coroutine, block);
   return coroutine;
 }
 var ProducerCoroutineClass;
@@ -68,23 +68,23 @@ function ProducerCoroutine() {
       constructor(parentContext, channel) {
         super(parentContext, channel, true, true);
       }
-      cx() {
-        return super.cx();
+      cy() {
+        return super.cy();
       }
-      m1e(value) {
-        this.t1d_1.e1d();
+      m1f(value) {
+        this.t1e_1.e1e();
       }
-      dx(value) {
-        return this.m1e(value instanceof Unit() ? value : THROW_CCE());
+      dy(value) {
+        return this.m1f(value instanceof Unit() ? value : THROW_CCE());
       }
-      ex(cause, handled) {
-        var processed = this.t1d_1.c1d(cause);
+      ey(cause, handled) {
+        var processed = this.t1e_1.c1e(cause);
         if (!processed && !handled) {
-          handleCoroutineException(this.ax_1, cause);
+          handleCoroutineException(this.ay_1, cause);
         }
       }
-      g1d(cause, $super) {
-        return this.my(cause, ($super == null ? true : $super instanceof ProducerCoroutine()) ? $super : THROW_CCE());
+      g1e(cause, $super) {
+        return this.mz(cause, ($super == null ? true : $super instanceof ProducerCoroutine()) ? $super : THROW_CCE());
       }
     }
     initMetadataForClass($, 'ProducerCoroutine', VOID, VOID, [ProducerScope()], [1, 0]);
@@ -112,9 +112,9 @@ function *awaitClose(_this__u8e3s4, block, $completion) {
     (yield () => {
       var uCont = $completion;
       var cancellable = new (CancellableContinuationImpl())(intercepted(uCont), 1);
-      cancellable.r10();
-      _this__u8e3s4.h1d(awaitClose$lambda_0(cancellable));
-      return cancellable.s10();
+      cancellable.r11();
+      _this__u8e3s4.h1e(awaitClose$lambda_0(cancellable));
+      return cancellable.s11();
     });
   }finally {
     block();

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Builders.mjs

@@ -24,10 +24,10 @@ function SafeFlow() {
     class $ extends AbstractFlow() {
       constructor(block) {
         super();
-        this.n1e_1 = block;
+        this.n1f_1 = block;
       }
-      *o1e(collector, $completion) {
-        yield* this.n1e_1(collector, $completion);
+      *o1f(collector, $completion) {
+        yield* this.n1f_1(collector, $completion);
         return Unit_instance;
       }
     }
@@ -55,16 +55,16 @@ function ChannelFlowBuilder() {
         capacity = capacity === VOID ? -2 : capacity;
         onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
         super(context, capacity, onBufferOverflow);
-        this.t1e_1 = block;
+        this.t1f_1 = block;
       }
-      u1e(context, capacity, onBufferOverflow) {
-        return new (ChannelFlowBuilder())(this.t1e_1, context, capacity, onBufferOverflow);
+      u1f(context, capacity, onBufferOverflow) {
+        return new (ChannelFlowBuilder())(this.t1f_1, context, capacity, onBufferOverflow);
       }
-      *v1e(scope, $completion) {
-        return yield* this.t1e_1(scope, $completion);
+      *v1f(scope, $completion) {
+        return yield* this.t1f_1(scope, $completion);
       }
       toString() {
-        return 'block[' + toString(this.t1e_1) + '] -> ' + super.toString();
+        return 'block[' + toString(this.t1f_1) + '] -> ' + super.toString();
       }
     }
     initMetadataForClass($, 'ChannelFlowBuilder', VOID, VOID, VOID, [1]);
@@ -81,17 +81,17 @@ function CallbackFlowBuilder() {
         capacity = capacity === VOID ? -2 : capacity;
         onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
         super(block, context, capacity, onBufferOverflow);
-        this.j1f_1 = block;
+        this.j1g_1 = block;
       }
-      *v1e(scope, $completion) {
-        yield* super.v1e(scope, $completion);
-        if (!scope.l1c()) {
+      *v1f(scope, $completion) {
+        yield* super.v1f(scope, $completion);
+        if (!scope.l1d()) {
           throw IllegalStateException().o("'awaitClose { yourCallbackOrListener.cancel() }' should be used in the end of callbackFlow block.\nOtherwise, a callback/listener may leak in case of external cancellation.\nSee callbackFlow API documentation for the details.");
         }
         return Unit_instance;
       }
-      u1e(context, capacity, onBufferOverflow) {
-        return new (CallbackFlowBuilder())(this.j1f_1, context, capacity, onBufferOverflow);
+      u1f(context, capacity, onBufferOverflow) {
+        return new (CallbackFlowBuilder())(this.j1g_1, context, capacity, onBufferOverflow);
       }
     }
     initMetadataForClass($, 'CallbackFlowBuilder', VOID, VOID, VOID, [1]);
@@ -104,19 +104,19 @@ function asFlow$$inlined$unsafeFlow$1() {
   if (asFlow$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_asFlow) {
-        this.k1f_1 = $this_asFlow;
+        this.k1g_1 = $this_asFlow;
       }
-      *l1f(collector, $completion) {
+      *l1g(collector, $completion) {
         // Inline function 'kotlin.collections.forEach' call
-        var _iterator__ex2g4s = this.k1f_1.l1();
+        var _iterator__ex2g4s = this.k1g_1.l1();
         while (_iterator__ex2g4s.m1()) {
           var element = _iterator__ex2g4s.n1();
-          yield* collector.m1f(element, $completion);
+          yield* collector.m1g(element, $completion);
         }
         return Unit_instance;
       }
-      p1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1f(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
@@ -129,14 +129,14 @@ function flowOf$$inlined$unsafeFlow$1() {
   if (flowOf$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($value) {
-        this.n1f_1 = $value;
+        this.n1g_1 = $value;
       }
-      *l1f(collector, $completion) {
-        yield* collector.m1f(this.n1f_1, $completion);
+      *l1g(collector, $completion) {
+        yield* collector.m1g(this.n1g_1, $completion);
         return Unit_instance;
       }
-      p1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1f(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Channels.mjs

@@ -13,9 +13,9 @@ function *emitAllImpl(_this__u8e3s4, channel, consume, $completion) {
   var cause = null;
   try {
     var _iterator__ex2g4s = channel.l1();
-    while (yield* _iterator__ex2g4s.e1c($completion)) {
+    while (yield* _iterator__ex2g4s.e1d($completion)) {
       var element = _iterator__ex2g4s.n1();
-      yield* _this__u8e3s4.m1f(element, $completion);
+      yield* _this__u8e3s4.m1g(element, $completion);
     }
   } catch ($p) {
     if ($p instanceof Error) {

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Collect.mjs

@@ -6,11 +6,11 @@ import { Unit_instancev9v8hjid95df as Unit_instance } from '../../../../kotlin-k
 //region block: pre-declaration
 //endregion
 function *collect(_this__u8e3s4, $completion) {
-  return yield* _this__u8e3s4.p1e(NopCollector_instance, $completion);
+  return yield* _this__u8e3s4.p1f(NopCollector_instance, $completion);
 }
 function *emitAll(_this__u8e3s4, flow, $completion) {
   ensureActive(_this__u8e3s4);
-  yield* flow.p1e(_this__u8e3s4, $completion);
+  yield* flow.p1f(_this__u8e3s4, $completion);
   return Unit_instance;
 }
 //region block: exports

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Collection.mjs

@@ -22,7 +22,7 @@ function *toList(_this__u8e3s4, destination, $completion) {
 }
 function *toCollection(_this__u8e3s4, destination, $completion) {
   var tmp = toCollection$slambda_0(destination);
-  yield* _this__u8e3s4.p1e(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+  yield* _this__u8e3s4.p1f(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
   return destination;
 }
 var sam$kotlinx_coroutines_flow_FlowCollector$0Class;
@@ -30,13 +30,13 @@ function sam$kotlinx_coroutines_flow_FlowCollector$0() {
   if (sam$kotlinx_coroutines_flow_FlowCollector$0Class === VOID) {
     class $ {
       constructor(function_0) {
-        this.w1j_1 = function_0;
+        this.w1k_1 = function_0;
       }
-      *m1f(value, $completion) {
-        return yield* this.w1j_1(value, $completion);
+      *m1g(value, $completion) {
+        return yield* this.w1k_1(value, $completion);
       }
       c5() {
-        return this.w1j_1;
+        return this.w1k_1;
       }
       equals(other) {
         var tmp;
@@ -67,14 +67,14 @@ function toCollection$slambda() {
   if (toCollection$slambdaClass === VOID) {
     class $ {
       constructor($destination) {
-        this.x1j_1 = $destination;
+        this.x1k_1 = $destination;
       }
-      *j1i(value, $completion) {
-        this.x1j_1.o2(value);
+      *j1j(value, $completion) {
+        this.x1k_1.o2(value);
         return Unit_instance;
       }
       vd(p1, $completion) {
-        return this.j1i(p1, $completion);
+        return this.j1j(p1, $completion);
       }
     }
     initMetadataForLambda($, VOID, VOID, [1]);
@@ -84,7 +84,7 @@ function toCollection$slambda() {
 }
 function toCollection$slambda_0($destination) {
   var i = new (toCollection$slambda())($destination);
-  var l = (value, $completion) => i.j1i(value, $completion);
+  var l = (value, $completion) => i.j1j(value, $completion);
   l.$arity = 1;
   return l;
 }

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Context.mjs

@@ -36,7 +36,7 @@ function buffer(_this__u8e3s4, capacity, onBufferOverflow) {
   }
   var tmp;
   if (isInterface(_this__u8e3s4, FusibleFlow())) {
-    tmp = _this__u8e3s4.c1f(VOID, capacity_0, onBufferOverflow_0);
+    tmp = _this__u8e3s4.c1g(VOID, capacity_0, onBufferOverflow_0);
   } else {
     tmp = new (ChannelFlowOperatorImpl())(_this__u8e3s4, VOID, capacity_0, onBufferOverflow_0);
   }

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Emitters.mjs

@@ -33,13 +33,13 @@ function ThrowingCollector() {
   if (ThrowingCollectorClass === VOID) {
     class $ {
       constructor(e) {
-        this.x1i_1 = e;
+        this.x1j_1 = e;
       }
-      *v1i(value, $completion) {
-        throw this.x1i_1;
+      *v1j(value, $completion) {
+        throw this.x1j_1;
       }
-      m1f(value, $completion) {
-        return this.v1i(value, $completion);
+      m1g(value, $completion) {
+        return this.v1j(value, $completion);
       }
     }
     initMetadataForClass($, 'ThrowingCollector', VOID, VOID, [FlowCollector()], [1]);
@@ -49,23 +49,23 @@ function ThrowingCollector() {
 }
 function ensureActive(_this__u8e3s4) {
   if (_this__u8e3s4 instanceof ThrowingCollector())
-    throw _this__u8e3s4.x1i_1;
+    throw _this__u8e3s4.x1j_1;
 }
 var onCompletion$$inlined$unsafeFlow$1Class;
 function onCompletion$$inlined$unsafeFlow$1() {
   if (onCompletion$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_onCompletion, $action) {
-        this.y1i_1 = $this_onCompletion;
-        this.z1i_1 = $action;
+        this.y1j_1 = $this_onCompletion;
+        this.z1j_1 = $action;
       }
-      *l1f(collector, $completion) {
+      *l1g(collector, $completion) {
         try {
-          yield* this.y1i_1.p1e(collector, $completion);
+          yield* this.y1j_1.p1f(collector, $completion);
         } catch ($p) {
           if ($p instanceof Error) {
             var e = $p;
-            yield* /*#__NOINLINE__*/invokeSafely(new (ThrowingCollector())(e), this.z1i_1, e, $completion);
+            yield* /*#__NOINLINE__*/invokeSafely(new (ThrowingCollector())(e), this.z1j_1, e, $completion);
             throw e;
           } else {
             throw $p;
@@ -76,14 +76,14 @@ function onCompletion$$inlined$unsafeFlow$1() {
         var tmp$ret$1 = $completion.wc();
         var sc = new (SafeCollector())(collector, tmp$ret$1);
         try {
-          yield* this.z1i_1(sc, null, $completion);
+          yield* this.z1j_1(sc, null, $completion);
         }finally {
           sc.gd();
         }
         return Unit_instance;
       }
-      p1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1f(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Errors.mjs

@@ -32,7 +32,7 @@ function *catchImpl(_this__u8e3s4, collector, $completion) {
   var fromDownstream = {_v: null};
   try {
     var tmp = catchImpl$slambda_0(collector, fromDownstream);
-    yield* _this__u8e3s4.p1e(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+    yield* _this__u8e3s4.p1f(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
   } catch ($p) {
     if ($p instanceof Error) {
       var e = $p;
@@ -71,9 +71,9 @@ function isSameExceptionAs(_this__u8e3s4, other) {
 }
 function isCancellationCause(_this__u8e3s4, coroutineContext) {
   var job = coroutineContext.id(Key_instance);
-  if (job == null || !job.yx())
+  if (job == null || !job.yy())
     return false;
-  return isSameExceptionAs(_this__u8e3s4, job.by());
+  return isSameExceptionAs(_this__u8e3s4, job.bz());
 }
 function retryWhen(_this__u8e3s4, predicate) {
   // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
@@ -84,13 +84,13 @@ function sam$kotlinx_coroutines_flow_FlowCollector$0() {
   if (sam$kotlinx_coroutines_flow_FlowCollector$0Class === VOID) {
     class $ {
       constructor(function_0) {
-        this.a1j_1 = function_0;
+        this.a1k_1 = function_0;
       }
-      *m1f(value, $completion) {
-        return yield* this.a1j_1(value, $completion);
+      *m1g(value, $completion) {
+        return yield* this.a1k_1(value, $completion);
       }
       c5() {
-        return this.a1j_1;
+        return this.a1k_1;
       }
       equals(other) {
         var tmp;
@@ -121,17 +121,17 @@ function catch$$inlined$unsafeFlow$1() {
   if (catch$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_catch, $action) {
-        this.b1j_1 = $this_catch;
-        this.c1j_1 = $action;
+        this.b1k_1 = $this_catch;
+        this.c1k_1 = $action;
       }
-      *l1f(collector, $completion) {
-        var exception = yield* /*#__NOINLINE__*/catchImpl(this.b1j_1, collector, $completion);
+      *l1g(collector, $completion) {
+        var exception = yield* /*#__NOINLINE__*/catchImpl(this.b1k_1, collector, $completion);
         if (!(exception == null))
-          yield* this.c1j_1(collector, exception, $completion);
+          yield* this.c1k_1(collector, exception, $completion);
         return Unit_instance;
       }
-      p1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1f(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
@@ -144,16 +144,16 @@ function catchImpl$slambda() {
   if (catchImpl$slambdaClass === VOID) {
     class $ {
       constructor($collector, $fromDownstream) {
-        this.d1j_1 = $collector;
-        this.e1j_1 = $fromDownstream;
+        this.d1k_1 = $collector;
+        this.e1k_1 = $fromDownstream;
       }
-      *j1i(it, $completion) {
+      *j1j(it, $completion) {
         try {
-          yield* this.d1j_1.m1f(it, $completion);
+          yield* this.d1k_1.m1g(it, $completion);
         } catch ($p) {
           if ($p instanceof Error) {
             var e = $p;
-            this.e1j_1._v = e;
+            this.e1k_1._v = e;
             throw e;
           } else {
             throw $p;
@@ -162,7 +162,7 @@ function catchImpl$slambda() {
         return Unit_instance;
       }
       vd(p1, $completion) {
-        return this.j1i(p1, $completion);
+        return this.j1j(p1, $completion);
       }
     }
     initMetadataForLambda($, VOID, VOID, [1]);
@@ -172,7 +172,7 @@ function catchImpl$slambda() {
 }
 function catchImpl$slambda_0($collector, $fromDownstream) {
   var i = new (catchImpl$slambda())($collector, $fromDownstream);
-  var l = (it, $completion) => i.j1i(it, $completion);
+  var l = (it, $completion) => i.j1j(it, $completion);
   l.$arity = 1;
   return l;
 }
@@ -181,17 +181,17 @@ function retryWhen$$inlined$unsafeFlow$1() {
   if (retryWhen$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_retryWhen, $predicate) {
-        this.f1j_1 = $this_retryWhen;
-        this.g1j_1 = $predicate;
+        this.f1k_1 = $this_retryWhen;
+        this.g1k_1 = $predicate;
       }
-      *l1f(collector, $completion) {
+      *l1g(collector, $completion) {
         var attempt = new (Long())(0, 0);
         var shallRetry;
         do {
           shallRetry = false;
-          var cause = yield* /*#__NOINLINE__*/catchImpl(this.f1j_1, collector, $completion);
+          var cause = yield* /*#__NOINLINE__*/catchImpl(this.f1k_1, collector, $completion);
           if (!(cause == null)) {
-            if (yield* this.g1j_1(collector, cause, attempt, $completion)) {
+            if (yield* this.g1k_1(collector, cause, attempt, $completion)) {
               shallRetry = true;
               var _unary__edvuaz = attempt;
               attempt = add(_unary__edvuaz, get_ONE());
@@ -203,8 +203,8 @@ function retryWhen$$inlined$unsafeFlow$1() {
          while (shallRetry);
         return Unit_instance;
       }
-      p1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1f(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);

package/kotlin/kotlinx-coroutines-core/kotlinx/coroutines/flow/Flow.mjs

@@ -10,12 +10,12 @@ var AbstractFlowClass;
 function AbstractFlow() {
   if (AbstractFlowClass === VOID) {
     class $ {
-      *p1e(collector, $completion) {
+      *p1f(collector, $completion) {
         // Inline function 'kotlin.js.getCoroutineContext' call
         var tmp$ret$0 = $completion.wc();
         var safeCollector = new (SafeCollector())(collector, tmp$ret$0);
         try {
-          yield* this.o1e(safeCollector, $completion);
+          yield* this.o1f(safeCollector, $completion);
         }finally {
           safeCollector.gd();
         }