@continuous-excellence/coupling-cli 1.1.509 → 1.1.511

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

@@ -23,10 +23,10 @@ function SafeFlow() {
     class $ extends AbstractFlow() {
       constructor(block) {
         super();
-        this.s1e_1 = block;
+        this.n1e_1 = block;
       }
-      *t1e(collector, $completion) {
-        yield* this.s1e_1(collector, $completion);
+      *o1e(collector, $completion) {
+        yield* this.n1e_1(collector, $completion);
         return Unit_instance;
       }
     }
@@ -51,16 +51,16 @@ function ChannelFlowBuilder() {
         capacity = capacity === VOID ? -2 : capacity;
         onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
         super(context, capacity, onBufferOverflow);
-        this.y1e_1 = block;
+        this.t1e_1 = block;
       }
-      z1e(context, capacity, onBufferOverflow) {
-        return new (ChannelFlowBuilder())(this.y1e_1, context, capacity, onBufferOverflow);
+      u1e(context, capacity, onBufferOverflow) {
+        return new (ChannelFlowBuilder())(this.t1e_1, context, capacity, onBufferOverflow);
       }
-      *a1f(scope, $completion) {
-        return yield* this.y1e_1(scope, $completion);
+      *v1e(scope, $completion) {
+        return yield* this.t1e_1(scope, $completion);
       }
       toString() {
-        return 'block[' + toString(this.y1e_1) + '] -> ' + super.toString();
+        return 'block[' + toString(this.t1e_1) + '] -> ' + super.toString();
       }
     }
     initMetadataForClass($, 'ChannelFlowBuilder', VOID, VOID, VOID, [1]);
@@ -73,19 +73,19 @@ function asFlow$$inlined$unsafeFlow$1() {
   if (asFlow$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_asFlow) {
-        this.k1f_1 = $this_asFlow;
+        this.f1f_1 = $this_asFlow;
       }
-      *l1f(collector, $completion) {
+      *g1f(collector, $completion) {
         // Inline function 'kotlin.collections.forEach' call
-        var _iterator__ex2g4s = this.k1f_1.l1();
+        var _iterator__ex2g4s = this.f1f_1.l1();
         while (_iterator__ex2g4s.m1()) {
           var element = _iterator__ex2g4s.n1();
-          yield* collector.m1f(element, $completion);
+          yield* collector.h1f(element, $completion);
         }
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
@@ -98,14 +98,14 @@ function flowOf$$inlined$unsafeFlow$1() {
   if (flowOf$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($value) {
-        this.n1f_1 = $value;
+        this.i1f_1 = $value;
       }
-      *l1f(collector, $completion) {
-        yield* collector.m1f(this.n1f_1, $completion);
+      *g1f(collector, $completion) {
+        yield* collector.h1f(this.i1f_1, $completion);
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(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.j1c($completion)) {
+    while (yield* _iterator__ex2g4s.e1c($completion)) {
       var element = _iterator__ex2g4s.n1();
-      yield* _this__u8e3s4.m1f(element, $completion);
+      yield* _this__u8e3s4.h1f(element, $completion);
     }
   } catch ($p) {
     if ($p instanceof Error) {

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

@@ -7,11 +7,11 @@ import { NopCollector_instance46vt84er03h7 as NopCollector_instance } from './in
 //endregion
 function *emitAll(_this__u8e3s4, flow, $completion) {
   ensureActive(_this__u8e3s4);
-  yield* flow.u1e(_this__u8e3s4, $completion);
+  yield* flow.p1e(_this__u8e3s4, $completion);
   return Unit_instance;
 }
 function *collect(_this__u8e3s4, $completion) {
-  return yield* _this__u8e3s4.u1e(NopCollector_instance, $completion);
+  return yield* _this__u8e3s4.p1e(NopCollector_instance, $completion);
 }
 //region block: exports
 export {

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.u1e(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+  yield* _this__u8e3s4.p1e(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.r1j_1 = function_0;
       }
-      *m1f(value, $completion) {
-        return yield* this.w1j_1(value, $completion);
+      *h1f(value, $completion) {
+        return yield* this.r1j_1(value, $completion);
       }
       c5() {
-        return this.w1j_1;
+        return this.r1j_1;
       }
       equals(other) {
         var tmp;
@@ -67,14 +67,14 @@ function toCollection$slambda() {
   if (toCollection$slambdaClass === VOID) {
     class $ {
       constructor($destination) {
-        this.x1j_1 = $destination;
+        this.s1j_1 = $destination;
       }
-      *j1i(value, $completion) {
-        this.x1j_1.o2(value);
+      *e1i(value, $completion) {
+        this.s1j_1.o2(value);
         return Unit_instance;
       }
       vd(p1, $completion) {
-        return this.j1i(p1, $completion);
+        return this.e1i(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.e1i(value, $completion);
   l.$arity = 1;
   return l;
 }

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

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

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.s1i_1 = e;
       }
-      *v1i(value, $completion) {
-        throw this.x1i_1;
+      *q1i(value, $completion) {
+        throw this.s1i_1;
       }
-      m1f(value, $completion) {
-        return this.v1i(value, $completion);
+      h1f(value, $completion) {
+        return this.q1i(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.s1i_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.t1i_1 = $this_onCompletion;
+        this.u1i_1 = $action;
       }
-      *l1f(collector, $completion) {
+      *g1f(collector, $completion) {
         try {
-          yield* this.y1i_1.u1e(collector, $completion);
+          yield* this.t1i_1.p1e(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.u1i_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.u1i_1(sc, null, $completion);
         }finally {
           sc.gd();
         }
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(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.u1e(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
+    yield* _this__u8e3s4.p1e(new (sam$kotlinx_coroutines_flow_FlowCollector$0())(tmp), $completion);
   } catch ($p) {
     if ($p instanceof Error) {
       var e = $p;
@@ -70,9 +70,9 @@ function isSameExceptionAs(_this__u8e3s4, other) {
 }
 function isCancellationCause(_this__u8e3s4, coroutineContext) {
   var job = coroutineContext.id(Key_instance);
-  if (job == null || !job.dy())
+  if (job == null || !job.yx())
     return false;
-  return isSameExceptionAs(_this__u8e3s4, job.gy());
+  return isSameExceptionAs(_this__u8e3s4, job.by());
 }
 function retryWhen(_this__u8e3s4, predicate) {
   // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
@@ -83,13 +83,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.v1i_1 = function_0;
       }
-      *m1f(value, $completion) {
-        return yield* this.a1j_1(value, $completion);
+      *h1f(value, $completion) {
+        return yield* this.v1i_1(value, $completion);
       }
       c5() {
-        return this.a1j_1;
+        return this.v1i_1;
       }
       equals(other) {
         var tmp;
@@ -120,17 +120,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.w1i_1 = $this_catch;
+        this.x1i_1 = $action;
       }
-      *l1f(collector, $completion) {
-        var exception = yield* /*#__NOINLINE__*/catchImpl(this.b1j_1, collector, $completion);
+      *g1f(collector, $completion) {
+        var exception = yield* /*#__NOINLINE__*/catchImpl(this.w1i_1, collector, $completion);
         if (!(exception == null))
-          yield* this.c1j_1(collector, exception, $completion);
+          yield* this.x1i_1(collector, exception, $completion);
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
@@ -143,16 +143,16 @@ function catchImpl$slambda() {
   if (catchImpl$slambdaClass === VOID) {
     class $ {
       constructor($collector, $fromDownstream) {
-        this.d1j_1 = $collector;
-        this.e1j_1 = $fromDownstream;
+        this.y1i_1 = $collector;
+        this.z1i_1 = $fromDownstream;
       }
-      *j1i(it, $completion) {
+      *e1i(it, $completion) {
         try {
-          yield* this.d1j_1.m1f(it, $completion);
+          yield* this.y1i_1.h1f(it, $completion);
         } catch ($p) {
           if ($p instanceof Error) {
             var e = $p;
-            this.e1j_1._v = e;
+            this.z1i_1._v = e;
             throw e;
           } else {
             throw $p;
@@ -161,7 +161,7 @@ function catchImpl$slambda() {
         return Unit_instance;
       }
       vd(p1, $completion) {
-        return this.j1i(p1, $completion);
+        return this.e1i(p1, $completion);
       }
     }
     initMetadataForLambda($, VOID, VOID, [1]);
@@ -171,7 +171,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.e1i(it, $completion);
   l.$arity = 1;
   return l;
 }
@@ -180,17 +180,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.a1j_1 = $this_retryWhen;
+        this.b1j_1 = $predicate;
       }
-      *l1f(collector, $completion) {
+      *g1f(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.a1j_1, collector, $completion);
           if (!(cause == null)) {
-            if (yield* this.g1j_1(collector, cause, attempt, $completion)) {
+            if (yield* this.b1j_1(collector, cause, attempt, $completion)) {
               shallRetry = true;
               var _unary__edvuaz = attempt;
               attempt = add(_unary__edvuaz, get_ONE());
@@ -202,8 +202,8 @@ function retryWhen$$inlined$unsafeFlow$1() {
          while (shallRetry);
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(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 $ {
-      *u1e(collector, $completion) {
+      *p1e(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.t1e(safeCollector, $completion);
+          yield* this.o1e(safeCollector, $completion);
         }finally {
           safeCollector.gd();
         }

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

@@ -18,24 +18,24 @@ function takeWhile$$inlined$unsafeFlow$1$collect$2() {
   if (takeWhile$$inlined$unsafeFlow$1$collect$2Class === VOID) {
     class $ {
       constructor($predicate, $$this$flow) {
-        this.h1j_1 = $predicate;
-        this.i1j_1 = $$this$flow;
+        this.c1j_1 = $predicate;
+        this.d1j_1 = $$this$flow;
       }
-      *v1i(value, $completion) {
+      *q1i(value, $completion) {
         var tmp;
-        if (yield* this.h1j_1(value, $completion)) {
-          yield* this.i1j_1.m1f(value, $completion);
+        if (yield* this.c1j_1(value, $completion)) {
+          yield* this.d1j_1.h1f(value, $completion);
           tmp = true;
         } else {
           tmp = false;
         }
         if (!tmp) {
-          throw AbortFlowException().j1j(this);
+          throw AbortFlowException().e1j(this);
         }
         return Unit_instance;
       }
-      m1f(value, $completion) {
-        return this.v1i(value, $completion);
+      h1f(value, $completion) {
+        return this.q1i(value, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, [FlowCollector()], [1]);
@@ -48,15 +48,15 @@ function takeWhile$$inlined$unsafeFlow$1() {
   if (takeWhile$$inlined$unsafeFlow$1Class === VOID) {
     class $ {
       constructor($this_takeWhile, $predicate) {
-        this.k1j_1 = $this_takeWhile;
-        this.l1j_1 = $predicate;
+        this.f1j_1 = $this_takeWhile;
+        this.g1j_1 = $predicate;
       }
-      *l1f(collector, $completion) {
+      *g1f(collector, $completion) {
         // Inline function 'kotlinx.coroutines.flow.collectWhile' call
-        var this_0 = this.k1j_1;
-        var collector_0 = new (takeWhile$$inlined$unsafeFlow$1$collect$2())(this.l1j_1, collector);
+        var this_0 = this.f1j_1;
+        var collector_0 = new (takeWhile$$inlined$unsafeFlow$1$collect$2())(this.g1j_1, collector);
         try {
-          yield* this_0.u1e(collector_0, $completion);
+          yield* this_0.p1e(collector_0, $completion);
         } catch ($p) {
           if ($p instanceof AbortFlowException()) {
             var e = $p;
@@ -70,8 +70,8 @@ function takeWhile$$inlined$unsafeFlow$1() {
         }
         return Unit_instance;
       }
-      u1e(collector, $completion) {
-        return this.l1f(collector, $completion);
+      p1e(collector, $completion) {
+        return this.g1f(collector, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);

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

@@ -14,7 +14,7 @@ function *firstOrNull(_this__u8e3s4, predicate, $completion) {
   // Inline function 'kotlinx.coroutines.flow.collectWhile' call
   var collector = new (firstOrNull$$inlined$collectWhile$1())(predicate, result);
   try {
-    yield* _this__u8e3s4.u1e(collector, $completion);
+    yield* _this__u8e3s4.p1e(collector, $completion);
   } catch ($p) {
     if ($p instanceof AbortFlowException()) {
       var e = $p;
@@ -33,24 +33,24 @@ function firstOrNull$$inlined$collectWhile$1() {
   if (firstOrNull$$inlined$collectWhile$1Class === VOID) {
     class $ {
       constructor($predicate, $result) {
-        this.y1j_1 = $predicate;
-        this.z1j_1 = $result;
+        this.t1j_1 = $predicate;
+        this.u1j_1 = $result;
       }
-      *v1i(value, $completion) {
+      *q1i(value, $completion) {
         var tmp;
-        if (yield* this.y1j_1(value, $completion)) {
-          this.z1j_1._v = value;
+        if (yield* this.t1j_1(value, $completion)) {
+          this.u1j_1._v = value;
           tmp = false;
         } else {
           tmp = true;
         }
         if (!tmp) {
-          throw AbortFlowException().j1j(this);
+          throw AbortFlowException().e1j(this);
         }
         return Unit_instance;
       }
-      m1f(value, $completion) {
-        return this.v1i(value, $completion);
+      h1f(value, $completion) {
+        return this.q1i(value, $completion);
       }
     }
     initMetadataForClass($, VOID, VOID, VOID, [FlowCollector()], [1]);

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

@@ -25,26 +25,26 @@ function SubscribedFlowCollector() {
   if (SubscribedFlowCollectorClass === VOID) {
     class $ {
       constructor(collector, action) {
-        this.s1g_1 = collector;
-        this.t1g_1 = action;
+        this.n1g_1 = collector;
+        this.o1g_1 = action;
       }
-      *u1g($completion) {
+      *p1g($completion) {
         // Inline function 'kotlinx.coroutines.currentCoroutineContext' call
         // Inline function 'kotlin.js.getCoroutineContext' call
         var tmp$ret$0 = $completion.wc();
-        var safeCollector = new (SafeCollector())(this.s1g_1, tmp$ret$0);
+        var safeCollector = new (SafeCollector())(this.n1g_1, tmp$ret$0);
         try {
-          yield* this.t1g_1(safeCollector, $completion);
+          yield* this.o1g_1(safeCollector, $completion);
         }finally {
           safeCollector.gd();
         }
-        var tmp = this.s1g_1;
+        var tmp = this.n1g_1;
         if (tmp instanceof SubscribedFlowCollector())
-          yield* this.s1g_1.u1g($completion);
+          yield* this.n1g_1.p1g($completion);
         return Unit_instance;
       }
-      *m1f(value, $completion) {
-        yield* this.s1g_1.m1f(value, $completion);
+      *h1f(value, $completion) {
+        yield* this.n1g_1.h1f(value, $completion);
         return Unit_instance;
       }
     }
@@ -58,21 +58,21 @@ function ReadonlySharedFlow() {
   if (ReadonlySharedFlowClass === VOID) {
     class $ {
       constructor(flow, job) {
-        this.m1j_1 = flow;
-        this.n1j_1 = job;
+        this.h1j_1 = flow;
+        this.i1j_1 = job;
       }
-      g1f(context, capacity, onBufferOverflow) {
+      b1f(context, capacity, onBufferOverflow) {
         return fuseSharedFlow(this, context, capacity, onBufferOverflow);
       }
-      *q1g(collector, $completion) {
-        yield* this.m1j_1.q1g(collector, $completion);
+      *l1g(collector, $completion) {
+        yield* this.h1j_1.l1g(collector, $completion);
         throwKotlinNothingValueException();
       }
-      u1e(collector, $completion) {
-        return this.q1g(collector, $completion);
+      p1e(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
-    protoOf($).h1f = fuse$default;
+    protoOf($).c1f = fuse$default;
     initMetadataForClass($, 'ReadonlySharedFlow', VOID, VOID, [FusibleFlow()], [1]);
     ReadonlySharedFlowClass = $;
   }
@@ -83,15 +83,15 @@ function SubscribedSharedFlow() {
   if (SubscribedSharedFlowClass === VOID) {
     class $ {
       constructor(sharedFlow, action) {
-        this.o1j_1 = sharedFlow;
-        this.p1j_1 = action;
+        this.j1j_1 = sharedFlow;
+        this.k1j_1 = action;
       }
-      *q1g(collector, $completion) {
-        yield* this.o1j_1.q1g(new (SubscribedFlowCollector())(collector, this.p1j_1), $completion);
+      *l1g(collector, $completion) {
+        yield* this.j1j_1.l1g(new (SubscribedFlowCollector())(collector, this.k1j_1), $completion);
         return throwKotlinNothingValueException();
       }
-      u1e(collector, $completion) {
-        return this.q1g(collector, $completion);
+      p1e(collector, $completion) {
+        return this.l1g(collector, $completion);
       }
     }
     initMetadataForClass($, 'SubscribedSharedFlow', VOID, VOID, VOID, [1]);