@attocash/commons-js 5.0.0

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

@@ -0,0 +1,106 @@
+import {
+  BufferOverflow_DROP_LATEST_getInstance143zua7beeutm as BufferOverflow_DROP_LATEST_getInstance,
+  BufferOverflow_SUSPEND_getInstance142kaabh2rhtl as BufferOverflow_SUSPEND_getInstance,
+  BufferOverflow_DROP_OLDEST_getInstance1vyzet7fbhkje as BufferOverflow_DROP_OLDEST_getInstance,
+} from './BufferOverflow.mjs';
+import { BufferedChannel3lgkhzot5gmk6 as BufferedChannel } from './BufferedChannel.mjs';
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  _ChannelResult___get_isSuccess__impl__odq1z91n9ra3wwc3tz2 as _ChannelResult___get_isSuccess__impl__odq1z9,
+  _ChannelResult___get_isClosed__impl__mg7kuu2zjlnnup5xs2b as _ChannelResult___get_isClosed__impl__mg7kuu,
+  Companion_getInstance8sxi3cktwbr5 as Companion_getInstance,
+  _ChannelResult___get_holder__impl__pm9gzw1tlq2sv26k77h as _ChannelResult___get_holder__impl__pm9gzw,
+  ChannelResult__exceptionOrNull_impl_16ei3025ypipjsmjecb as ChannelResult__exceptionOrNull_impl_16ei30,
+  Closed8t4xgopf7j5r as Closed,
+} from './Channel.mjs';
+import { callUndeliveredElementCatchingException6xwxmojd3rq1 as callUndeliveredElementCatchingException } from '../internal/OnUndeliveredElement.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { getKClass1s3j9wy1cofik as getKClass } from '../../../../kotlin-kotlin-stdlib/reflection.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { addSuppressedu5jwjfvsc039 as addSuppressed } from '../../../../kotlin-kotlin-stdlib/kotlin/throwableExtensions.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function trySendImpl($this, element, isSendOp) {
+  return $this.u2j_1 === BufferOverflow_DROP_LATEST_getInstance() ? trySendDropLatest($this, element, isSendOp) : $this.h2i(element);
+}
+function trySendDropLatest($this, element, isSendOp) {
+  var result = protoOf(BufferedChannel()).f2i.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.j2c_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
+      throw tmp1_safe_receiver;
+    }
+  }
+  return Companion_getInstance().x2e(Unit_instance);
+}
+var ConflatedBufferedChannelClass;
+function ConflatedBufferedChannel() {
+  if (ConflatedBufferedChannelClass === VOID) {
+    class $ extends BufferedChannel() {
+      constructor(capacity, onBufferOverflow, onUndeliveredElement) {
+        onUndeliveredElement = onUndeliveredElement === VOID ? null : onUndeliveredElement;
+        super(capacity, onUndeliveredElement);
+        this.t2j_1 = capacity;
+        this.u2j_1 = onBufferOverflow;
+        // Inline function 'kotlin.require' call
+        if (!!(this.u2j_1 === BufferOverflow_SUSPEND_getInstance())) {
+          var message = 'This implementation does not support suspension for senders, use ' + getKClass(BufferedChannel()).ag() + ' instead';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        // Inline function 'kotlin.require' call
+        if (!(this.t2j_1 >= 1)) {
+          var message_0 = 'Buffered channel capacity must be at least 1, but ' + this.t2j_1 + ' was specified';
+          throw IllegalArgumentException().u(toString(message_0));
+        }
+      }
+      p2f() {
+        return this.u2j_1.equals(BufferOverflow_DROP_OLDEST_getInstance());
+      }
+      e2i(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.j2c_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.r2e());
+            throw tmp1_safe_receiver;
+          }
+          throw this.r2e();
+        }
+        return Unit_instance;
+      }
+      f2i(element) {
+        return trySendImpl(this, element, false);
+      }
+    }
+    initMetadataForClass($, 'ConflatedBufferedChannel', VOID, VOID, VOID, [1, 0]);
+    ConflatedBufferedChannelClass = $;
+  }
+  return ConflatedBufferedChannelClass;
+}
+//region block: exports
+export {
+  ConflatedBufferedChannel as ConflatedBufferedChannel16nes42ao4b78,
+};
+//endregion
+
+//# sourceMappingURL=ConflatedBufferedChannel.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/channels/ConflatedBufferedChannel.kt","src/kotlin/util/Standard.kt","src/kotlin/util/Preconditions.kt","../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/channels/Channel.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["trySendImpl","element","isSendOp","trySendDropLatest","result","capacity","onBufferOverflow","onUndeliveredElement","message","<get-isConflatedDropOldest>","send","$completion","trySend"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAkDIA,CAAA,K,EAAwBC,O,EAAYC,QAApCF,EACI;A,EAC+B,OAD3B,gBAAqB,wCAArB,GAAkC,yBAAkB,OAAlB,EAA2B,QAA3B,CAAlC,GACC,UAAkB,OAAlB,C;AAAyB,C;0BAElCG,CAAA,K,EAA8BF,O,EAAYC,QAA1CC,EAAkF;A,MAE9EC,SAAmB,2CAAQ,OAAR,C;EAEf,IAAO,6CAAP,MAAO,CAAP,IAA2B,4CAAP,MAAO,CAA3B,C;IAAqC,OAAO,M;EAI5C,a,CAAU;A,QACV,gC;QAAsB,iGAAtB,kBAAsB,EAAwC,OAAxC,C;IAAkD,+B;MAAA,I;SAAA;A;MC0BzC,MD1B/B,kB;IAEA,C;;EAEJ,OAAO,0C;AACX,C;;;;;kBAtDAC,Q,EACAC,gB,EACAC,oB;+DAAiD,I;cACnB,Q,EAAiC,oB;QAH/D,qB;QACA,6B;;QEoBI,KFhBQ,iBAAqB,oCAArB,CEgBR,C,CAAQ;A,cACRC,UFhBK,mEAAD,GAA2F,iCAA3F,GAAsG,U;UEiB1G,mCAAuC,SAAR,OAAQ,CAAvC,C;QACJ,C;;QAHI,MFbQ,cAAY,CEapB,E,CAAQ;A,cACRA,YFbK,oDAAD,GAAoD,IAApD,CAAoD,KAApD,GAA4D,gB;UEchE,mCAAuC,SAAR,SAAQ,CAAvC,C;QACJ,C;;SFVIC,CAAAA,EAAQ;A,QAA+B,OAA/B,kBAAoB,wCAApB,C;MAA8B,C;SAE1CC,CAA0BT,O,EAA1BU,WAAAD,EAAsC;A;qBAElC,kBAAY,OAAZ,EAAgC,IAAhC,C;kBGs/BA,iD;QAAA,4B,CAAgC;A,UAAO,kD;cHr/BnC,+B;cAAsB,iGAAtB,kBAAsB,EAAwC,OAAxC,C;UAAkD,+B;YAAA,I;eAAA;A;YCgBjB,cDhBvD,kBCgBuD,EAAc,UAAd,C;YAA6C,MDhBpG,kB;UAGA,C;UACA,MAAM,U;QGi/B8C,C;QH/+B5D,oB;MAAA,C;SASAE,CAAqBX,OAArBW,EAAwD;A,QAAsC,OAAtC,kBAAY,OAAZ,EAAgC,KAAhC,C;MAAqC,C;;;;;;;;;;;"}

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

@@ -0,0 +1,93 @@
+import { EmptyCoroutineContext_getInstance31fow51ayy30t as EmptyCoroutineContext_getInstance } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineContextImpl.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { BufferOverflow_SUSPEND_getInstance142kaabh2rhtl as BufferOverflow_SUSPEND_getInstance } from './BufferOverflow.mjs';
+import { CoroutineStart_DEFAULT_getInstance2bbgmtawlnkke as CoroutineStart_DEFAULT_getInstance } from '../CoroutineStart.mjs';
+import { CoroutineScopefcb5f5dwqcas as CoroutineScope } from '../CoroutineScope.mjs';
+import {
+  SendChannel38sllbxw662ws as SendChannel,
+  Channel3r72atmcithql as Channel,
+} from './Channel.mjs';
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { newCoroutineContext2tdpc8c02iv5t as newCoroutineContext } from '../CoroutineContext.mjs';
+import {
+  Unit_instance1fbcbse1fwigr as Unit_instance,
+  Unitkvevlwgzwiuc as Unit,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { ChannelCoroutine12l2gxei4u780 as ChannelCoroutine } from './ChannelCoroutine.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { handleCoroutineExceptionv1m1bdk4j2te as handleCoroutineException } from '../CoroutineExceptionHandler.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function produce(_this__u8e3s4, context, capacity, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  capacity = capacity === VOID ? 0 : capacity;
+  return produce_0(_this__u8e3s4, context, capacity, BufferOverflow_SUSPEND_getInstance(), CoroutineStart_DEFAULT_getInstance(), null, block);
+}
+var ProducerScopeClass;
+function ProducerScope() {
+  if (ProducerScopeClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'ProducerScope', VOID, VOID, [CoroutineScope(), SendChannel()], [1]);
+    ProducerScopeClass = $;
+  }
+  return ProducerScopeClass;
+}
+function produce_0(_this__u8e3s4, context, capacity, onBufferOverflow, start, onCompletion, block) {
+  context = context === VOID ? EmptyCoroutineContext_getInstance() : context;
+  capacity = capacity === VOID ? 0 : capacity;
+  onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
+  start = start === VOID ? CoroutineStart_DEFAULT_getInstance() : start;
+  onCompletion = onCompletion === VOID ? null : onCompletion;
+  var channel = Channel(capacity, onBufferOverflow);
+  var newContext = newCoroutineContext(_this__u8e3s4, context);
+  var coroutine = new (ProducerCoroutine())(newContext, channel);
+  if (!(onCompletion == null)) {
+    coroutine.v1y(onCompletion);
+  }
+  coroutine.g1y(start, coroutine, block);
+  return coroutine;
+}
+var ProducerCoroutineClass;
+function ProducerCoroutine() {
+  if (ProducerCoroutineClass === VOID) {
+    class $ extends ChannelCoroutine() {
+      constructor(parentContext, channel) {
+        super(parentContext, channel, true, true);
+      }
+      t1x() {
+        return super.t1x();
+      }
+      z2j(value) {
+        this.g2j_1.s2i();
+      }
+      u1x(value) {
+        return this.z2j(value instanceof Unit() ? value : THROW_CCE());
+      }
+      v1x(cause, handled) {
+        var processed = this.g2j_1.q2i(cause);
+        if (!processed && !handled) {
+          handleCoroutineException(this.r1x_1, cause);
+        }
+      }
+      u2i(cause, $super) {
+        return this.d1z(cause, ($super == null ? true : $super instanceof ProducerCoroutine()) ? $super : THROW_CCE());
+      }
+    }
+    initMetadataForClass($, 'ProducerCoroutine', VOID, VOID, [ChannelCoroutine(), ProducerScope()], [1, 0]);
+    ProducerCoroutineClass = $;
+  }
+  return ProducerCoroutineClass;
+}
+//region block: exports
+export {
+  ProducerScope as ProducerScopeb3mmhvfa6ll7,
+  produce as produce1iljho2c8bp6o,
+};
+//endregion
+
+//# sourceMappingURL=Produce.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/channels/Produce.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["produce","<this>","context","capacity","block","onBufferOverflow","start","onCompletion","channel","newContext","coroutine","parentContext","<get-isActive>","onCompleted","value","onCancelled","cause","handled","processed"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;gBA6OAA,CACeC,a,EACXC,O,EACAC,Q,EACAC,KAJJJ,EAMI;A;iCAHwB,C;EAGsF,OAA9G,yBAAQ,OAAR,EAAiB,QAAjB,EAA0C,oCAA1C,EAAkE,oCAAlE,EAA0F,IAA1F,EAAwG,KAAxG,C;AAA6G,C;;;;;;;;;;kBAyBjHA,CAAiBC,a,EACbC,O,EACAC,Q,EACAE,gB,EACAC,K,EACAC,Y,EACAH,KANJJ,EAOqB;A;iCALD,C;iDACkC,oC;2BACX,oC;yCACJ,I;MAGnCQ,UAAc,QAAW,QAAX,EAAqB,gBAArB,C;MACdC,aAAiB,mCAAoB,OAApB,C;MACjBC,sCAAkC,UAAlCA,EAA8C,OAA9CA,C;EACI,sBAAgB,IAAhB,E,CAAgC;A,IAAV,SAAU,KAA6B,YAA7B,C;;EACpC,SAAU,KAAM,KAAN,EAAa,SAAb,EAAwB,KAAxB,C;EACV,OAAO,S;AACX,C;;;;;kBAGIC,a,EAAiCH,O;cACb,a,EAAe,O,EAAS,I,EAAe,I;;SAEvDI,CAAAA,EAAQ;A,QAAc,OAAR,W;MAAO,C;SAEzBC,CAAyBC,KAAzBD,EAAsC;A,QAClC,IAAS,CAAT,KAAS,M;MACb,C;UArOYC,K;;;SAuOZC,CAAyBC,K,EAAkBC,OAA3CF,EAA6D;A,YACzDG,YAAgB,IAAS,CAAT,KAAS,KAAM,KAAN,C;QACrB,KAAC,SAAD,IAAc,CAAC,OAAf,C;UAAwB,yBAAyB,IAAzB,CAAyB,KAAzB,EAAkC,KAAlC,C;;MAChC,C;UAEgzmBF,K;;;;;;;;;;;;;"}

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

@@ -0,0 +1,135 @@
+import { AbstractFlow3bixaw6q3bbim as AbstractFlow } from './Flow.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function flow(block) {
+  return new (SafeFlow())(block);
+}
+var SafeFlowClass;
+function SafeFlow() {
+  if (SafeFlowClass === VOID) {
+    class $ extends AbstractFlow() {
+      constructor(block) {
+        super();
+        this.a2k_1 = block;
+      }
+      b2k(collector, $completion) {
+        return this.a2k_1(collector, $completion);
+      }
+    }
+    initMetadataForClass($, 'SafeFlow', VOID, VOID, VOID, [1]);
+    SafeFlowClass = $;
+  }
+  return SafeFlowClass;
+}
+function asFlow(_this__u8e3s4) {
+  // Inline function 'kotlinx.coroutines.flow.internal.unsafeFlow' call
+  return new (asFlow$$inlined$unsafeFlow$1())(_this__u8e3s4);
+}
+var $collectCOROUTINE$Class;
+function $collectCOROUTINE$() {
+  if ($collectCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, collector, resultContinuation) {
+        super(resultContinuation);
+        this.l2k_1 = _this__u8e3s4;
+        this.m2k_1 = collector;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                var tmp_0 = this;
+                tmp_0.n2k_1 = this.m2k_1;
+                this.o2k_1 = this.n2k_1;
+                var tmp_1 = this;
+                tmp_1.p2k_1 = this.l2k_1.v2k_1;
+                this.q2k_1 = this.p2k_1;
+                this.r2k_1 = this.q2k_1.d1();
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                if (!this.r2k_1.e1()) {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+                this.s2k_1 = this.r2k_1.f1();
+                var tmp_2 = this;
+                tmp_2.t2k_1 = this.s2k_1;
+                this.u2k_1 = this.t2k_1;
+                this.ac_1 = 2;
+                suspendResult = this.o2k_1.w2k(this.u2k_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.ac_1 = 1;
+                continue $sm;
+              case 3:
+                return Unit_instance;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $collectCOROUTINE$Class = $;
+  }
+  return $collectCOROUTINE$Class;
+}
+var asFlow$$inlined$unsafeFlow$1Class;
+function asFlow$$inlined$unsafeFlow$1() {
+  if (asFlow$$inlined$unsafeFlow$1Class === VOID) {
+    class $ {
+      constructor($this_asFlow) {
+        this.v2k_1 = $this_asFlow;
+      }
+      x2k(collector, $completion) {
+        var tmp = new ($collectCOROUTINE$())(this, collector, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      c2k(collector, $completion) {
+        return this.x2k(collector, $completion);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, VOID, [1]);
+    asFlow$$inlined$unsafeFlow$1Class = $;
+  }
+  return asFlow$$inlined$unsafeFlow$1Class;
+}
+//region block: exports
+export {
+  asFlow as asFlow3ngsnn5xpz8pw,
+  flow as flow3tazazxj2t7g4,
+};
+//endregion
+
+//# sourceMappingURL=Builders.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/Builders.kt","../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/internal/SafeCollector.common.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["flow","block","collectSafely","collector","$completion","asFlow","<this>","doResume","collect"],"mappings":";;;;;;;;;;;;;aAmDAA,CAAoBC,KAApBD,EAA6F;A,EAAe,wBAAN,KAAM,C;AAAD,C;;;;;kBAGjFC,K;;QAAA,kB;;SACtBC,CAAmCC,S,EAAnCC,WAAAF,EAAgE;A,QAClD,OAAV,IAAU,OAAV,SAAU,c;MACd,C;;;;;;;eA2BJG,CAAeC,aAAfD,EAA+C;A;EAI9C,OCgBU,mD;ADhBX,C;;;;;kBAoEsD,a,EAA6B,S,EAA7B,kB;;;;;QAAAE,CAAAA,EAAA;A;;UAAA,I;;;;;;mCACpC,K;;;mCAxEd,K,CAAA,K;;gBAwQmiiD,4B;;;;qBAAA,e;;;;;gBAAX,aAAW,e;;mCAAa,K;;;gCAvQ5iiD,oBAAK,KAAL,O;;;;;;;;;;gBAyEM,oB;;;;;;;;;;;;;;MAAA,C;;;;;;;;;;;kBA3EC,Y;;;SAwEuCC,CAA6BL,S,EAA7BC,WAAAI,EAClD;A;;;;MAEU,C;UA+IbL,S,EAF0BC,W;;;;;;;;;;;;;"}

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

@@ -0,0 +1,100 @@
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { SafeCollector3ss0wp8n80f6m as SafeCollector } from './internal/SafeCollector.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var $collectCOROUTINE$Class;
+function $collectCOROUTINE$() {
+  if ($collectCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, collector, resultContinuation) {
+        super(resultContinuation);
+        this.g2l_1 = _this__u8e3s4;
+        this.h2l_1 = collector;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 5;
+                var tmp_0 = this;
+                tmp_0.i2l_1 = new (SafeCollector())(this.h2l_1, this.gc());
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.bc_1 = 4;
+                this.ac_1 = 2;
+                suspendResult = this.g2l_1.b2k(this.i2l_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 2:
+                this.j2l_1 = suspendResult;
+                this.bc_1 = 5;
+                this.ac_1 = 3;
+                continue $sm;
+              case 3:
+                this.bc_1 = 5;
+                this.i2l_1.kc();
+                return Unit_instance;
+              case 4:
+                this.bc_1 = 5;
+                var t = this.dc_1;
+                this.i2l_1.kc();
+                throw t;
+              case 5:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 5) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $collectCOROUTINE$Class = $;
+  }
+  return $collectCOROUTINE$Class;
+}
+var AbstractFlowClass;
+function AbstractFlow() {
+  if (AbstractFlowClass === VOID) {
+    class $ {
+      c2k(collector, $completion) {
+        var tmp = new ($collectCOROUTINE$())(this, collector, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+    }
+    initMetadataForClass($, 'AbstractFlow', VOID, VOID, VOID, [1]);
+    AbstractFlowClass = $;
+  }
+  return AbstractFlowClass;
+}
+//region block: exports
+export {
+  AbstractFlow as AbstractFlow3bixaw6q3bbim,
+};
+//endregion
+
+//# sourceMappingURL=Flow.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/Flow.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["doResume","t","collect","collector","$completion"],"mappings":";;;;;;;;;;;;;;;;;kBA8NI,a,EAA0C,S,EAA1C,kB;;;;;QAAAA,CAAAA,EAAA;A;;UAAA,I;;;;;;gBACI,yCAAkC,KAAlC,EA9MH,SA8MG,C;;;;;;gCAEI,oBAAc,KAAd,O;;;;;;;;;;;;;gBAEc,KAAd,KAAc,K;gBAEtB,oB;;;oBALIC,a;gBAGkB,KAAd,KAAc,K;;;;;;;;;;;;;;;MAEtB,C;;;;;;;;;;;SAPAC,CAA0CC,S,EAA1CC,WAAAF,EAAuE;A;;;;MAOvE,C;;;;;;;;;;;"}

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/FlowCollector.mjs

@@ -0,0 +1,22 @@
+import { initMetadataForInterface1egvbzx539z91 as initMetadataForInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var FlowCollectorClass;
+function FlowCollector() {
+  if (FlowCollectorClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'FlowCollector', VOID, VOID, VOID, [1]);
+    FlowCollectorClass = $;
+  }
+  return FlowCollectorClass;
+}
+//region block: exports
+export {
+  FlowCollector as FlowCollector26clgpmzihvke,
+};
+//endregion
+
+//# sourceMappingURL=FlowCollector.mjs.map

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/FlowCollector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,196 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { AbortFlowException2zdgh4w7z3hep as AbortFlowException } from './internal/FlowExceptions.mjs';
+import {
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from './FlowCollector.mjs';
+import { checkOwnershipoyid8o0pxxr7 as checkOwnership } from './internal/FlowExceptions.common.mjs';
+import { ensureActive2yo7199srjlgl as ensureActive } from '../Job.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function firstOrNull(_this__u8e3s4, predicate, $completion) {
+  var tmp = new ($firstOrNullCOROUTINE$())(_this__u8e3s4, predicate, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var $emitCOROUTINE$Class;
+function $emitCOROUTINE$() {
+  if ($emitCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, value, resultContinuation) {
+        super(resultContinuation);
+        this.q2m_1 = _this__u8e3s4;
+        this.r2m_1 = value;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                var tmp_0 = this;
+                tmp_0.s2m_1 = this.r2m_1;
+                this.t2m_1 = this.s2m_1;
+                this.ac_1 = 1;
+                suspendResult = this.q2m_1.v2m_1(this.t2m_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                if (suspendResult) {
+                  var tmp_1 = this;
+                  this.q2m_1.w2m_1._v = this.t2m_1;
+                  tmp_1.u2m_1 = false;
+                  this.ac_1 = 2;
+                  continue $sm;
+                } else {
+                  var tmp_2 = this;
+                  tmp_2.u2m_1 = true;
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 2:
+                var ARGUMENT = this.u2m_1;
+                if (!ARGUMENT) {
+                  throw AbortFlowException().x2m(this.q2m_1);
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 3:
+                return Unit_instance;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 4) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $emitCOROUTINE$Class = $;
+  }
+  return $emitCOROUTINE$Class;
+}
+var firstOrNull$$inlined$collectWhile$1Class;
+function firstOrNull$$inlined$collectWhile$1() {
+  if (firstOrNull$$inlined$collectWhile$1Class === VOID) {
+    class $ {
+      constructor($predicate, $result) {
+        this.v2m_1 = $predicate;
+        this.w2m_1 = $result;
+      }
+      y2m(value, $completion) {
+        var tmp = new ($emitCOROUTINE$())(this, value, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      w2k(value, $completion) {
+        return this.y2m((value == null ? true : !(value == null)) ? value : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForClass($, VOID, VOID, VOID, [FlowCollector()], [1]);
+    firstOrNull$$inlined$collectWhile$1Class = $;
+  }
+  return firstOrNull$$inlined$collectWhile$1Class;
+}
+var $firstOrNullCOROUTINE$Class;
+function $firstOrNullCOROUTINE$() {
+  if ($firstOrNullCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, predicate, resultContinuation) {
+        super(resultContinuation);
+        this.c2m_1 = _this__u8e3s4;
+        this.d2m_1 = predicate;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 4;
+                this.e2m_1 = {_v: null};
+                var tmp_0 = this;
+                tmp_0.f2m_1 = this.c2m_1;
+                this.g2m_1 = this.f2m_1;
+                var tmp_1 = this;
+                tmp_1.h2m_1 = new (firstOrNull$$inlined$collectWhile$1())(this.d2m_1, this.e2m_1);
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.g2m_1.c2k(this.h2m_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                this.bc_1 = 4;
+                this.ac_1 = 3;
+                continue $sm;
+              case 2:
+                this.bc_1 = 4;
+                var tmp_2 = this.dc_1;
+                if (tmp_2 instanceof AbortFlowException()) {
+                  var e = this.dc_1;
+                  checkOwnership(e, this.h2m_1);
+                  ensureActive(this.gc());
+                  this.ac_1 = 3;
+                  continue $sm;
+                } else {
+                  throw this.dc_1;
+                }
+
+              case 3:
+                this.bc_1 = 4;
+                return this.e2m_1._v;
+              case 4:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e_0 = $p;
+            if (this.bc_1 === 4) {
+              throw e_0;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e_0;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $firstOrNullCOROUTINE$Class = $;
+  }
+  return $firstOrNullCOROUTINE$Class;
+}
+//region block: exports
+export {
+  firstOrNull as firstOrNull3jjcu7fygcopr,
+};
+//endregion
+
+//# sourceMappingURL=Reduce.mjs.map