@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,800 @@
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { BufferOverflow_SUSPEND_getInstance31wn3v83onf3w as BufferOverflow_SUSPEND_getInstance } from '../channels/BufferOverflow.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  toString1pkumu07cwy4m as toString,
+  equals2au1ep9vhcato as equals,
+  protoOf180f3jzyo7rfj as protoOf,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  compare2uud5j30pw5xc as compare,
+  fromInt1lka3ktyu79a4 as fromInt,
+  add85si75olwt6n as add,
+  subtract16cg4lfi29fq9 as subtract,
+  convertToIntofdoxh9bstof as convertToInt,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { SubscribedFlowCollector17ch8by19noql as SubscribedFlowCollector } from './Share.mjs';
+import {
+  Key_instance17dpgmdbeabno as Key_instance,
+  ensureActive159jflbg22qd8 as ensureActive,
+} from '../Job.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import {
+  intercepted2ogpsikxxj4u0 as intercepted,
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { CancellableContinuationImpl1cx201opicavg as CancellableContinuationImpl } from '../CancellableContinuationImpl.mjs';
+import {
+  get_EMPTY_RESUMES1se3895plb5u1 as get_EMPTY_RESUMES,
+  AbstractSharedFlow1jjql04jld86z as AbstractSharedFlow,
+  AbstractSharedFlowSlot2hcw2f06t03o0 as AbstractSharedFlowSlot,
+} from './internal/AbstractSharedFlow.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { disposeOnCancellation302lv5bib5mna as disposeOnCancellation } from '../CancellableContinuation.mjs';
+import { copyOf2ng0t8oizk6it as copyOf } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import {
+  fuse$default193jw8jxgbygs as fuse$default,
+  FusibleFlow2tgh9s2p1kryd as FusibleFlow,
+  ChannelFlowOperatorImpl3gjkp847e0ebc as ChannelFlowOperatorImpl,
+} from './internal/ChannelFlow.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from './FlowCollector.mjs';
+import { Symbol17xuwzgi5g8ve as Symbol } from '../internal/Symbol.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function get_NO_VALUE() {
+  _init_properties_SharedFlow_kt__umasnn();
+  return NO_VALUE;
+}
+var NO_VALUE;
+function MutableSharedFlow(replay, extraBufferCapacity, onBufferOverflow) {
+  replay = replay === VOID ? 0 : replay;
+  extraBufferCapacity = extraBufferCapacity === VOID ? 0 : extraBufferCapacity;
+  onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
+  _init_properties_SharedFlow_kt__umasnn();
+  // Inline function 'kotlin.require' call
+  if (!(replay >= 0)) {
+    var message = 'replay cannot be negative, but was ' + replay;
+    throw IllegalArgumentException().r2(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(extraBufferCapacity >= 0)) {
+    var message_0 = 'extraBufferCapacity cannot be negative, but was ' + extraBufferCapacity;
+    throw IllegalArgumentException().r2(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(replay > 0 || extraBufferCapacity > 0 || onBufferOverflow.equals(BufferOverflow_SUSPEND_getInstance()))) {
+    var message_1 = 'replay or extraBufferCapacity must be positive with non-default onBufferOverflow strategy ' + onBufferOverflow.toString();
+    throw IllegalArgumentException().r2(toString(message_1));
+  }
+  var bufferCapacity0 = replay + extraBufferCapacity | 0;
+  var bufferCapacity = bufferCapacity0 < 0 ? 2147483647 : bufferCapacity0;
+  return new (SharedFlowImpl())(replay, bufferCapacity, onBufferOverflow);
+}
+function _get_head__d7jo8b($this) {
+  var tmp0 = $this.f1f_1;
+  // Inline function 'kotlin.comparisons.minOf' call
+  var b = $this.e1f_1;
+  return compare(tmp0, b) <= 0 ? tmp0 : b;
+}
+function _get_replaySize__dxgnb1($this) {
+  var tmp0 = _get_head__d7jo8b($this);
+  // Inline function 'kotlin.Long.plus' call
+  var other = $this.g1f_1;
+  var tmp$ret$0 = add(tmp0, fromInt(other));
+  return convertToInt(subtract(tmp$ret$0, $this.e1f_1));
+}
+function _get_totalSize__xhdb3o($this) {
+  return $this.g1f_1 + $this.h1f_1 | 0;
+}
+function _get_bufferEndIndex__d2rk18($this) {
+  var tmp0 = _get_head__d7jo8b($this);
+  // Inline function 'kotlin.Long.plus' call
+  var other = $this.g1f_1;
+  return add(tmp0, fromInt(other));
+}
+function _get_queueEndIndex__4m025l($this) {
+  var tmp0 = _get_head__d7jo8b($this);
+  // Inline function 'kotlin.Long.plus' call
+  var other = $this.g1f_1;
+  var tmp0_0 = add(tmp0, fromInt(other));
+  // Inline function 'kotlin.Long.plus' call
+  var other_0 = $this.h1f_1;
+  return add(tmp0_0, fromInt(other_0));
+}
+function *_generator_collect__dlomyy($this, collector, $completion) {
+  var slot = $this.m1f();
+  try {
+    if (collector instanceof SubscribedFlowCollector()) {
+      var tmp = collector.p1f($completion);
+      if (tmp === get_COROUTINE_SUSPENDED())
+        tmp = yield tmp;
+    }
+    // Inline function 'kotlinx.coroutines.currentCoroutineContext' call
+    // Inline function 'kotlin.js.getCoroutineContext' call
+    var collectorJob = $completion.bd().rd(Key_instance);
+    while (true) {
+      var newValue;
+      $l$loop: while (true) {
+        newValue = tryTakeValue($this, slot);
+        if (!(newValue === get_NO_VALUE()))
+          break $l$loop;
+        var tmp_0 = awaitValue($this, slot, $completion);
+        if (tmp_0 === get_COROUTINE_SUSPENDED())
+          tmp_0 = yield tmp_0;
+      }
+      if (collectorJob == null)
+        null;
+      else {
+        ensureActive(collectorJob);
+      }
+      var tmp_1 = collector.p1e((newValue == null ? true : !(newValue == null)) ? newValue : THROW_CCE(), $completion);
+      if (tmp_1 === get_COROUTINE_SUSPENDED())
+        tmp_1 = yield tmp_1;
+    }
+  }finally {
+    $this.q1f(slot);
+  }
+}
+function *_generator_emit__qph46j($this, value, $completion) {
+  if ($this.r1f(value))
+    return Unit_instance;
+  var tmp = emitSuspend($this, value, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function tryEmitLocked($this, value) {
+  if ($this.j1f_1 === 0)
+    return tryEmitNoCollectorsLocked($this, value);
+  if ($this.g1f_1 >= $this.b1f_1 && compare($this.f1f_1, $this.e1f_1) <= 0) {
+    switch ($this.c1f_1.x1_1) {
+      case 0:
+        return false;
+      case 2:
+        return true;
+      case 1:
+        break;
+      default:
+        noWhenBranchMatchedException();
+        break;
+    }
+  }
+  enqueueLocked($this, value);
+  $this.g1f_1 = $this.g1f_1 + 1 | 0;
+  if ($this.g1f_1 > $this.b1f_1) {
+    dropOldestLocked($this);
+  }
+  if (_get_replaySize__dxgnb1($this) > $this.a1f_1) {
+    // Inline function 'kotlin.Long.plus' call
+    var this_0 = $this.e1f_1;
+    var tmp$ret$0 = add(this_0, fromInt(1));
+    updateBufferLocked($this, tmp$ret$0, $this.f1f_1, _get_bufferEndIndex__d2rk18($this), _get_queueEndIndex__4m025l($this));
+  }
+  return true;
+}
+function tryEmitNoCollectorsLocked($this, value) {
+  // Inline function 'kotlinx.coroutines.assert' call
+  if ($this.a1f_1 === 0)
+    return true;
+  enqueueLocked($this, value);
+  $this.g1f_1 = $this.g1f_1 + 1 | 0;
+  if ($this.g1f_1 > $this.a1f_1) {
+    dropOldestLocked($this);
+  }
+  var tmp = $this;
+  var tmp0 = _get_head__d7jo8b($this);
+  // Inline function 'kotlin.Long.plus' call
+  var other = $this.g1f_1;
+  tmp.f1f_1 = add(tmp0, fromInt(other));
+  return true;
+}
+function dropOldestLocked($this) {
+  setBufferAt(ensureNotNull($this.d1f_1), _get_head__d7jo8b($this), null);
+  $this.g1f_1 = $this.g1f_1 - 1 | 0;
+  // Inline function 'kotlin.Long.plus' call
+  var this_0 = _get_head__d7jo8b($this);
+  var newHead = add(this_0, fromInt(1));
+  if (compare($this.e1f_1, newHead) < 0)
+    $this.e1f_1 = newHead;
+  if (compare($this.f1f_1, newHead) < 0) {
+    correctCollectorIndexesOnDropOldest($this, newHead);
+  }
+  // Inline function 'kotlinx.coroutines.assert' call
+}
+function correctCollectorIndexesOnDropOldest($this, newHead) {
+  $l$block: {
+    // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
+    if ($this.j1f_1 === 0) {
+      break $l$block;
+    }
+    var tmp0_safe_receiver = $this.i1f_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.collections.forEach' call
+      var inductionVariable = 0;
+      var last = tmp0_safe_receiver.length;
+      while (inductionVariable < last) {
+        var element = tmp0_safe_receiver[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        if (!(element == null)) {
+          if (compare(element.s1f_1, new (Long())(0, 0)) >= 0 && compare(element.s1f_1, newHead) < 0) {
+            element.s1f_1 = newHead;
+          }
+        }
+      }
+    }
+  }
+  $this.f1f_1 = newHead;
+}
+function enqueueLocked($this, item) {
+  var curSize = _get_totalSize__xhdb3o($this);
+  var curBuffer = $this.d1f_1;
+  var buffer = curBuffer == null ? growBuffer($this, null, 0, 2) : curSize >= curBuffer.length ? growBuffer($this, curBuffer, curSize, imul(curBuffer.length, 2)) : curBuffer;
+  // Inline function 'kotlin.Long.plus' call
+  var this_0 = _get_head__d7jo8b($this);
+  var tmp$ret$0 = add(this_0, fromInt(curSize));
+  setBufferAt(buffer, tmp$ret$0, item);
+}
+function growBuffer($this, curBuffer, curSize, newSize) {
+  // Inline function 'kotlin.check' call
+  if (!(newSize > 0)) {
+    var message = 'Buffer size overflow';
+    throw IllegalStateException().o(toString(message));
+  }
+  // Inline function 'kotlin.arrayOfNulls' call
+  // Inline function 'kotlin.also' call
+  var this_0 = Array(newSize);
+  $this.d1f_1 = this_0;
+  var newBuffer = this_0;
+  if (curBuffer == null)
+    return newBuffer;
+  var head = _get_head__d7jo8b($this);
+  var inductionVariable = 0;
+  if (inductionVariable < curSize)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.Long.plus' call
+      var tmp = add(head, fromInt(i));
+      // Inline function 'kotlin.Long.plus' call
+      var tmp$ret$6 = add(head, fromInt(i));
+      setBufferAt(newBuffer, tmp, getBufferAt(curBuffer, tmp$ret$6));
+    }
+     while (inductionVariable < curSize);
+  return newBuffer;
+}
+function emitSuspend($this, value, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.zz();
+  var resumes = get_EMPTY_RESUMES();
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  var tmp$ret$2;
+  $l$block: {
+    if (tryEmitLocked($this, value)) {
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+      cancellable.dd(tmp$ret$0);
+      resumes = findSlotsToResumeLocked($this, resumes);
+      tmp$ret$2 = null;
+      break $l$block;
+    }
+    var tmp0 = _get_head__d7jo8b($this);
+    // Inline function 'kotlin.Long.plus' call
+    var other = _get_totalSize__xhdb3o($this);
+    var tmp$ret$3 = add(tmp0, fromInt(other));
+    // Inline function 'kotlin.also' call
+    var this_0 = new (Emitter())($this, tmp$ret$3, value, cancellable);
+    enqueueLocked($this, this_0);
+    $this.h1f_1 = $this.h1f_1 + 1 | 0;
+    if ($this.b1f_1 === 0)
+      resumes = findSlotsToResumeLocked($this, resumes);
+    tmp$ret$2 = this_0;
+  }
+  var emitter = tmp$ret$2;
+  if (emitter == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    disposeOnCancellation(cancellable, emitter);
+  }
+  var indexedObject = resumes;
+  var inductionVariable = 0;
+  var last = indexedObject.length;
+  while (inductionVariable < last) {
+    var r = indexedObject[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    if (r == null)
+      null;
+    else {
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var tmp$ret$10 = _Result___init__impl__xyqfz8(Unit_instance);
+      r.dd(tmp$ret$10);
+    }
+  }
+  return cancellable.a10();
+}
+function cancelEmitter($this, emitter) {
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  if (compare(emitter.v1f_1, _get_head__d7jo8b($this)) < 0)
+    return Unit_instance;
+  var buffer = ensureNotNull($this.d1f_1);
+  if (!(getBufferAt(buffer, emitter.v1f_1) === emitter))
+    return Unit_instance;
+  setBufferAt(buffer, emitter.v1f_1, get_NO_VALUE());
+  cleanupTailLocked($this);
+  return Unit_instance;
+}
+function updateBufferLocked($this, newReplayIndex, newMinCollectorIndex, newBufferEndIndex, newQueueEndIndex) {
+  // Inline function 'kotlin.comparisons.minOf' call
+  var newHead = compare(newMinCollectorIndex, newReplayIndex) <= 0 ? newMinCollectorIndex : newReplayIndex;
+  // Inline function 'kotlinx.coroutines.assert' call
+  var inductionVariable = _get_head__d7jo8b($this);
+  if (compare(inductionVariable, newHead) < 0)
+    do {
+      var index = inductionVariable;
+      inductionVariable = add(inductionVariable, new (Long())(1, 0));
+      setBufferAt(ensureNotNull($this.d1f_1), index, null);
+    }
+     while (compare(inductionVariable, newHead) < 0);
+  $this.e1f_1 = newReplayIndex;
+  $this.f1f_1 = newMinCollectorIndex;
+  $this.g1f_1 = convertToInt(subtract(newBufferEndIndex, newHead));
+  $this.h1f_1 = convertToInt(subtract(newQueueEndIndex, newBufferEndIndex));
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+  // Inline function 'kotlinx.coroutines.assert' call
+}
+function cleanupTailLocked($this) {
+  if ($this.b1f_1 === 0 && $this.h1f_1 <= 1)
+    return Unit_instance;
+  var buffer = ensureNotNull($this.d1f_1);
+  $l$loop: while (true) {
+    var tmp;
+    if ($this.h1f_1 > 0) {
+      var tmp0 = _get_head__d7jo8b($this);
+      // Inline function 'kotlin.Long.plus' call
+      var other = _get_totalSize__xhdb3o($this);
+      // Inline function 'kotlin.Long.minus' call
+      var this_0 = add(tmp0, fromInt(other));
+      var tmp$ret$1 = subtract(this_0, fromInt(1));
+      tmp = getBufferAt(buffer, tmp$ret$1) === get_NO_VALUE();
+    } else {
+      tmp = false;
+    }
+    if (!tmp) {
+      break $l$loop;
+    }
+    $this.h1f_1 = $this.h1f_1 - 1 | 0;
+    var tmp0_0 = _get_head__d7jo8b($this);
+    // Inline function 'kotlin.Long.plus' call
+    var other_0 = _get_totalSize__xhdb3o($this);
+    var tmp$ret$2 = add(tmp0_0, fromInt(other_0));
+    setBufferAt(buffer, tmp$ret$2, null);
+  }
+}
+function tryTakeValue($this, slot) {
+  var resumes = get_EMPTY_RESUMES();
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  var index = tryPeekLocked($this, slot);
+  var tmp;
+  if (compare(index, new (Long())(0, 0)) < 0) {
+    tmp = get_NO_VALUE();
+  } else {
+    var oldIndex = slot.s1f_1;
+    var newValue = getPeekedValueLockedAt($this, index);
+    var tmp_0 = slot;
+    // Inline function 'kotlin.Long.plus' call
+    tmp_0.s1f_1 = add(index, fromInt(1));
+    resumes = $this.y1f(oldIndex);
+    tmp = newValue;
+  }
+  var value = tmp;
+  var indexedObject = resumes;
+  var inductionVariable = 0;
+  var last = indexedObject.length;
+  while (inductionVariable < last) {
+    var resume = indexedObject[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    if (resume == null)
+      null;
+    else {
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var tmp$ret$4 = _Result___init__impl__xyqfz8(Unit_instance);
+      resume.dd(tmp$ret$4);
+    }
+  }
+  return value;
+}
+function tryPeekLocked($this, slot) {
+  var index = slot.s1f_1;
+  if (compare(index, _get_bufferEndIndex__d2rk18($this)) < 0)
+    return index;
+  if ($this.b1f_1 > 0)
+    return new (Long())(-1, -1);
+  if (compare(index, _get_head__d7jo8b($this)) > 0)
+    return new (Long())(-1, -1);
+  if ($this.h1f_1 === 0)
+    return new (Long())(-1, -1);
+  return index;
+}
+function getPeekedValueLockedAt($this, index) {
+  var item = getBufferAt(ensureNotNull($this.d1f_1), index);
+  var tmp;
+  if (item instanceof Emitter()) {
+    tmp = item.w1f_1;
+  } else {
+    tmp = item;
+  }
+  return tmp;
+}
+function awaitValue($this, slot, $completion) {
+  var cancellable = new (CancellableContinuationImpl())(intercepted($completion), 1);
+  cancellable.zz();
+  // Inline function 'kotlinx.coroutines.internal.synchronized' call
+  // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+  $l$block: {
+    var index = tryPeekLocked($this, slot);
+    if (compare(index, new (Long())(0, 0)) < 0) {
+      slot.t1f_1 = cancellable;
+    } else {
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var tmp$ret$0 = _Result___init__impl__xyqfz8(Unit_instance);
+      cancellable.dd(tmp$ret$0);
+      break $l$block;
+    }
+    slot.t1f_1 = cancellable;
+  }
+  return cancellable.a10();
+}
+function findSlotsToResumeLocked($this, resumesIn) {
+  var resumes = resumesIn;
+  var resumeCount = resumesIn.length;
+  $l$block: {
+    // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
+    if ($this.j1f_1 === 0) {
+      break $l$block;
+    }
+    var tmp0_safe_receiver = $this.i1f_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.collections.forEach' call
+      var inductionVariable = 0;
+      var last = tmp0_safe_receiver.length;
+      while (inductionVariable < last) {
+        var element = tmp0_safe_receiver[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        if (!(element == null)) {
+          $l$block_1: {
+            var tmp0_elvis_lhs = element.t1f_1;
+            var tmp;
+            if (tmp0_elvis_lhs == null) {
+              break $l$block_1;
+            } else {
+              tmp = tmp0_elvis_lhs;
+            }
+            var cont = tmp;
+            if (compare(tryPeekLocked($this, element), new (Long())(0, 0)) < 0) {
+              break $l$block_1;
+            }
+            if (resumeCount >= resumes.length) {
+              var tmp_0 = resumes;
+              // Inline function 'kotlin.comparisons.maxOf' call
+              var b = imul(2, resumes.length);
+              var tmp$ret$2 = Math.max(2, b);
+              resumes = copyOf(tmp_0, tmp$ret$2);
+            }
+            var tmp_1 = resumes;
+            var _unary__edvuaz = resumeCount;
+            resumeCount = _unary__edvuaz + 1 | 0;
+            tmp_1[_unary__edvuaz] = cont;
+            element.t1f_1 = null;
+          }
+        }
+      }
+    }
+  }
+  return resumes;
+}
+var EmitterClass;
+function Emitter() {
+  if (EmitterClass === VOID) {
+    class $ {
+      constructor(flow, index, value, cont) {
+        this.u1f_1 = flow;
+        this.v1f_1 = index;
+        this.w1f_1 = value;
+        this.x1f_1 = cont;
+      }
+      zy() {
+        return cancelEmitter(this.u1f_1, this);
+      }
+    }
+    initMetadataForClass($, 'Emitter');
+    EmitterClass = $;
+  }
+  return EmitterClass;
+}
+var SharedFlowImplClass;
+function SharedFlowImpl() {
+  if (SharedFlowImplClass === VOID) {
+    class $ extends AbstractSharedFlow() {
+      constructor(replay, bufferCapacity, onBufferOverflow) {
+        super();
+        this.a1f_1 = replay;
+        this.b1f_1 = bufferCapacity;
+        this.c1f_1 = onBufferOverflow;
+        this.d1f_1 = null;
+        this.e1f_1 = new (Long())(0, 0);
+        this.f1f_1 = new (Long())(0, 0);
+        this.g1f_1 = 0;
+        this.h1f_1 = 0;
+      }
+      z1f() {
+        var tmp = ensureNotNull(this.d1f_1);
+        var tmp0 = this.e1f_1;
+        // Inline function 'kotlin.Long.plus' call
+        var other = _get_replaySize__dxgnb1(this);
+        // Inline function 'kotlin.Long.minus' call
+        var this_0 = add(tmp0, fromInt(other));
+        var tmp$ret$1 = subtract(this_0, fromInt(1));
+        var tmp_0 = getBufferAt(tmp, tmp$ret$1);
+        return (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+      }
+      y1d(collector, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_collect__dlomyy.bind(VOID, this, collector), $completion);
+      }
+      r1f(value) {
+        var resumes = get_EMPTY_RESUMES();
+        // Inline function 'kotlinx.coroutines.internal.synchronized' call
+        // Inline function 'kotlinx.coroutines.internal.synchronizedImpl' call
+        var tmp;
+        if (tryEmitLocked(this, value)) {
+          resumes = findSlotsToResumeLocked(this, resumes);
+          tmp = true;
+        } else {
+          tmp = false;
+        }
+        var emitted = tmp;
+        var indexedObject = resumes;
+        var inductionVariable = 0;
+        var last = indexedObject.length;
+        while (inductionVariable < last) {
+          var cont = indexedObject[inductionVariable];
+          inductionVariable = inductionVariable + 1 | 0;
+          if (cont == null)
+            null;
+          else {
+            // Inline function 'kotlin.coroutines.resume' call
+            // Inline function 'kotlin.Companion.success' call
+            var tmp$ret$3 = _Result___init__impl__xyqfz8(Unit_instance);
+            cont.dd(tmp$ret$3);
+          }
+        }
+        return emitted;
+      }
+      p1e(value, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_emit__qph46j.bind(VOID, this, value), $completion);
+      }
+      a1g() {
+        var index = this.e1f_1;
+        if (compare(index, this.f1f_1) < 0)
+          this.f1f_1 = index;
+        return index;
+      }
+      y1f(oldIndex) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (compare(oldIndex, this.f1f_1) > 0)
+          return get_EMPTY_RESUMES();
+        var head = _get_head__d7jo8b(this);
+        // Inline function 'kotlin.Long.plus' call
+        var other = this.g1f_1;
+        var newMinCollectorIndex = add(head, fromInt(other));
+        if (this.b1f_1 === 0 && this.h1f_1 > 0) {
+          var _unary__edvuaz = newMinCollectorIndex;
+          newMinCollectorIndex = add(_unary__edvuaz, get_ONE());
+        }
+        $l$block: {
+          // Inline function 'kotlinx.coroutines.flow.internal.AbstractSharedFlow.forEachSlotLocked' call
+          if (this.j1f_1 === 0) {
+            break $l$block;
+          }
+          var tmp0_safe_receiver = this.i1f_1;
+          if (tmp0_safe_receiver == null)
+            null;
+          else {
+            // Inline function 'kotlin.collections.forEach' call
+            var inductionVariable = 0;
+            var last = tmp0_safe_receiver.length;
+            while (inductionVariable < last) {
+              var element = tmp0_safe_receiver[inductionVariable];
+              inductionVariable = inductionVariable + 1 | 0;
+              if (!(element == null)) {
+                if (compare(element.s1f_1, new (Long())(0, 0)) >= 0 && compare(element.s1f_1, newMinCollectorIndex) < 0)
+                  newMinCollectorIndex = element.s1f_1;
+              }
+            }
+          }
+        }
+        // Inline function 'kotlinx.coroutines.assert' call
+        if (compare(newMinCollectorIndex, this.f1f_1) <= 0)
+          return get_EMPTY_RESUMES();
+        var newBufferEndIndex = _get_bufferEndIndex__d2rk18(this);
+        var tmp;
+        if (this.j1f_1 > 0) {
+          var newBufferSize0 = convertToInt(subtract(newBufferEndIndex, newMinCollectorIndex));
+          var tmp0 = this.h1f_1;
+          // Inline function 'kotlin.comparisons.minOf' call
+          var b = this.b1f_1 - newBufferSize0 | 0;
+          tmp = Math.min(tmp0, b);
+        } else {
+          tmp = this.h1f_1;
+        }
+        var maxResumeCount = tmp;
+        var resumes = get_EMPTY_RESUMES();
+        var tmp0_0 = newBufferEndIndex;
+        // Inline function 'kotlin.Long.plus' call
+        var other_0 = this.h1f_1;
+        var newQueueEndIndex = add(tmp0_0, fromInt(other_0));
+        if (maxResumeCount > 0) {
+          // Inline function 'kotlin.arrayOfNulls' call
+          resumes = Array(maxResumeCount);
+          var resumeCount = 0;
+          var buffer = ensureNotNull(this.d1f_1);
+          var inductionVariable_0 = newBufferEndIndex;
+          if (compare(inductionVariable_0, newQueueEndIndex) < 0)
+            $l$loop: do {
+              var curEmitterIndex = inductionVariable_0;
+              inductionVariable_0 = add(inductionVariable_0, new (Long())(1, 0));
+              var emitter = getBufferAt(buffer, curEmitterIndex);
+              if (!(emitter === get_NO_VALUE())) {
+                if (!(emitter instanceof Emitter()))
+                  THROW_CCE();
+                var tmp_0 = resumes;
+                var _unary__edvuaz_0 = resumeCount;
+                resumeCount = _unary__edvuaz_0 + 1 | 0;
+                tmp_0[_unary__edvuaz_0] = emitter.x1f_1;
+                setBufferAt(buffer, curEmitterIndex, get_NO_VALUE());
+                setBufferAt(buffer, newBufferEndIndex, emitter.w1f_1);
+                var _unary__edvuaz_1 = newBufferEndIndex;
+                newBufferEndIndex = add(_unary__edvuaz_1, get_ONE());
+                if (resumeCount >= maxResumeCount)
+                  break $l$loop;
+              }
+            }
+             while (compare(inductionVariable_0, newQueueEndIndex) < 0);
+        }
+        var newBufferSize1 = convertToInt(subtract(newBufferEndIndex, head));
+        if (this.j1f_1 === 0)
+          newMinCollectorIndex = newBufferEndIndex;
+        var tmp0_1 = this.e1f_1;
+        var tmp0_2 = newBufferEndIndex;
+        // Inline function 'kotlin.comparisons.minOf' call
+        var a = this.a1f_1;
+        // Inline function 'kotlin.Long.minus' call
+        var other_1 = Math.min(a, newBufferSize1);
+        // Inline function 'kotlin.comparisons.maxOf' call
+        var b_0 = subtract(tmp0_2, fromInt(other_1));
+        var newReplayIndex = compare(tmp0_1, b_0) >= 0 ? tmp0_1 : b_0;
+        if (this.b1f_1 === 0 && compare(newReplayIndex, newQueueEndIndex) < 0 && equals(getBufferAt(ensureNotNull(this.d1f_1), newReplayIndex), get_NO_VALUE())) {
+          var _unary__edvuaz_2 = newBufferEndIndex;
+          newBufferEndIndex = add(_unary__edvuaz_2, get_ONE());
+          var _unary__edvuaz_3 = newReplayIndex;
+          newReplayIndex = add(_unary__edvuaz_3, get_ONE());
+        }
+        updateBufferLocked(this, newReplayIndex, newMinCollectorIndex, newBufferEndIndex, newQueueEndIndex);
+        cleanupTailLocked(this);
+        // Inline function 'kotlin.collections.isNotEmpty' call
+        // Inline function 'kotlin.collections.isEmpty' call
+        if (!(resumes.length === 0))
+          resumes = findSlotsToResumeLocked(this, resumes);
+        return resumes;
+      }
+      b1g() {
+        return new (SharedFlowSlot())();
+      }
+      c1g(size) {
+        // Inline function 'kotlin.arrayOfNulls' call
+        return Array(size);
+      }
+      k1e(context, capacity, onBufferOverflow) {
+        return fuseSharedFlow(this, context, capacity, onBufferOverflow);
+      }
+    }
+    protoOf($).l1e = fuse$default;
+    initMetadataForClass($, 'SharedFlowImpl', VOID, VOID, [AbstractSharedFlow(), FlowCollector(), FusibleFlow()], [1]);
+    SharedFlowImplClass = $;
+  }
+  return SharedFlowImplClass;
+}
+var SharedFlowSlotClass;
+function SharedFlowSlot() {
+  if (SharedFlowSlotClass === VOID) {
+    class $ extends AbstractSharedFlowSlot() {
+      constructor() {
+        super();
+        this.s1f_1 = new (Long())(-1, -1);
+        this.t1f_1 = null;
+      }
+      e1g(flow) {
+        if (compare(this.s1f_1, new (Long())(0, 0)) >= 0)
+          return false;
+        this.s1f_1 = flow.a1g();
+        return true;
+      }
+      f1g(flow) {
+        return this.e1g(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
+      }
+      g1g(flow) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        var oldIndex = this.s1f_1;
+        this.s1f_1 = new (Long())(-1, -1);
+        this.t1f_1 = null;
+        return flow.y1f(oldIndex);
+      }
+      h1g(flow) {
+        return this.g1g(flow instanceof SharedFlowImpl() ? flow : THROW_CCE());
+      }
+    }
+    initMetadataForClass($, 'SharedFlowSlot', SharedFlowSlot);
+    SharedFlowSlotClass = $;
+  }
+  return SharedFlowSlotClass;
+}
+function getBufferAt(_this__u8e3s4, index) {
+  _init_properties_SharedFlow_kt__umasnn();
+  return _this__u8e3s4[convertToInt(index) & (_this__u8e3s4.length - 1 | 0)];
+}
+function setBufferAt(_this__u8e3s4, index, item) {
+  _init_properties_SharedFlow_kt__umasnn();
+  return _this__u8e3s4[convertToInt(index) & (_this__u8e3s4.length - 1 | 0)] = item;
+}
+function fuseSharedFlow(_this__u8e3s4, context, capacity, onBufferOverflow) {
+  _init_properties_SharedFlow_kt__umasnn();
+  if ((capacity === 0 || capacity === -3) && onBufferOverflow.equals(BufferOverflow_SUSPEND_getInstance())) {
+    return _this__u8e3s4;
+  }
+  return new (ChannelFlowOperatorImpl())(_this__u8e3s4, context, capacity, onBufferOverflow);
+}
+var properties_initialized_SharedFlow_kt_tmefor;
+function _init_properties_SharedFlow_kt__umasnn() {
+  if (!properties_initialized_SharedFlow_kt_tmefor) {
+    properties_initialized_SharedFlow_kt_tmefor = true;
+    NO_VALUE = new (Symbol())('NO_VALUE');
+  }
+}
+//region block: exports
+export {
+  MutableSharedFlow as MutableSharedFlow3g4w4npzofx4w,
+  SharedFlowImpl as SharedFlowImplm7e4zqeuk15m,
+  fuseSharedFlow as fuseSharedFlow3r8bpddms9npl,
+};
+//endregion
+
+//# sourceMappingURL=SharedFlow.mjs.map