@attocash/commons-js 5.4.1 → 6.1.0

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/internal/ChannelFlow.mjs

@@ -0,0 +1,413 @@
+import { EmptyCoroutineContext_instance2qpebg1xogbvt as EmptyCoroutineContext_instance } 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 '../../channels/BufferOverflow.mjs';
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.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 { newCoroutineContext1x74axajiiptk as newCoroutineContext } from '../../CoroutineContext.mjs';
+import {
+  equals2au1ep9vhcato as equals,
+  protoOf180f3jzyo7rfj as protoOf,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Key_instance17k9ki7fvysxq as Key_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/ContinuationInterceptor.mjs';
+import {
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+  startCoroutineUninterceptedOrReturnGeneratorVersion1cv0wx9z0l0zn as startCoroutineUninterceptedOrReturnGeneratorVersion,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from '../FlowCollector.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { SendingCollector33jb503i6hglm as SendingCollector } from './SendingCollector.mjs';
+import { emitAll3o9nnhrg4qpbv as emitAll } from '../Channels.mjs';
+import {
+  ProducerScopeb3mmhvfa6ll7 as ProducerScope,
+  produce3s4oh9balbl5b as produce,
+} from '../../channels/Produce.mjs';
+import {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  coroutineScope284yy3flyb2v2 as coroutineScope,
+} from '../../CoroutineScope.mjs';
+import { CoroutineStart_ATOMIC_getInstance30g3oja6rp37m as CoroutineStart_ATOMIC_getInstance } from '../../CoroutineStart.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { get_classSimpleName2jgk6lzg9ft1 as get_classSimpleName } from '../../Debug.mjs';
+import { joinToString1cxrrlmo0chqs as joinToString } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { NopCollector2h4omm21qc7hq as NopCollector } from './NopCollector.mjs';
+import { threadContextElements12yd4mfmaodla as threadContextElements } from '../../internal/ThreadContext.mjs';
+import { Continuation1aa2oekvx7jm7 as Continuation } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/Continuation.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function fuse$default(context, capacity, onBufferOverflow, $super) {
+  context = context === VOID ? EmptyCoroutineContext_instance : context;
+  capacity = capacity === VOID ? -3 : capacity;
+  onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
+  return $super === VOID ? this.a1c(context, capacity, onBufferOverflow) : $super.a1c.call(this, context, capacity, onBufferOverflow);
+}
+var FusibleFlowClass;
+function FusibleFlow() {
+  if (FusibleFlowClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'FusibleFlow', VOID, VOID, VOID, [1]);
+    FusibleFlowClass = $;
+  }
+  return FusibleFlowClass;
+}
+var ChannelFlowOperatorImplClass;
+function ChannelFlowOperatorImpl() {
+  if (ChannelFlowOperatorImplClass === VOID) {
+    class $ extends ChannelFlowOperator() {
+      constructor(flow, context, capacity, onBufferOverflow) {
+        context = context === VOID ? EmptyCoroutineContext_instance : context;
+        capacity = capacity === VOID ? -3 : capacity;
+        onBufferOverflow = onBufferOverflow === VOID ? BufferOverflow_SUSPEND_getInstance() : onBufferOverflow;
+        super(flow, context, capacity, onBufferOverflow);
+      }
+      a1d(context, capacity, onBufferOverflow) {
+        return new (ChannelFlowOperatorImpl())(this.e1d_1, context, capacity, onBufferOverflow);
+      }
+      f1d(collector, $completion) {
+        return this.e1d_1.g1a(collector, $completion);
+      }
+    }
+    initMetadataForClass($, 'ChannelFlowOperatorImpl', VOID, VOID, VOID, [1]);
+    ChannelFlowOperatorImplClass = $;
+  }
+  return ChannelFlowOperatorImplClass;
+}
+function *_generator_invoke__zhh2q8($this, it, $completion) {
+  var tmp = $this.o1d_1.f1d(it, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function collectWithContextUndispatched($this, collector, newContext, $completion) {
+  // Inline function 'kotlin.js.getCoroutineContext' call
+  var tmp$ret$0 = $completion.zb();
+  var originalContextCollector = withUndispatchedContextCollector(collector, tmp$ret$0);
+  return withContextUndispatched(newContext, originalContextCollector, VOID, ChannelFlowOperator$collectWithContextUndispatched$slambda_0($this), $completion);
+}
+function *_generator_collect__dlomyy($this, collector, $completion) {
+  if ($this.i1d_1 === -3) {
+    // Inline function 'kotlin.js.getCoroutineContext' call
+    var collectContext = $completion.zb();
+    var newContext = newCoroutineContext(collectContext, $this.h1d_1);
+    if (equals(newContext, collectContext)) {
+      var tmp = $this.f1d(collector, $completion);
+      if (tmp === get_COROUTINE_SUSPENDED())
+        tmp = yield tmp;
+      return Unit_instance;
+    }
+    if (equals(newContext.mc(Key_instance), collectContext.mc(Key_instance))) {
+      var tmp_0 = collectWithContextUndispatched($this, collector, newContext, $completion);
+      if (tmp_0 === get_COROUTINE_SUSPENDED())
+        tmp_0 = yield tmp_0;
+      return Unit_instance;
+    }
+  }
+  var tmp_1 = protoOf(ChannelFlow()).g1a.call($this, collector, $completion);
+  if (tmp_1 === get_COROUTINE_SUSPENDED())
+    tmp_1 = yield tmp_1;
+  return Unit_instance;
+}
+var ChannelFlowOperator$collectWithContextUndispatched$slambdaClass;
+function ChannelFlowOperator$collectWithContextUndispatched$slambda() {
+  if (ChannelFlowOperator$collectWithContextUndispatched$slambdaClass === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.o1d_1 = this$0;
+      }
+      p1d(it, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, it), $completion);
+      }
+      hd(p1, $completion) {
+        return this.p1d((!(p1 == null) ? isInterface(p1, FlowCollector()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    ChannelFlowOperator$collectWithContextUndispatched$slambdaClass = $;
+  }
+  return ChannelFlowOperator$collectWithContextUndispatched$slambdaClass;
+}
+function ChannelFlowOperator$collectWithContextUndispatched$slambda_0(this$0) {
+  var i = new (ChannelFlowOperator$collectWithContextUndispatched$slambda())(this$0);
+  var l = (it, $completion) => i.p1d(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var ChannelFlowOperatorClass;
+function ChannelFlowOperator() {
+  if (ChannelFlowOperatorClass === VOID) {
+    class $ extends ChannelFlow() {
+      constructor(flow, context, capacity, onBufferOverflow) {
+        super(context, capacity, onBufferOverflow);
+        this.e1d_1 = flow;
+      }
+      g1d(scope, $completion) {
+        return this.f1d(new (SendingCollector())(scope), $completion);
+      }
+      g1a(collector, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_collect__dlomyy.bind(VOID, this, collector), $completion);
+      }
+      toString() {
+        return toString(this.e1d_1) + ' -> ' + super.toString();
+      }
+    }
+    initMetadataForClass($, 'ChannelFlowOperator', VOID, VOID, VOID, [1, 2]);
+    ChannelFlowOperatorClass = $;
+  }
+  return ChannelFlowOperatorClass;
+}
+function *_generator_invoke__zhh2q8_0($this, it, $completion) {
+  var tmp = $this.q1d_1.g1d(it, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function *_generator_invoke__zhh2q8_1($this, $this$coroutineScope, $completion) {
+  var tmp = emitAll($this.r1d_1, $this.s1d_1.m1d($this$coroutineScope), $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+var ChannelFlow$_get_collectToFun_$slambda_j53z2eClass;
+function ChannelFlow$_get_collectToFun_$slambda_j53z2e() {
+  if (ChannelFlow$_get_collectToFun_$slambda_j53z2eClass === VOID) {
+    class $ {
+      constructor(this$0) {
+        this.q1d_1 = this$0;
+      }
+      t1d(it, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_0.bind(VOID, this, it), $completion);
+      }
+      hd(p1, $completion) {
+        return this.t1d((!(p1 == null) ? isInterface(p1, ProducerScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    ChannelFlow$_get_collectToFun_$slambda_j53z2eClass = $;
+  }
+  return ChannelFlow$_get_collectToFun_$slambda_j53z2eClass;
+}
+function ChannelFlow$_get_collectToFun_$slambda_j53z2e_0(this$0) {
+  var i = new (ChannelFlow$_get_collectToFun_$slambda_j53z2e())(this$0);
+  var l = (it, $completion) => i.t1d(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var ChannelFlow$collect$slambdaClass;
+function ChannelFlow$collect$slambda() {
+  if (ChannelFlow$collect$slambdaClass === VOID) {
+    class $ {
+      constructor($collector, this$0) {
+        this.r1d_1 = $collector;
+        this.s1d_1 = this$0;
+      }
+      u1d($this$coroutineScope, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_1.bind(VOID, this, $this$coroutineScope), $completion);
+      }
+      hd(p1, $completion) {
+        return this.u1d((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    ChannelFlow$collect$slambdaClass = $;
+  }
+  return ChannelFlow$collect$slambdaClass;
+}
+function ChannelFlow$collect$slambda_0($collector, this$0) {
+  var i = new (ChannelFlow$collect$slambda())($collector, this$0);
+  var l = ($this$coroutineScope, $completion) => i.u1d($this$coroutineScope, $completion);
+  l.$arity = 1;
+  return l;
+}
+var ChannelFlowClass;
+function ChannelFlow() {
+  if (ChannelFlowClass === VOID) {
+    class $ {
+      constructor(context, capacity, onBufferOverflow) {
+        this.h1d_1 = context;
+        this.i1d_1 = capacity;
+        this.j1d_1 = onBufferOverflow;
+        // Inline function 'kotlinx.coroutines.assert' call
+      }
+      k1d() {
+        return ChannelFlow$_get_collectToFun_$slambda_j53z2e_0(this);
+      }
+      l1d() {
+        return this.i1d_1 === -3 ? -2 : this.i1d_1;
+      }
+      a1c(context, capacity, onBufferOverflow) {
+        // Inline function 'kotlinx.coroutines.assert' call
+        var newContext = context.il(this.h1d_1);
+        var newCapacity;
+        var newOverflow;
+        if (!onBufferOverflow.equals(BufferOverflow_SUSPEND_getInstance())) {
+          newCapacity = capacity;
+          newOverflow = onBufferOverflow;
+        } else {
+          var tmp;
+          if (this.i1d_1 === -3) {
+            tmp = capacity;
+          } else if (capacity === -3) {
+            tmp = this.i1d_1;
+          } else if (this.i1d_1 === -2) {
+            tmp = capacity;
+          } else if (capacity === -2) {
+            tmp = this.i1d_1;
+          } else {
+            // Inline function 'kotlinx.coroutines.assert' call
+            // Inline function 'kotlinx.coroutines.assert' call
+            var sum = this.i1d_1 + capacity | 0;
+            tmp = sum >= 0 ? sum : 2147483647;
+          }
+          newCapacity = tmp;
+          newOverflow = this.j1d_1;
+        }
+        if (equals(newContext, this.h1d_1) && newCapacity === this.i1d_1 && newOverflow.equals(this.j1d_1))
+          return this;
+        return this.a1d(newContext, newCapacity, newOverflow);
+      }
+      m1d(scope) {
+        return produce(scope, this.h1d_1, this.l1d(), this.j1d_1, CoroutineStart_ATOMIC_getInstance(), VOID, this.k1d());
+      }
+      g1a(collector, $completion) {
+        return coroutineScope(ChannelFlow$collect$slambda_0(collector, this), $completion);
+      }
+      n1d() {
+        return null;
+      }
+      toString() {
+        var props = ArrayList().u(4);
+        var tmp0_safe_receiver = this.n1d();
+        if (tmp0_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          props.v(tmp0_safe_receiver);
+        }
+        if (!(this.h1d_1 === EmptyCoroutineContext_instance)) {
+          props.v('context=' + toString(this.h1d_1));
+        }
+        if (!(this.i1d_1 === -3)) {
+          props.v('capacity=' + this.i1d_1);
+        }
+        if (!this.j1d_1.equals(BufferOverflow_SUSPEND_getInstance())) {
+          props.v('onBufferOverflow=' + this.j1d_1.toString());
+        }
+        return get_classSimpleName(this) + '[' + joinToString(props, ', ') + ']';
+      }
+    }
+    protoOf($).b1c = fuse$default;
+    initMetadataForClass($, 'ChannelFlow', VOID, VOID, [FusibleFlow()], [1]);
+    ChannelFlowClass = $;
+  }
+  return ChannelFlowClass;
+}
+function withUndispatchedContextCollector(_this__u8e3s4, emitContext) {
+  var tmp;
+  var tmp_0;
+  if (_this__u8e3s4 instanceof SendingCollector()) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = _this__u8e3s4 instanceof NopCollector();
+  }
+  if (tmp_0) {
+    tmp = _this__u8e3s4;
+  } else {
+    tmp = new (UndispatchedContextCollector())(_this__u8e3s4, emitContext);
+  }
+  return tmp;
+}
+function withContextUndispatched(newContext, value, countOrElement, block, $completion) {
+  countOrElement = countOrElement === VOID ? threadContextElements(newContext) : countOrElement;
+  // Inline function 'kotlinx.coroutines.withCoroutineContext' call
+  // Inline function 'kotlin.coroutines.intrinsics.startCoroutineUninterceptedOrReturn' call
+  var completion = new (StackFrameContinuation())($completion, newContext);
+  return startCoroutineUninterceptedOrReturnGeneratorVersion(block, value, completion);
+}
+function *_generator_invoke__zhh2q8_2($this, it, $completion) {
+  var tmp = $this.v1d_1.j1a(it, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+var UndispatchedContextCollector$emitRef$slambdaClass;
+function UndispatchedContextCollector$emitRef$slambda() {
+  if (UndispatchedContextCollector$emitRef$slambdaClass === VOID) {
+    class $ {
+      constructor($downstream) {
+        this.v1d_1 = $downstream;
+      }
+      w1d(it, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_2.bind(VOID, this, it), $completion);
+      }
+      hd(p1, $completion) {
+        return this.w1d((p1 == null ? true : !(p1 == null)) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    UndispatchedContextCollector$emitRef$slambdaClass = $;
+  }
+  return UndispatchedContextCollector$emitRef$slambdaClass;
+}
+function UndispatchedContextCollector$emitRef$slambda_0($downstream) {
+  var i = new (UndispatchedContextCollector$emitRef$slambda())($downstream);
+  var l = (it, $completion) => i.w1d(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var UndispatchedContextCollectorClass;
+function UndispatchedContextCollector() {
+  if (UndispatchedContextCollectorClass === VOID) {
+    class $ {
+      constructor(downstream, emitContext) {
+        this.x1d_1 = emitContext;
+        this.y1d_1 = threadContextElements(this.x1d_1);
+        var tmp = this;
+        tmp.z1d_1 = UndispatchedContextCollector$emitRef$slambda_0(downstream);
+      }
+      j1a(value, $completion) {
+        return withContextUndispatched(this.x1d_1, value, this.y1d_1, this.z1d_1, $completion);
+      }
+    }
+    initMetadataForClass($, 'UndispatchedContextCollector', VOID, VOID, [FlowCollector()], [1]);
+    UndispatchedContextCollectorClass = $;
+  }
+  return UndispatchedContextCollectorClass;
+}
+var StackFrameContinuationClass;
+function StackFrameContinuation() {
+  if (StackFrameContinuationClass === VOID) {
+    class $ {
+      constructor(uCont, context) {
+        this.a1e_1 = uCont;
+        this.b1e_1 = context;
+      }
+      zb() {
+        return this.b1e_1;
+      }
+      bc(result) {
+        this.a1e_1.bc(result);
+      }
+    }
+    initMetadataForClass($, 'StackFrameContinuation', VOID, VOID, [Continuation()]);
+    StackFrameContinuationClass = $;
+  }
+  return StackFrameContinuationClass;
+}
+//region block: exports
+export {
+  fuse$default as fuse$default2o081v9hjnus8,
+  ChannelFlowOperatorImpl as ChannelFlowOperatorImpl3gjkp847e0ebc,
+  ChannelFlowOperator as ChannelFlowOperator26u0hhp41h3fm,
+  FusibleFlow as FusibleFlow2tgh9s2p1kryd,
+};
+//endregion
+
+//# sourceMappingURL=ChannelFlow.mjs.map

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/internal/ChannelFlow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/flow/internal/ChannelFlow.kt","js/runtime/coroutineInternalJS.kt","js/src/kotlin/coroutines/intrinsics/IntrinsicsJs.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["fuse$default","context","capacity","onBufferOverflow","flow","create","flowCollect","collector","$completion","<generator-invoke>","collectWithContextUndispatched","newContext","originalContextCollector","<generator-collect>","collectContext","invoke","ChannelFlowOperator$collectWithContextUndispatched$slambda","ChannelFlowOperator$collectWithContextUndispatched$slambda$lambda","collectTo","scope","collect","toString","ChannelFlow$<get-collectToFun>$slambda","ChannelFlow$<get-collectToFun>$slambda$lambda","$collector","ChannelFlow$collect$slambda","ChannelFlow$collect$slambda$lambda","<get-collectToFun>","<get-produceCapacity>","fuse","newCapacity","newOverflow","sum","produceImpl","additionalToStringProps","props","withUndispatchedContextCollector","<this>","emitContext","withContextUndispatched","value","countOrElement","block","$downstream","UndispatchedContextCollector$emitRef$slambda","UndispatchedContextCollector$emitRef$slambda$lambda","downstream","emit","uCont","<get-context>","resumeWith","result"],"mappings":"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"}

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/internal/FlowExceptions.common.mjs

@@ -1,7 +1,7 @@
 //region block: pre-declaration
 //endregion
 function checkOwnership(_this__u8e3s4, owner) {
-  if (!(_this__u8e3s4.s2l_1 === owner))
+  if (!(_this__u8e3s4.g1e_1 === owner))
     throw _this__u8e3s4;
 }
 //region block: exports

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/internal/FlowExceptions.mjs

@@ -6,14 +6,29 @@ import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/k
 //endregion
 //region block: pre-declaration
 //endregion
+var ChildCancelledExceptionClass;
+function ChildCancelledException() {
+  if (ChildCancelledExceptionClass === VOID) {
+    class $ extends CancellationException() {
+      static z1e() {
+        var $this = this.bd('Child of the scoped flow was cancelled');
+        captureStack($this, $this.y1e_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'ChildCancelledException', $.z1e);
+    ChildCancelledExceptionClass = $;
+  }
+  return ChildCancelledExceptionClass;
+}
 var AbortFlowExceptionClass;
 function AbortFlowException() {
   if (AbortFlowExceptionClass === VOID) {
     class $ extends CancellationException() {
-      static x2m(owner) {
-        var $this = this.cd('Flow was aborted, no more elements needed');
-        captureStack($this, $this.t2l_1);
-        $this.s2l_1 = owner;
+      static h1g(owner) {
+        var $this = this.bd('Flow was aborted, no more elements needed');
+        captureStack($this, $this.h1e_1);
+        $this.g1e_1 = owner;
         return $this;
       }
     }
@@ -25,6 +40,7 @@ function AbortFlowException() {
 //region block: exports
 export {
   AbortFlowException as AbortFlowException2zdgh4w7z3hep,
+  ChildCancelledException as ChildCancelledException276y6xzo23vhp,
 };
 //endregion
 

package/kotlinx-coroutines-core/kotlinx/coroutines/flow/internal/FlowExceptions.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/jsAndWasmShared/src/flow/internal/FlowExceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["owner"],"mappings":";;;;;;;;;;;;iBAMIA,K;4BACsB,2C;;QADtB,mB;;;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/jsAndWasmShared/src/flow/internal/FlowExceptions.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["owner"],"mappings":";;;;;;;;;;;;;4BAQsE,wC;;;;;;;;;;;;;;iBAFlEA,K;4BACsB,2C;;QADtB,mB;;;;;;;;;;;;;"}