@attocash/commons-js 5.3.0 → 6.0.0

package/commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsyncBuilder.js.mjs

@@ -0,0 +1,147 @@
+import { await3dv3uh1wzc6yf as await_0 } from '../../../../../commons-commons-core/cash/atto/commons/AttoFuture.js.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { AttoKeyIndex1s9zn741nq4qi as AttoKeyIndex } from '../../../../../commons-commons-core/cash/atto/commons/AttoKeyIndex.mjs';
+import {
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForFunctionReferencen3g5fpj34t8u as initMetadataForFunctionReference,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { toSigner372w8oykcr9o5 as toSigner } from '../../../../../commons-commons-core/cash/atto/commons/AttoSigner.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  Companion_getInstance3vz87v4c01z2t as Companion_getInstance,
+  toDuration7gy6v749ektt as toDuration,
+  Duration5ynfiptaqcrg as Duration,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/time/Duration.mjs';
+import { DurationUnit_SECONDS_getInstance3jias9ne5z4er as DurationUnit_SECONDS_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/time/DurationUnitJs.mjs';
+import { _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k } from '../../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import { toAttoAmountkv09taydvu7m as toAttoAmount } from '../../../../../commons-commons-core/cash/atto/commons/AttoAmount.mjs';
+import {
+  AttoWallet1whmu3qyz4let as AttoWallet,
+  startAutoReceiver1iqaoyf7nw3ww as startAutoReceiver,
+} from './AttoWallet.mjs';
+import { Dispatchers_getInstanceitgtkvqfcnx3 as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+import { AttoWalletAsync4aef45xgjaot as AttoWalletAsync } from './AttoWalletAsync.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoWalletAsyncBuilder$signerProvider$slambdaClass;
+function AttoWalletAsyncBuilder$signerProvider$slambda() {
+  if (AttoWalletAsyncBuilder$signerProvider$slambdaClass === VOID) {
+    class $ {
+      constructor($value) {
+        this.h3s_1 = $value;
+      }
+      i3s(index, $completion) {
+        return await_0(this.h3s_1.get(index), $completion);
+      }
+      hd(p1, $completion) {
+        return this.i3s(p1 instanceof AttoKeyIndex() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoWalletAsyncBuilder$signerProvider$slambdaClass = $;
+  }
+  return AttoWalletAsyncBuilder$signerProvider$slambdaClass;
+}
+function AttoWalletAsyncBuilder$signerProvider$slambda_0($value) {
+  var i = new (AttoWalletAsyncBuilder$signerProvider$slambda())($value);
+  var l = (index, $completion) => i.i3s(index, $completion);
+  l.$arity = 1;
+  return l;
+}
+var toSigner$refClass;
+function toSigner$ref() {
+  if (toSigner$refClass === VOID) {
+    class $ {
+      constructor(p0) {
+        this.j3s_1 = p0;
+      }
+      i3s(receiver, $completion) {
+        var tmp0 = this.j3s_1;
+        return toSigner(tmp0, receiver);
+      }
+      hd(p1, $completion) {
+        return this.i3s(p1 instanceof AttoKeyIndex() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForFunctionReference($, VOID, VOID, [1]);
+    toSigner$refClass = $;
+  }
+  return toSigner$refClass;
+}
+function toSigner$ref_0(p0) {
+  var i = new (toSigner$ref())(p0);
+  var l = (receiver, $completion) => i.i3s(receiver, $completion);
+  l.$arity = 1;
+  return l;
+}
+var AttoWalletAsyncBuilderClass;
+function AttoWalletAsyncBuilder() {
+  if (AttoWalletAsyncBuilderClass === VOID) {
+    class $ {
+      constructor(clientAsync, workerAsync) {
+        this.k3s_1 = clientAsync;
+        this.l3s_1 = workerAsync;
+        this.m3s_1 = null;
+        this.n3s_1 = null;
+        this.o3s_1 = null;
+        this.p3s_1 = null;
+        this.q3s_1 = null;
+      }
+      signerProviderFunction(value) {
+        // Inline function 'kotlin.apply' call
+        var tmp = this;
+        tmp.m3s_1 = AttoWalletAsyncBuilder$signerProvider$slambda_0(value);
+        return this;
+      }
+      signerProviderSeed(value) {
+        // Inline function 'kotlin.apply' call
+        var tmp = this;
+        tmp.m3s_1 = toSigner$ref_0(value);
+        return this;
+      }
+      r3s(monitor, minAmount, retryAfterSeconds, defaultRepresentativeAddressProvider) {
+        // Inline function 'kotlin.apply' call
+        this.n3s_1 = monitor;
+        this.o3s_1 = minAmount;
+        var tmp = this;
+        // Inline function 'kotlin.time.Companion.seconds' call
+        Companion_getInstance();
+        tmp.p3s_1 = toDuration(retryAfterSeconds, DurationUnit_SECONDS_getInstance());
+        this.q3s_1 = defaultRepresentativeAddressProvider;
+        return this;
+      }
+      enableAutoReceiver(monitor, minAmount, retryAfterSeconds, defaultRepresentativeAddressProvider, $super) {
+        minAmount = minAmount === VOID ? toAttoAmount(_ULong___init__impl__c78o9k(1n)) : minAmount;
+        return $super === VOID ? this.r3s(monitor, minAmount, retryAfterSeconds, defaultRepresentativeAddressProvider) : $super.r3s.call(this, monitor, minAmount, retryAfterSeconds, defaultRepresentativeAddressProvider);
+      }
+      build() {
+        var wallet = new (AttoWallet())(this.k3s_1.client, this.l3s_1.worker, ensureNotNull(this.m3s_1));
+        if (!(this.n3s_1 == null)) {
+          var tmp = ensureNotNull(this.n3s_1).s3k_1;
+          var tmp_0 = Dispatchers_getInstance().a15_1;
+          var tmp_1 = ensureNotNull(this.o3s_1);
+          var tmp_2 = this.p3s_1;
+          startAutoReceiver(wallet, tmp, tmp_0, tmp_1, ensureNotNull(tmp_2 == null ? null : new (Duration())(tmp_2)).zo_1, ensureNotNull(this.q3s_1));
+        }
+        return new (AttoWalletAsync())(wallet, Dispatchers_getInstance().a15_1);
+      }
+    }
+    initMetadataForClass($, 'AttoWalletAsyncBuilder');
+    AttoWalletAsyncBuilderClass = $;
+  }
+  return AttoWalletAsyncBuilderClass;
+}
+//region block: exports
+export {
+  AttoWalletAsyncBuilder as AttoWalletAsyncBuilderfm2srblqy3vj,
+};
+//endregion
+
+//# sourceMappingURL=AttoWalletAsyncBuilder.js.mjs.map

package/commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsyncBuilder.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["src/kotlin/util/Standard.kt","../../../../../../../commons-wallet/src/jsMain/kotlin/cash/atto/commons/wallet/AttoWalletAsyncBuilder.js.kt","src/kotlin/time/Duration.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["$value","invoke","$completion","AttoWalletAsyncBuilder$signerProvider$slambda","AttoWalletAsyncBuilder$signerProvider$slambda$lambda","p0","toSigner$ref","toSigner$ref$lambda","clientAsync","workerAsync","signerProvider","value","enableAutoReceiver","monitor","minAmount","retryAfterSeconds","defaultRepresentativeAddressProvider","enableAutoReceiver$default","build","wallet"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCwFA,M;;;SAG7EC,CAAE,K,EAAFC,WAAAD,EAAW;A,QAAuB,OAAN,QAAjB,IAAM,CAAN,KAAM,KAAI,KAAJ,CAAW,c;MAAM,C;SAvC7C,E,EAAAC,W;;;;;;;;;wDCgC6BC,CAFCH,MAEDG,E;;UAAAC,CAAE,K,EAAFF,WAAAE,8B;;;C;;;;;kBDegCC,E;QAAA,e;;SAAAJ,C,UAAAC,WAAAD,E;;QAAA,+B;O;SA/C7D,E,EAAAC,W;;;;;;;;;uBCsC6BI,CAAAD,EAAAC,E;;UAAAC,C,UAAAL,WAAAK,iC;;;C;;;;;kBAlBjBC,W,EACAC,W;QADR,wB;QACA,wB;QAEsE,iB;QACtB,iB;QACX,iB;QACD,iB;QACqC,iB;;4BAGlEC,CAAmBC,KAAnBD,EACH;A;kBAAA,I;QACI,YAAiB,sD;QACpB,OAFD,I;MAEA,C;wBAGGA,CAAmBC,KAAnBD,EACH;A;kBAAA,I;QACI,YAAiB,qB;QACpB,OAFD,I;MAEA,C;SAEGE,CACHC,O,EACAC,S,EACAC,iB,EACAC,oCAJGJ,EAMH;A;QAAA,IACS,SAAU,O;QADnB,IAES,SAAY,S;kBAFrB,I;;;QAGS,YC4EuC,WD5E1B,iBC4E0B,EAAwB,kCAAxB,C;QD/EhD,IAIS,SAAuC,oC;QAC/C,OALD,I;MAKA,C;wBAXGK,CACHJ,O,EACAC,S,EACAC,iB,EACAC,oC,QAJGC,E;yCAhBa,aAAJ,+BAAI,C;;O;WA6BbC,CAAAA,EAA6B;A,YAChCC,4BAAwB,IAAxBA,CAAwB,KAAxBA,CAAoC,MAApCA,EAA4C,IAA5CA,CAA4C,KAA5CA,CAAwD,MAAxDA,EAAgE,yBAAhEA,C;QAEI,oBAAW,IAAX,E,CAAiB;A,oBAEb,yB,CAAU,K;gDACE,K;sBACZ,yB;sBACA,I,CAAA,K;UAJG,kBAAP,MAAO,qBAIH,6DAJG,OAKH,yBALG,C;QAOX,C;QAEA,+BAAuB,MAAvB,4BAA2C,KAA3C,C;MACJ,C;;;;;;;;;;;"}

package/{commons-commons-worker/cash/atto/commons/worker/AttoWorkerJs.js.mjs → commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsyncBuilder.mjs}

@@ -4,19 +4,14 @@ import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/k
 //endregion
 //region block: pre-declaration
 //endregion
-var AttoWorkerJsClass;
-function AttoWorkerJs() {
-  if (AttoWorkerJsClass === VOID) {
+var AttoSignerProviderClass;
+function AttoSignerProvider() {
+  if (AttoSignerProviderClass === VOID) {
     class $ {}
-    initMetadataForInterface($, 'AttoWorkerJs');
-    AttoWorkerJsClass = $;
+    initMetadataForInterface($, 'AttoSignerProvider');
+    AttoSignerProviderClass = $;
   }
-  return AttoWorkerJsClass;
+  return AttoSignerProviderClass;
 }
-//region block: exports
-export {
-  AttoWorkerJs as AttoWorkerJs32dczaal5n02m,
-};
-//endregion
 
-//# sourceMappingURL=AttoWorkerJs.js.mjs.map
+//# sourceMappingURL=AttoWalletAsyncBuilder.mjs.map

package/commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsyncBuilder.mjs.map

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

package/commons-commons-wallet.mjs

@@ -0,0 +1,8 @@
+//region block: pre-declaration
+//endregion
+//region block: exports
+export * from './commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsync.export.mjs';
+export * from './commons-commons-wallet/cash/atto/commons/wallet/AttoWalletAsyncBuilder.js.export.mjs';
+//endregion
+
+//# sourceMappingURL=commons-commons-wallet.mjs.map

package/{commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerRemote.js.export.mjs.map → commons-commons-wallet.mjs.map}

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

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

@@ -5,15 +5,9 @@ import {
 import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
 import {
   Companion_instance34cvisfr2k5u0 as Companion_instance,
-  getThresholdcflwip0mgpox as getThreshold,
+  getThreshold18fzjxt4pr6o4 as getThreshold,
 } from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.mjs';
-import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
-import { toString1pkumu07cwy4m as toString } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
-import {
-  PreviousSupport1um4ogj9ve97w as PreviousSupport,
-  AttoOpenBlock12k0m6lgjqi4d as AttoOpenBlock,
-} from '../../../../../commons-commons-core/cash/atto/commons/AttoBlock.mjs';
-import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.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
@@ -34,21 +28,11 @@ function Companion_getInstance() {
 }
 function work(network, timestamp, target, $completion) {
   var threshold = getThreshold(Companion_instance, network, timestamp);
-  return this.c7t(threshold, target, $completion);
+  return this.k3m(threshold, target, $completion);
 }
 function work_0(block, $completion) {
-  var tmp;
-  if (block instanceof AttoOpenBlock()) {
-    tmp = block.m2v_1.value;
-  } else {
-    if (isInterface(block, PreviousSupport())) {
-      tmp = block.previous.value;
-    } else {
-      throw IllegalArgumentException().u('Unsupported block type ' + toString(block));
-    }
-  }
-  var target = tmp;
-  return this.d7t(block.network, block.timestamp, target, $completion);
+  var target = getTarget(block);
+  return this.l3m(block.network, block.timestamp, target, $completion);
 }
 var AttoWorkerClass;
 function AttoWorker() {

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

@@ -1 +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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAkBIA,CACIC,O,EACAC,S,EACAC,M,EAHJC,WAAAJ,EAIY;A,MACRK,YAAyB,iCAAa,OAAb,EAAsB,SAAtB,C;EACzB,OAAO,SAAK,SAAL,EAAgB,MAAhB,c;AACX,C;eAEAL,CAAiBM,K,EAAjBF,WAAAJ,EAA6C;A;EAGjC,IADE,KACF,4B;UAAoB,K,CAAM,K,CAAU,K;;IACpC,gBAFE,KAEF,qB;YAAsB,K,CAAM,Q,CAAS,K;;MAC7B,mCAAgC,yBAAhC,YAAwD,KAAxD,E;;;MAJhBG,Y;EAMA,OAAO,SAAK,KAAL,CAAW,OAAX,EAAoB,KAApB,CAA0B,SAA1B,EAAqC,MAArC,c;AACX,C;;;;;;;;;;;;;;;;;"}
+{"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.n3m_1 = this$0;
+        this.o3m_1 = $threshold;
+        this.p3m_1 = $target;
+      }
+      jd($completion) {
+        return this.n3m_1.worker.k3m(this.o3m_1, this.p3m_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.jd($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.r3m_1 = this$0;
+        this.s3m_1 = $network;
+        this.t3m_1 = $timestamp;
+        this.u3m_1 = $target;
+      }
+      jd($completion) {
+        return this.r3m_1.worker.l3m(this.s3m_1, this.t3m_1, this.u3m_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.jd($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.v3m_1 = this$0;
+        this.w3m_1 = $block;
+      }
+      jd($completion) {
+        return this.v3m_1.worker.m3m(this.w3m_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.jd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWorkerAsyncClass;
+function AttoWorkerAsync() {
+  if (AttoWorkerAsyncClass === VOID) {
+    class $ {
+      constructor(worker, dispatcher) {
+        dispatcher = dispatcher === VOID ? Dispatchers_getInstance().a15_1 : dispatcher;
+        this.worker = worker;
+        this.q3m_1 = CoroutineScope(dispatcher.il(SupervisorJob()));
+      }
+      x3m() {
+        return this.worker;
+      }
+      workThreshold(threshold, target) {
+        return submit(this.q3m_1, AttoWorkerAsync$work$slambda_0(this, threshold, target));
+      }
+      workNetwork(network, timestamp, target) {
+        return submit(this.q3m_1, AttoWorkerAsync$work$slambda_2(this, network, timestamp, target));
+      }
+      workBlock(block) {
+        return submit(this.q3m_1, AttoWorkerAsync$work$slambda_4(this, block));
+      }
+    }
+    initMetadataForClass($, 'AttoWorkerAsync');
+    AttoWorkerAsyncClass = $;
+  }
+  return AttoWorkerAsyncClass;
+}
+function toAsync(_this__u8e3s4, dispatcher) {
+  dispatcher = dispatcher === VOID ? Dispatchers_getInstance().a15_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;;;;;"}