@attocash/commons-test 6.0.0

package/commons-commons-test/cash/atto/commons/node/AttoWorkerMockAsyncBuilder.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/jsMain/kotlin/cash/atto/commons/node/AttoWorkerMockAsyncBuilder.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["invoke","$completion","defaultConfiguration","configuration","AttoWorkerMockAsyncBuilder$build$slambda","AttoWorkerMockAsyncBuilder$build$slambda$lambda","name","value","image","build"],"mappings":";;;;;;;;;;;;;;;;;;;;kBAoBW,M;;;QACgBA,CAAAC,WAAAD,EACf;A,YAAAE,4D;YAGe,iC;kBAAA,yBAAQ,oBAAR,CAA6B,KAA7B,iB;YACC,iC;YAHhBC,gBACI,oBAAqB,UAET,yBAAS,oBAAT,CAA8B,KAA9B,iBAFS,C;QAIiC,OAA5B,+BAAf,aAAe,6BAAoB,KAApB,C;MAA2B,C;;;;;;;mDAP1CC,CADhB,MACgBA,E;;UAAAC,CAAAJ,WAAAI,sB;;;C;;;;;;QATK,iB;QACC,iB;;UAEtBC,CAASC,KAATD,EAAsD;A;QAAA,IAAa,SAAO,K;QAAO,OAA3B,I;MAA0B,C;WAEhFE,CAAUD,KAAVC,EAAuD;A;QAAA,IAAa,SAAQ,K;QAAO,OAA5B,I;MAA2B,C;WAGlFC,CAAAA,EACH;A;QAQC,OARW,YAAO,gDAAP,C;MAQZ,C;;;;;;;;;;;"}

package/commons-commons-test.mjs

@@ -0,0 +1,14 @@
+import './ktor-ktor-client-core.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+export * from './commons-commons-test/cash/atto/commons/node/AttoNodeMock.export.mjs';
+export * from './commons-commons-test/cash/atto/commons/node/AttoNodeMockAsync.js.export.mjs';
+export * from './commons-commons-test/cash/atto/commons/node/AttoNodeMockAsyncBuilder.js.export.mjs';
+export * from './commons-commons-test/cash/atto/commons/node/AttoWorkerMockAsync.js.export.mjs';
+export * from './commons-commons-test/cash/atto/commons/node/AttoWorkerMockAsyncBuilder.js.export.mjs';
+//endregion
+
+//# sourceMappingURL=commons-commons-test.mjs.map

package/commons-commons-test.mjs.map

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

package/commons-commons-worker/cash/atto/commons/worker/AttoWorker.mjs

@@ -0,0 +1,58 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  Companion_instance34cvisfr2k5u0 as Companion_instance,
+  getThreshold18fzjxt4pr6o4 as getThreshold,
+} from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.mjs';
+import { getTargetgiem2nmxlcxo as getTarget } from '../../../../../commons-commons-core/cash/atto/commons/AttoWorkTarget.mjs';
+import { AutoCloseable1l5p57f9lp7kv as AutoCloseable } from '../../../../../kotlin-kotlin-stdlib/kotlin/AutoCloseableJs.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  return Companion_instance_0;
+}
+function work(network, timestamp, target, $completion) {
+  var threshold = getThreshold(Companion_instance, network, timestamp);
+  return this.f52(threshold, target, $completion);
+}
+function work_0(block, $completion) {
+  var target = getTarget(block);
+  return this.g52(block.network, block.timestamp, target, $completion);
+}
+var AttoWorkerClass;
+function AttoWorker() {
+  if (AttoWorkerClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AttoWorker', VOID, VOID, [AutoCloseable()], [2, 3, 1]);
+    AttoWorkerClass = $;
+  }
+  return AttoWorkerClass;
+}
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
+//region block: exports
+export {
+  AttoWorker as AttoWorker1vldrz4t7huug,
+  work_0 as work30rrtknet8hfg,
+  work as work3ude3jw3qwf7i,
+  Companion_instance_0 as Companion_instance2z9co4ocesd9m,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorker.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/commonMain/kotlin/cash/atto/commons/worker/AttoWorker.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["work","network","timestamp","target","$completion","threshold","block"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkBYA,CACJC,O,EACAC,S,EACAC,M,EAHIC,WAAAJ,EAII;A,MACRK,YAAyB,iCAAa,OAAb,EAAsB,SAAtB,C;EAE7B,OADW,SAAK,SAAL,EAAgB,MAAhB,c;AACX,C;eAEQL,CAASM,K,EAATF,WAAAJ,EAAqC;A,MACzCG,SAAmB,UAAN,KAAM,C;EAEvB,OADW,SAAK,KAAL,CAAW,OAAX,EAAoB,KAApB,CAA0B,SAA1B,EAAqC,MAArC,c;AACX,C;;;;;;;;;;;;;;;;;"}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerAsync.export.d.mts

@@ -0,0 +1,13 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoWorkerAsync {
+    private constructor();
+    get worker(): any/* AttoWorker */;
+    workThreshold(threshold: bigint, target: any/* AttoWorkTarget */): AttoFuture<AttoWork>;
+    workNetwork(network: AttoNetwork, timestamp: AttoInstant, target: any/* AttoWorkTarget */): AttoFuture<AttoWork>;
+    workBlock(block: AttoBlock): AttoFuture<AttoWork>;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoWorkerAsync.$metadata$ {
+    const constructor: abstract new () => AttoWorkerAsync;
+}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerAsync.export.mjs

@@ -0,0 +1,13 @@
+import { AttoWorkerAsync2mqicuktlp1kj as AttoWorkerAsync } from './AttoWorkerAsync.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoWorkerAsync_0 = AttoWorkerAsync();
+export {
+  AttoWorkerAsync_0 as AttoWorkerAsync,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerAsync.export.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerAsync.export.mjs.map

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

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerAsync.mjs

@@ -0,0 +1,124 @@
+import {
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Dispatchers_getInstanceitgtkvqfcnx3 as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+import { SupervisorJobythnfxkr3jxc as SupervisorJob } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Supervisor.mjs';
+import { CoroutineScopelux7s7zphw7e as CoroutineScope } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { submitr2wceezoc2x6 as submit } from '../../../../../commons-commons-core/cash/atto/commons/AttoFuture.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoWorkerAsync$work$slambdaClass;
+function AttoWorkerAsync$work$slambda() {
+  if (AttoWorkerAsync$work$slambdaClass === VOID) {
+    class $ {
+      constructor(this$0, $threshold, $target) {
+        this.i52_1 = this$0;
+        this.j52_1 = $threshold;
+        this.k52_1 = $target;
+      }
+      dd($completion) {
+        return this.i52_1.worker.f52(this.j52_1, this.k52_1, $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWorkerAsync$work$slambdaClass = $;
+  }
+  return AttoWorkerAsync$work$slambdaClass;
+}
+function AttoWorkerAsync$work$slambda_0(this$0, $threshold, $target) {
+  var i = new (AttoWorkerAsync$work$slambda())(this$0, $threshold, $target);
+  var l = ($completion) => i.dd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWorkerAsync$work$slambdaClass_0;
+function AttoWorkerAsync$work$slambda_1() {
+  if (AttoWorkerAsync$work$slambdaClass_0 === VOID) {
+    class $ {
+      constructor(this$0, $network, $timestamp, $target) {
+        this.m52_1 = this$0;
+        this.n52_1 = $network;
+        this.o52_1 = $timestamp;
+        this.p52_1 = $target;
+      }
+      dd($completion) {
+        return this.m52_1.worker.g52(this.n52_1, this.o52_1, this.p52_1, $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWorkerAsync$work$slambdaClass_0 = $;
+  }
+  return AttoWorkerAsync$work$slambdaClass_0;
+}
+function AttoWorkerAsync$work$slambda_2(this$0, $network, $timestamp, $target) {
+  var i = new (AttoWorkerAsync$work$slambda_1())(this$0, $network, $timestamp, $target);
+  var l = ($completion) => i.dd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWorkerAsync$work$slambdaClass_1;
+function AttoWorkerAsync$work$slambda_3() {
+  if (AttoWorkerAsync$work$slambdaClass_1 === VOID) {
+    class $ {
+      constructor(this$0, $block) {
+        this.q52_1 = this$0;
+        this.r52_1 = $block;
+      }
+      dd($completion) {
+        return this.q52_1.worker.h52(this.r52_1, $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWorkerAsync$work$slambdaClass_1 = $;
+  }
+  return AttoWorkerAsync$work$slambdaClass_1;
+}
+function AttoWorkerAsync$work$slambda_4(this$0, $block) {
+  var i = new (AttoWorkerAsync$work$slambda_3())(this$0, $block);
+  var l = ($completion) => i.dd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWorkerAsyncClass;
+function AttoWorkerAsync() {
+  if (AttoWorkerAsyncClass === VOID) {
+    class $ {
+      constructor(worker, dispatcher) {
+        dispatcher = dispatcher === VOID ? Dispatchers_getInstance().o13_1 : dispatcher;
+        this.worker = worker;
+        this.l52_1 = CoroutineScope(dispatcher.cl(SupervisorJob()));
+      }
+      s52() {
+        return this.worker;
+      }
+      workThreshold(threshold, target) {
+        return submit(this.l52_1, AttoWorkerAsync$work$slambda_0(this, threshold, target));
+      }
+      workNetwork(network, timestamp, target) {
+        return submit(this.l52_1, AttoWorkerAsync$work$slambda_2(this, network, timestamp, target));
+      }
+      workBlock(block) {
+        return submit(this.l52_1, AttoWorkerAsync$work$slambda_4(this, block));
+      }
+    }
+    initMetadataForClass($, 'AttoWorkerAsync');
+    AttoWorkerAsyncClass = $;
+  }
+  return AttoWorkerAsyncClass;
+}
+function toAsync(_this__u8e3s4, dispatcher) {
+  dispatcher = dispatcher === VOID ? Dispatchers_getInstance().o13_1 : dispatcher;
+  return new (AttoWorkerAsync())(_this__u8e3s4, dispatcher);
+}
+//region block: exports
+export {
+  AttoWorkerAsync as AttoWorkerAsync2mqicuktlp1kj,
+  toAsync as toAsync10i9ow1f352l5,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerAsync.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerAsync.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/commonMain/kotlin/cash/atto/commons/worker/AttoWorkerAsync.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["$threshold","$target","invoke","$completion","AttoWorkerAsync$work$slambda","AttoWorkerAsync$work$slambda$lambda","$network","$timestamp","$block","worker","dispatcher","<get-worker>","work","threshold","target","network","timestamp","block","toAsync","<this>"],"mappings":";;;;;;;;;;;;;;;;;kBAwBI,M,EACIA,U,EACAC,O;;;;;QACmCC,CAAAC,WAAAD,EAAE;A,QAA6B,OAA7B,IAAO,CAAP,KAAO,CAAP,MAAO,KAAK,IAAL,CAAK,KAAL,EAAgB,IAAhB,CAAgB,KAAhB,c;MAAsB,C;;;;;;;uCAA/BE,CAHvC,M,EACIJ,U,EACAC,OACmCG,E;;UAAAC,CAAAF,WAAAE,sB;;;C;;;;;kBAGvC,M,EACIC,Q,EACAC,U,EACAN,O;;;;;;QACmCC,CAAAC,WAAAD,EAAE;A,QAAsC,OAAtC,IAAO,CAAP,KAAO,CAAP,MAAO,KAAK,IAAL,CAAK,KAAL,EAAc,IAAd,CAAc,KAAd,EAAyB,IAAzB,CAAyB,KAAzB,c;MAA+B,C;;;;;;;uCAAxCE,CAJvC,M,EACIE,Q,EACAC,U,EACAN,OACmCG,E;;UAAAC,CAAAF,WAAAE,sB;;;C;;;;;kBAGvC,M,EAASG,M;;;;QAAuDN,CAAAC,WAAAD,EAAE;A,QAAiB,OAAjB,IAAO,CAAP,KAAO,CAAP,MAAO,KAAK,IAAL,CAAK,KAAL,c;MAAU,C;;;;;;;uCAAnBE,CAAhE,M,EAASI,MAAuDJ,E;;UAAAC,CAAAF,WAAAE,sB;;;C;;;;;kBAnBhEI,M,EACAC,U;qEAA8C,K;QAD9C,oB;QAGoB,4BAAe,cAAa,eAAb,CAAf,C;;SAHpBC,CAAAA,EAAA;A,QAAA,kB;MAAqB,C;mBAMrBC,CACIC,S,EACAC,MAFJF,EAG0B;A,QAA+C,OAAzC,OAAN,IAAM,CAAN,KAAM,EAAO,uDAAP,C;MAAwC,C;iBAGxEA,CACIG,O,EACAC,S,EACAF,MAHJF,EAI0B;A,QAAwD,OAAlD,OAAN,IAAM,CAAN,KAAM,EAAO,gEAAP,C;MAAiD,C;eAGjFA,CAASK,KAATL,EAAmD;A,QAAmC,OAA7B,OAAN,IAAM,CAAN,KAAM,EAAO,2CAAP,C;MAA4B,C;;;;;;;gBAGzFM,CAAIC,a,EAAmBT,UAAvBQ,EAAiG;A,+DAA5B,K;EAA6D,+BAAjB,aAAiB,EAAX,UAAW,C;AAAD,C;;;;;"}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerCache.mjs

@@ -0,0 +1,348 @@
+import { Dispatchers_getInstanceitgtkvqfcnx3 as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.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 { Exceptiondt2hlxn7j7vw as Exception } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { asyncz02dsa2nb2zt as async } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { Companion_instance34cvisfr2k5u0 as Companion_instance } from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.mjs';
+import {
+  isValid331pazae51bpo as isValid,
+  isValid2btj0q2riexuc as isValid_0,
+  getTargetgiem2nmxlcxo as getTarget,
+  AttoWorkTarget3v4zqc5kfdpel as AttoWorkTarget,
+} from '../../../../../commons-commons-core/cash/atto/commons/AttoWorkTarget.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  CoroutineScopelux7s7zphw7e as CoroutineScope_0,
+  cancel36mj9lv3a0whl as cancel,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { Companion_instance1fg0f1h3yksy8 as Companion_instance_0 } from '../../../../../commons-commons-core/cash/atto/commons/AttoInstant.mjs';
+import { SupervisorJobythnfxkr3jxc as SupervisorJob } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Supervisor.mjs';
+import { Mutex16li1l0asjv17 as Mutex } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/sync/Mutex.mjs';
+import { HashMap1a0ld5kgwhmhv as HashMap } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/HashMap.mjs';
+import { AttoWorker1vldrz4t7huug as AttoWorker } from './AttoWorker.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function cached(_this__u8e3s4, dispatcher) {
+  dispatcher = dispatcher === VOID ? Dispatchers_getInstance().o13_1 : dispatcher;
+  return new (AttoWorkerCache())(_this__u8e3s4, dispatcher);
+}
+function *_generator_invoke__zhh2q8($this, $this$async, $completion) {
+  try {
+    var tmp = $this.t52_1($this.u52_1, $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+    return tmp;
+  } catch ($p) {
+    if ($p instanceof Exception()) {
+      var e = $p;
+      // Inline function 'kotlinx.coroutines.sync.withLock' call
+      var this_0 = $this.v52_1.y52_1;
+      var tmp_0 = this_0.o1h(null, $completion);
+      if (tmp_0 === get_COROUTINE_SUSPENDED())
+        tmp_0 = yield tmp_0;
+      var tmp_1;
+      try {
+        tmp_1 = $this.v52_1.z52_1.n3($this.u52_1);
+      }finally {
+        this_0.z1g(null);
+      }
+      throw e;
+    } else {
+      throw $p;
+    }
+  }
+}
+function *_generator_delegateWork__9mcuq($this, target, delegate, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.y52_1;
+  var tmp = this_0.o1h(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    var deferred = $this.z52_1.j3(target);
+    if (!(deferred == null)) {
+      return deferred;
+    }
+    deferred = async($this.x52_1, VOID, VOID, AttoWorkerCache$delegateWork$slambda_0(delegate, target, $this));
+    var tmp0 = $this.z52_1;
+    // Inline function 'kotlin.collections.set' call
+    var value = deferred;
+    tmp0.m3(target, value);
+    return deferred;
+  }finally {
+    this_0.z1g(null);
+  }
+}
+function delegateWork($this, target, delegate, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_delegateWork__9mcuq.bind(VOID, $this, target, delegate), $completion);
+}
+function *_generator_work__qfjd2h($this, threshold, target, $completion) {
+  var tmp = delegateWork($this, target, AttoWorkerCache$work$slambda_0($this, threshold), $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var deferred = tmp;
+  var tmp_0 = deferred.pv($completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var work = tmp_0;
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.y52_1;
+  var tmp_1 = this_0.o1h(null, $completion);
+  if (tmp_1 === get_COROUTINE_SUSPENDED())
+    tmp_1 = yield tmp_1;
+  var tmp_2;
+  try {
+    tmp_2 = $this.z52_1.n3(target);
+  }finally {
+    this_0.z1g(null);
+  }
+  if (isValid(Companion_instance, threshold, target, work.value)) {
+    return work;
+  }
+  var tmp_3 = $this.f52(threshold, target, $completion);
+  if (tmp_3 === get_COROUTINE_SUSPENDED())
+    tmp_3 = yield tmp_3;
+  return tmp_3;
+}
+function *_generator_work__qfjd2h_0($this, network, timestamp, target, $completion) {
+  var tmp = delegateWork($this, target, AttoWorkerCache$work$slambda_2($this, network, timestamp), $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var deferred = tmp;
+  var tmp_0 = deferred.pv($completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var work = tmp_0;
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.y52_1;
+  var tmp_1 = this_0.o1h(null, $completion);
+  if (tmp_1 === get_COROUTINE_SUSPENDED())
+    tmp_1 = yield tmp_1;
+  var tmp_2;
+  try {
+    tmp_2 = $this.z52_1.n3(target);
+  }finally {
+    this_0.z1g(null);
+  }
+  if (isValid_0(Companion_instance, network, timestamp, target, work.value)) {
+    return work;
+  }
+  var tmp_3 = $this.g52(network, timestamp, target, $completion);
+  if (tmp_3 === get_COROUTINE_SUSPENDED())
+    tmp_3 = yield tmp_3;
+  return tmp_3;
+}
+function *_generator_work__qfjd2h_1($this, block, $completion) {
+  var tmp = getTarget(block);
+  var tmp_0 = delegateWork($this, tmp, AttoWorkerCache$work$slambda_4($this, block), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var deferred = tmp_0;
+  var tmp_1 = deferred.pv($completion);
+  if (tmp_1 === get_COROUTINE_SUSPENDED())
+    tmp_1 = yield tmp_1;
+  var work = tmp_1;
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.y52_1;
+  var tmp_2 = this_0.o1h(null, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  var tmp_3;
+  try {
+    tmp_3 = $this.z52_1.n3(getTarget(block));
+  }finally {
+    this_0.z1g(null);
+  }
+  var nextTarget = new (AttoWorkTarget())(block.hash.value);
+  var tmp_4 = delegateWork($this, nextTarget, AttoWorkerCache$work$slambda_6($this, block), $completion);
+  if (tmp_4 === get_COROUTINE_SUSPENDED())
+    tmp_4 = yield tmp_4;
+  if (work.isValid(block)) {
+    return work;
+  }
+  var tmp_5 = $this.h52(block, $completion);
+  if (tmp_5 === get_COROUTINE_SUSPENDED())
+    tmp_5 = yield tmp_5;
+  return tmp_5;
+}
+var AttoWorkerCache$delegateWork$slambdaClass;
+function AttoWorkerCache$delegateWork$slambda() {
+  if (AttoWorkerCache$delegateWork$slambdaClass === VOID) {
+    class $ {
+      constructor($delegate, $target, this$0) {
+        this.t52_1 = $delegate;
+        this.u52_1 = $target;
+        this.v52_1 = this$0;
+      }
+      b1c($this$async, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, $this$async), $completion);
+      }
+      bd(p1, $completion) {
+        return this.b1c((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWorkerCache$delegateWork$slambdaClass = $;
+  }
+  return AttoWorkerCache$delegateWork$slambdaClass;
+}
+function AttoWorkerCache$delegateWork$slambda_0($delegate, $target, this$0) {
+  var i = new (AttoWorkerCache$delegateWork$slambda())($delegate, $target, this$0);
+  var l = ($this$async, $completion) => i.b1c($this$async, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWorkerCache$work$slambdaClass;
+function AttoWorkerCache$work$slambda() {
+  if (AttoWorkerCache$work$slambdaClass === VOID) {
+    class $ {
+      constructor(this$0, $threshold) {
+        this.a53_1 = this$0;
+        this.b53_1 = $threshold;
+      }
+      c53(it, $completion) {
+        return this.a53_1.w52_1.f52(this.b53_1, it, $completion);
+      }
+      bd(p1, $completion) {
+        return this.c53(p1 instanceof AttoWorkTarget() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWorkerCache$work$slambdaClass = $;
+  }
+  return AttoWorkerCache$work$slambdaClass;
+}
+function AttoWorkerCache$work$slambda_0(this$0, $threshold) {
+  var i = new (AttoWorkerCache$work$slambda())(this$0, $threshold);
+  var l = (it, $completion) => i.c53(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWorkerCache$work$slambdaClass_0;
+function AttoWorkerCache$work$slambda_1() {
+  if (AttoWorkerCache$work$slambdaClass_0 === VOID) {
+    class $ {
+      constructor(this$0, $network, $timestamp) {
+        this.d53_1 = this$0;
+        this.e53_1 = $network;
+        this.f53_1 = $timestamp;
+      }
+      c53(it, $completion) {
+        return this.d53_1.w52_1.g52(this.e53_1, this.f53_1, it, $completion);
+      }
+      bd(p1, $completion) {
+        return this.c53(p1 instanceof AttoWorkTarget() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWorkerCache$work$slambdaClass_0 = $;
+  }
+  return AttoWorkerCache$work$slambdaClass_0;
+}
+function AttoWorkerCache$work$slambda_2(this$0, $network, $timestamp) {
+  var i = new (AttoWorkerCache$work$slambda_1())(this$0, $network, $timestamp);
+  var l = (it, $completion) => i.c53(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWorkerCache$work$slambdaClass_1;
+function AttoWorkerCache$work$slambda_3() {
+  if (AttoWorkerCache$work$slambdaClass_1 === VOID) {
+    class $ {
+      constructor(this$0, $block) {
+        this.g53_1 = this$0;
+        this.h53_1 = $block;
+      }
+      c53(it, $completion) {
+        return this.g53_1.w52_1.h52(this.h53_1, $completion);
+      }
+      bd(p1, $completion) {
+        return this.c53(p1 instanceof AttoWorkTarget() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWorkerCache$work$slambdaClass_1 = $;
+  }
+  return AttoWorkerCache$work$slambdaClass_1;
+}
+function AttoWorkerCache$work$slambda_4(this$0, $block) {
+  var i = new (AttoWorkerCache$work$slambda_3())(this$0, $block);
+  var l = (it, $completion) => i.c53(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWorkerCache$work$slambdaClass_2;
+function AttoWorkerCache$work$slambda_5() {
+  if (AttoWorkerCache$work$slambdaClass_2 === VOID) {
+    class $ {
+      constructor(this$0, $block) {
+        this.i53_1 = this$0;
+        this.j53_1 = $block;
+      }
+      c53(it, $completion) {
+        return this.i53_1.w52_1.g52(this.j53_1.network, Companion_instance_0.now(), it, $completion);
+      }
+      bd(p1, $completion) {
+        return this.c53(p1 instanceof AttoWorkTarget() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWorkerCache$work$slambdaClass_2 = $;
+  }
+  return AttoWorkerCache$work$slambdaClass_2;
+}
+function AttoWorkerCache$work$slambda_6(this$0, $block) {
+  var i = new (AttoWorkerCache$work$slambda_5())(this$0, $block);
+  var l = (it, $completion) => i.c53(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWorkerCacheClass;
+function AttoWorkerCache() {
+  if (AttoWorkerCacheClass === VOID) {
+    class $ {
+      constructor(delegate, dispatcher) {
+        dispatcher = dispatcher === VOID ? Dispatchers_getInstance().o13_1 : dispatcher;
+        this.w52_1 = delegate;
+        this.x52_1 = CoroutineScope_0(dispatcher.cl(SupervisorJob()));
+        this.y52_1 = Mutex();
+        this.z52_1 = HashMap().f8();
+      }
+      f52(threshold, target, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_work__qfjd2h.bind(VOID, this, threshold, target), $completion);
+      }
+      g52(network, timestamp, target, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_work__qfjd2h_0.bind(VOID, this, network, timestamp, target), $completion);
+      }
+      h52(block, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_work__qfjd2h_1.bind(VOID, this, block), $completion);
+      }
+      a6() {
+        this.z52_1.p3();
+        cancel(this.x52_1);
+        this.w52_1.a6();
+      }
+    }
+    initMetadataForClass($, 'AttoWorkerCache', VOID, VOID, [AttoWorker()], [2, 3, 1]);
+    AttoWorkerCacheClass = $;
+  }
+  return AttoWorkerCacheClass;
+}
+//region block: exports
+export {
+  cached as cached1s4yf99twpuut,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerCache.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerCache.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/commonMain/kotlin/cash/atto/commons/worker/AttoWorkerCache.kt","../../../../../../../../../../../../mnt/agent/work/44ec6e850d5c63f0/kotlinx-coroutines-core/common/src/sync/Mutex.kt","src/kotlin/collections/Maps.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["cached","<this>","dispatcher","<generator-invoke>","$completion","e","<generator-delegateWork>","target","delegate","deferred","delegateWork","<generator-work>","threshold","work","network","timestamp","block","nextTarget","$delegate","$target","invoke","AttoWorkerCache$delegateWork$slambda","AttoWorkerCache$delegateWork$slambda$lambda","$threshold","AttoWorkerCache$work$slambda","AttoWorkerCache$work$slambda$lambda","$network","$timestamp","$block","close"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAmIAA,CAAIC,a,EAAkBC,UAAtBF,EAA2F;A,+DAAvB,K;EAAwD,+BAAjB,aAAiB,EAAX,UAAW,C;AAAD,C;mCA7F/FG,CAAA,K,EAAA,W,EAAAC,WAAAD,EACR;A,EAAA,IAAI;A,QACsB,MAAT,KAAS,CAAT,KAAS,CAAO,KAAP,CAAO,KAAP,c;;;IAAtB,U;EACJ,C;mCAAuB;A,UAAdE,M;;mBACL,K,CAAA,K,CAAA,K;UC8EpB,mBAJuD,IAIvD,c;;;;MACO,I;gBD9EiB,KAAM,CAAN,KAAM,CAAN,KAAM,IAAO,KAAP,CAAO,KAAP,C;eCgFpB;A,QACN,WARmD,IAQnD,C;MACJ,C;MDhFoB,MAAM,C;IACV,C;;;;AAAA,C;wCAlBAC,CAAA,K,EACZC,M,EACAC,Q,EAFYJ,WAAAE,EAGM;A;eAClB,K,CAAA,K;MCwFJ,iBAJuD,IAIvD,c;;;;EACO,I;QAzF+CG,WAAe,eAAM,MAAN,C;IACzE,kBAAY,IAAZ,E,CAAkB;A,MAEd,OAAO,Q;IAAqB,C;IAAc,WAAiC,MAAN,KAAM,CAAN,KAAM,cAAM,+DAAN,C;eAO/E,K,CAAA,K;;gBACS,Q;IC6NL,QD9NE,MC8NF,EAAS,KAAT,C;ID7N2B,OAAO,Q;WAgFxB;A,IACN,WARmD,IAQnD,C;EACJ,C;ADxEA,C;qBAzBgBC,CAAA,K,EACZH,M,EACAC,Q,EAFYJ,WAAAM,E;;C;iCA2BCC,CAAA,K,EACbC,S,EACAL,M,EAFaH,WAAAO,EAGL;A,MAEJ,0BAAa,MAAb,EAAqB,gDAArB,c;;;MADJF,c;MAKoB,QAAT,QAAS,gB;;;MAApBI,Y;;eAEA,K,CAAA,K;MCsDJ,mBAJuD,IAIvD,c;;;;EACO,I;YDtDC,KAAM,CAAN,KAAM,IAAO,MAAP,C;WCwDJ;A,IACN,WARmD,IAQnD,C;EACJ,C;EDvDQ,IAAS,4BAAQ,SAAR,EAAmB,MAAnB,EAA2B,IAA3B,CAAgC,KAAhC,CAAT,C,CAAiD;A,IACjD,OAAO,I;EACX,C;MAEO,kBAAK,SAAL,EAAgB,MAAhB,c;;;EAAP,Y;AACJ,C;mCAEiBF,CAAA,K,EACbG,O,EACAC,S,EACAR,M,EAHaH,WAAAO,EAIL;A,MAEJ,0BAAa,MAAb,EAAqB,yDAArB,c;;;MADJF,c;MAKoB,QAAT,QAAS,gB;;;MAApBI,Y;;eAEA,K,CAAA,K;MC+BJ,mBAJuD,IAIvD,c;;;;EACO,I;YD/BC,KAAM,CAAN,KAAM,IAAO,MAAP,C;WCiCJ;A,IACN,WARmD,IAQnD,C;EACJ,C;EDhCQ,IAAS,8BAAQ,OAAR,EAAiB,SAAjB,EAA4B,MAA5B,EAAoC,IAApC,CAAyC,KAAzC,CAAT,C,CAA0D;A,IAC1D,OAAO,I;EACX,C;MAEO,kBAAK,OAAL,EAAc,SAAd,EAAyB,MAAzB,c;;;EAAP,Y;AACJ,C;mCAEiBF,CAAA,K,EAASK,K,EAATZ,WAAAO,EAAqC;A,YAE3B,UAAN,KAAM,C;MAAnB,iCAAgC,4CAAhC,c;;;MADJF,gB;MAKoB,QAAT,QAAS,gB;;;MAApBI,Y;;eAEA,K,CAAA,K;MCYJ,mBAJuD,IAIvD,c;;;;EACO,I;YDZC,KAAM,CAAN,KAAM,IAAa,UAAN,KAAM,CAAb,C;WCcJ;A,IACN,WARmD,IAQnD,C;EACJ,C;MDbII,oCAAgC,KAAhCA,CAAsC,IAAtCA,CAA2C,KAA3CA,C;MACA,4BAAa,UAAb,EAAyB,4CAAzB,c;;;EAII,IAAA,IAAK,SAAQ,KAAR,CAAL,C,CAAqB;A,IACrB,OAAO,I;EACX,C;MAEO,kBAAK,KAAL,c;;;EAAP,Y;AACJ,C;;;;;kBC3FwCC,S,EAAhCC,O,EAFiE,M;;;;;SAMQC,CAAA,W,EAAAhB,WAAAgB,E;;O;SAnCrF,E,EAAAhB,W;;;;;;;;;+CDsC4BiB,CARpBH,S,EADAC,O,EADY,MAUQE,E;;UAAAC,CAAA,W,EAAAlB,WAAAkB,oC;;;C;;;;;kBAiBP,M,EACbC,U;;;;SAIyBH,CAAA,E,EAAAhB,WAAAgB,EACjB;A,QAA2B,OAA3B,IAAS,CAAT,KAAS,CAAT,KAAS,KAAK,IAAL,CAAK,KAAL,EAAgB,EAAhB,c;MAAkB,C;SA7D3C,E,EAAAhB,W;;;;;;;;;uCA4DiCoB,CALZ,M,EACbD,UAIyBC,E;;UAAAC,CAAA,E,EAAArB,WAAAqB,2B;;;C;;;;;kBAiBZ,M,EACbC,Q,EACAC,U;;;;;SAIyBP,CAAA,E,EAAAhB,WAAAgB,EACjB;A,QAAoC,OAApC,IAAS,CAAT,KAAS,CAAT,KAAS,KAAK,IAAL,CAAK,KAAL,EAAc,IAAd,CAAc,KAAd,EAAyB,EAAzB,c;MAA2B,C;SApFpD,E,EAAAhB,W;;;;;;;;;uCAmFiCoB,CANZ,M,EACbE,Q,EACAC,UAIyBH,E;;UAAAC,CAAA,E,EAAArB,WAAAqB,2B;;;C;;;;;kBAiBZ,M,EAASG,M;;;;SAEcR,CAAA,E,EAAAhB,WAAAgB,EAC5B;A,QAAmB,OAAnB,IAAS,CAAT,KAAS,CAAT,KAAS,KAAK,IAAL,CAAK,KAAL,c;MAAU,C;SAvGnC,E,EAAAhB,W;;;;;;;;;uCAsG4CoB,CAFvB,M,EAASI,MAEcJ,E;;UAAAC,CAAA,E,EAAArB,WAAAqB,2B;;;C;;;;;kBAFvB,M,EAASG,M;;;;SAaGR,CAAA,E,EAAAhB,WAAAgB,EACrB;A,QAAkD,OAAlD,IAAS,CAAT,KAAS,CAAT,KAAS,KAAK,IAAL,CAAK,KAAL,CAAW,OAAX,EAAgC,0BAAhC,EAAuC,EAAvC,c;MAAyC,C;SAlH9D,E,EAAAhB,W;;;;;;;;;uCAiHiCoB,CAbZ,M,EAASI,MAaGJ,E;;UAAAC,CAAA,E,EAAArB,WAAAqB,2B;;;C;;;;;kBA7FrBjB,Q,EACRN,U;qEAA8C,K;QAD9C,qB;QAGoB,8BAAe,cAAa,eAAb,CAAf,C;QAEA,oB;QACA,2B;;SA6BHW,CACbD,S,EACAL,M,EAFaH,WAAAS,E;;O;SAsBAA,CACbC,O,EACAC,S,EACAR,M,EAHaH,WAAAS,E;;O;SAuBAA,CAASG,K,EAATZ,WAAAS,E;;O;QAwBRgB,CAAAA,EAAY;A,QACjB,IAAM,CAAN,KAAM,K;QACA,OAAN,IAAM,CAAN,KAAM,C;QACN,IAAS,CAAT,KAAS,K;MACb,C;;;;;;;;;;;"}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerCpu.js.mjs

@@ -0,0 +1,16 @@
+import { _UShort___init__impl__jigrne2jag2u7194ozm as _UShort___init__impl__jigrne } from '../../../../../kotlin-kotlin-stdlib/kotlin/UShort.mjs';
+import { cpu2fo88rg25ie8d as cpu } from './AttoWorkerCpu.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function cpu_0(_this__u8e3s4) {
+  return cpu(_this__u8e3s4, _UShort___init__impl__jigrne(1));
+}
+//region block: exports
+export {
+  cpu_0 as cpu37wc7dry26co,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerCpu.js.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerCpu.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/jsMain/kotlin/cash/atto/commons/worker/AttoWorkerCpu.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["cpu","<this>"],"mappings":";;;;;;cAEOA,CAAIC,aAAJD,EAA6C;A,EAAO,OAAP,mBAAI,+BAAJ,C;AAAM,C;;;;;"}