@attocash/commons-js 5.0.0

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

@@ -0,0 +1,73 @@
+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,
+  getThresholdcflwip0mgpox 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 { 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.c7p(threshold, target, $completion);
+}
+function work_0(block, $completion) {
+  var tmp;
+  if (block instanceof AttoOpenBlock()) {
+    tmp = block.y2u_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.d7p(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,
+  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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;"}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerJs.js.export.d.ts

@@ -0,0 +1,10 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface AttoWorkerJs {
+    workThreshold(threshold: string, target: Int8Array): Promise<AttoWork>;
+    workNetwork(network: AttoNetwork, timestamp: string, target: Int8Array): Promise<AttoWork>;
+    workBlock(block: AttoBlock): Promise<AttoWork>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.worker.AttoWorkerJs": unique symbol;
+    };
+}

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerJs.js.export.mjs

@@ -0,0 +1,4 @@
+//region block: pre-declaration
+//endregion
+
+//# sourceMappingURL=AttoWorkerJs.js.export.mjs.map

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerJs.js.export.mjs.map

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

package/commons-commons-worker/cash/atto/commons/worker/AttoWorkerJs.js.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 AttoWorkerJsClass;
+function AttoWorkerJs() {
+  if (AttoWorkerJsClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AttoWorkerJs');
+    AttoWorkerJsClass = $;
+  }
+  return AttoWorkerJsClass;
+}
+//region block: exports
+export {
+  AttoWorkerJs as AttoWorkerJs32dczaal5n02m,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerJs.js.mjs.map

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

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

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

@@ -0,0 +1,399 @@
+import { values1ix93lj72gxe9 as values } from '../../../../../commons-commons-core/cash/atto/commons/AttoNetwork.mjs';
+import { createSimpleEnumSerializer2guioz11kk1m0 as createSimpleEnumSerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/Enums.mjs';
+import { LazyThreadSafetyMode_PUBLICATION_getInstance3hlj875zwihx0 as LazyThreadSafetyMode_PUBLICATION_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Lazy.mjs';
+import { lazy1261dae0bgscp as lazy } from '../../../../../kotlin-kotlin-stdlib/kotlin/kotlin.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { PluginGeneratedSerialDescriptorqdzeg5asqhfg as PluginGeneratedSerialDescriptor } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginGeneratedSerialDescriptor.mjs';
+import { InstantMillisSerializer_getInstance119d7idybowz2 as InstantMillisSerializer_getInstance } from '../../../../../commons-commons-core/cash/atto/commons/serialiazer/InstantMillisSerializer.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { UnknownFieldExceptiona60e3a6v1xqo as UnknownFieldException } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/SerializationExceptions.mjs';
+import { StringSerializer_getInstance2wffkbpdux3h9 as StringSerializer_getInstance } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/Primitives.mjs';
+import {
+  typeParametersSerializers2likxjr48tr7y as typeParametersSerializers,
+  GeneratedSerializer1f7t7hssdd2ws as GeneratedSerializer,
+} from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginHelperInterfaces.mjs';
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  createThis2j2avj17cvnv2 as createThis,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { AttoWorkSerializer_getInstance2knpvs0pp68c1 as AttoWorkSerializer_getInstance } from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.mjs';
+import { throwMissingFieldException2cmke0v3ynf14 as throwMissingFieldException } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginExceptions.mjs';
+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 { toHexcxaq2tti5e5x as toHex } from '../../../../../commons-commons-core/cash/atto/commons/Extensions.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { AttoWorker1vldrz4t7huug as AttoWorker } from './AttoWorker.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function AttoWorkerOperations$Request$Companion$$childSerializers$_anonymous__k0cb7d() {
+  return createSimpleEnumSerializer('cash.atto.commons.AttoNetwork', values());
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        tmp.f7p_1 = [lazy(tmp_0, AttoWorkerOperations$Request$Companion$$childSerializers$_anonymous__k0cb7d), null, null];
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var $serializerClass;
+function $serializer() {
+  if ($serializerClass === VOID) {
+    class $ {
+      constructor() {
+        $serializer_instance = this;
+        var tmp0_serialDesc = new (PluginGeneratedSerialDescriptor())('cash.atto.commons.worker.AttoWorkerOperations.Request', this, 3);
+        tmp0_serialDesc.w14('network', false);
+        tmp0_serialDesc.w14('timestamp', false);
+        tmp0_serialDesc.w14('target', false);
+        this.g7p_1 = tmp0_serialDesc;
+      }
+      h7p(encoder, value) {
+        var tmp0_desc = this.g7p_1;
+        var tmp1_output = encoder.kx(tmp0_desc);
+        var tmp2_cached = Companion_getInstance().f7p_1;
+        tmp1_output.bz(tmp0_desc, 0, tmp2_cached[0].s1(), value.i7p_1);
+        tmp1_output.bz(tmp0_desc, 1, InstantMillisSerializer_getInstance(), value.j7p_1);
+        tmp1_output.zy(tmp0_desc, 2, value.k7p_1);
+        tmp1_output.lx(tmp0_desc);
+      }
+      ys(encoder, value) {
+        return this.h7p(encoder, value instanceof Request() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        var tmp0_desc = this.g7p_1;
+        var tmp1_flag = true;
+        var tmp2_index = 0;
+        var tmp3_bitMask0 = 0;
+        var tmp4_local0 = null;
+        var tmp5_local1 = null;
+        var tmp6_local2 = null;
+        var tmp7_input = decoder.kx(tmp0_desc);
+        var tmp8_cached = Companion_getInstance().f7p_1;
+        if (tmp7_input.zx()) {
+          tmp4_local0 = tmp7_input.wx(tmp0_desc, 0, tmp8_cached[0].s1(), tmp4_local0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          tmp5_local1 = tmp7_input.wx(tmp0_desc, 1, InstantMillisSerializer_getInstance(), tmp5_local1);
+          tmp3_bitMask0 = tmp3_bitMask0 | 2;
+          tmp6_local2 = tmp7_input.ux(tmp0_desc, 2);
+          tmp3_bitMask0 = tmp3_bitMask0 | 4;
+        } else
+          while (tmp1_flag) {
+            tmp2_index = tmp7_input.ay(tmp0_desc);
+            switch (tmp2_index) {
+              case -1:
+                tmp1_flag = false;
+                break;
+              case 0:
+                tmp4_local0 = tmp7_input.wx(tmp0_desc, 0, tmp8_cached[0].s1(), tmp4_local0);
+                tmp3_bitMask0 = tmp3_bitMask0 | 1;
+                break;
+              case 1:
+                tmp5_local1 = tmp7_input.wx(tmp0_desc, 1, InstantMillisSerializer_getInstance(), tmp5_local1);
+                tmp3_bitMask0 = tmp3_bitMask0 | 2;
+                break;
+              case 2:
+                tmp6_local2 = tmp7_input.ux(tmp0_desc, 2);
+                tmp3_bitMask0 = tmp3_bitMask0 | 4;
+                break;
+              default:
+                throw UnknownFieldException().ev(tmp2_index);
+            }
+          }
+        tmp7_input.lx(tmp0_desc);
+        return Request().l7p(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
+      }
+      xs() {
+        return this.g7p_1;
+      }
+      l15() {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        return [Companion_getInstance().f7p_1[0].s1(), InstantMillisSerializer_getInstance(), StringSerializer_getInstance()];
+      }
+    }
+    protoOf($).m15 = typeParametersSerializers;
+    initMetadataForObject($, '$serializer', VOID, VOID, [GeneratedSerializer()]);
+    $serializerClass = $;
+  }
+  return $serializerClass;
+}
+var $serializer_instance;
+function $serializer_getInstance() {
+  if ($serializer_instance === VOID)
+    new ($serializer())();
+  return $serializer_instance;
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+var $serializerClass_0;
+function $serializer_0() {
+  if ($serializerClass_0 === VOID) {
+    class $ {
+      constructor() {
+        $serializer_instance_0 = this;
+        var tmp0_serialDesc = new (PluginGeneratedSerialDescriptor())('cash.atto.commons.worker.AttoWorkerOperations.Response', this, 1);
+        tmp0_serialDesc.w14('work', false);
+        this.m7p_1 = tmp0_serialDesc;
+      }
+      n7p(encoder, value) {
+        var tmp0_desc = this.m7p_1;
+        var tmp1_output = encoder.kx(tmp0_desc);
+        tmp1_output.bz(tmp0_desc, 0, AttoWorkSerializer_getInstance(), value.o7p_1);
+        tmp1_output.lx(tmp0_desc);
+      }
+      ys(encoder, value) {
+        return this.n7p(encoder, value instanceof Response() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        var tmp0_desc = this.m7p_1;
+        var tmp1_flag = true;
+        var tmp2_index = 0;
+        var tmp3_bitMask0 = 0;
+        var tmp4_local0 = null;
+        var tmp5_input = decoder.kx(tmp0_desc);
+        if (tmp5_input.zx()) {
+          tmp4_local0 = tmp5_input.wx(tmp0_desc, 0, AttoWorkSerializer_getInstance(), tmp4_local0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+        } else
+          while (tmp1_flag) {
+            tmp2_index = tmp5_input.ay(tmp0_desc);
+            switch (tmp2_index) {
+              case -1:
+                tmp1_flag = false;
+                break;
+              case 0:
+                tmp4_local0 = tmp5_input.wx(tmp0_desc, 0, AttoWorkSerializer_getInstance(), tmp4_local0);
+                tmp3_bitMask0 = tmp3_bitMask0 | 1;
+                break;
+              default:
+                throw UnknownFieldException().ev(tmp2_index);
+            }
+          }
+        tmp5_input.lx(tmp0_desc);
+        return Response().p7p(tmp3_bitMask0, tmp4_local0, null);
+      }
+      xs() {
+        return this.m7p_1;
+      }
+      l15() {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        return [AttoWorkSerializer_getInstance()];
+      }
+    }
+    protoOf($).m15 = typeParametersSerializers;
+    initMetadataForObject($, '$serializer', VOID, VOID, [GeneratedSerializer()]);
+    $serializerClass_0 = $;
+  }
+  return $serializerClass_0;
+}
+var $serializer_instance_0;
+function $serializer_getInstance_0() {
+  if ($serializer_instance_0 === VOID)
+    new ($serializer_0())();
+  return $serializer_instance_0;
+}
+var RequestClass;
+function Request() {
+  if (RequestClass === VOID) {
+    class $ {
+      constructor(network, timestamp, target) {
+        Companion_getInstance();
+        this.i7p_1 = network;
+        this.j7p_1 = timestamp;
+        this.k7p_1 = target;
+      }
+      toString() {
+        return 'Request(network=' + this.i7p_1.toString() + ', timestamp=' + this.j7p_1.toString() + ', target=' + this.k7p_1 + ')';
+      }
+      hashCode() {
+        var result = this.i7p_1.hashCode();
+        result = imul(result, 31) + this.j7p_1.hashCode() | 0;
+        result = imul(result, 31) + getStringHashCode(this.k7p_1) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Request()))
+          return false;
+        var tmp0_other_with_cast = other instanceof Request() ? other : THROW_CCE();
+        if (!this.i7p_1.equals(tmp0_other_with_cast.i7p_1))
+          return false;
+        if (!this.j7p_1.equals(tmp0_other_with_cast.j7p_1))
+          return false;
+        if (!(this.k7p_1 === tmp0_other_with_cast.k7p_1))
+          return false;
+        return true;
+      }
+      static l7p(seen0, network, timestamp, target, serializationConstructorMarker) {
+        Companion_getInstance();
+        if (!(7 === (7 & seen0))) {
+          throwMissingFieldException(seen0, 7, $serializer_getInstance().g7p_1);
+        }
+        var $this = createThis(this);
+        $this.i7p_1 = network;
+        $this.j7p_1 = timestamp;
+        $this.k7p_1 = target;
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Request', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance});
+    RequestClass = $;
+  }
+  return RequestClass;
+}
+var ResponseClass;
+function Response() {
+  if (ResponseClass === VOID) {
+    class $ {
+      toString() {
+        return 'Response(work=' + this.o7p_1.toString() + ')';
+      }
+      hashCode() {
+        return this.o7p_1.hashCode();
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Response()))
+          return false;
+        var tmp0_other_with_cast = other instanceof Response() ? other : THROW_CCE();
+        if (!this.o7p_1.equals(tmp0_other_with_cast.o7p_1))
+          return false;
+        return true;
+      }
+      static p7p(seen0, work, serializationConstructorMarker) {
+        if (!(1 === (1 & seen0))) {
+          throwMissingFieldException(seen0, 1, $serializer_getInstance_0().m7p_1);
+        }
+        var $this = createThis(this);
+        $this.o7p_1 = work;
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Response', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_0});
+    ResponseClass = $;
+  }
+  return ResponseClass;
+}
+var $workCOROUTINE$Class;
+function $workCOROUTINE$() {
+  if ($workCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, network, timestamp, target, resultContinuation) {
+        super(resultContinuation);
+        this.y7p_1 = _this__u8e3s4;
+        this.z7p_1 = network;
+        this.a7q_1 = timestamp;
+        this.b7q_1 = target;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.c7q_1 = new (Request())(this.z7p_1, this.a7q_1, toHex(this.b7q_1));
+                this.ac_1 = 1;
+                suspendResult = this.y7p_1.d7q(this.c7q_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                var response = suspendResult;
+                return response.o7p_1;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $workCOROUTINE$Class = $;
+  }
+  return $workCOROUTINE$Class;
+}
+function work(network, timestamp, target, $completion) {
+  var tmp = new ($workCOROUTINE$())(this, network, timestamp, target, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var AttoWorkerOperationsClass;
+function AttoWorkerOperations() {
+  if (AttoWorkerOperationsClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AttoWorkerOperations', VOID, VOID, [AttoWorker()], [1, 3, 2]);
+    AttoWorkerOperationsClass = $;
+  }
+  return AttoWorkerOperationsClass;
+}
+//region block: init
+Companion_instance_0 = new (Companion_0())();
+//endregion
+//region block: exports
+export {
+  Request as Request2o3t1kyfw778m,
+  Response as Response3lq22kwwmc6vl,
+  AttoWorkerOperations as AttoWorkerOperations1gnkwfcdzd0wa,
+  work as work6ix6ca9lmac7,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerOperations.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/commonMain/kotlin/cash/atto/commons/worker/AttoWorkerOperations.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["AttoWorkerOperations$Request$Companion$$childSerializers$<anonymous>","serialize","encoder","value","deserialize","childSerializers","network","timestamp","target","result","doResume","response","work","$completion"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oFAsBIA,CAAAA,EAAA;A,EAAA,4E;AAMA,C;;;;;;;kBANA,I;;;;;QAAA,kH;;;;;;;;;;;;;;;;;;;;YAAA,2H;QAAA,qC;QAAA,uC;QAAA,oC;QAAA,4B;;SAAAC,CAAA,O,EAAA,KAAAA,EAAA;A,YAAA,sB;YAAA,mC;YAAA,2C;QAAA,8D;QAAA,gF;QAAA,yC;QAAA,yB;MAMA,C;SAO0yLC,O,EAAkBC,K;;;QAb5zLC,CAAA,OAAAA,EAAA;A,YAAA,sB;YAAA,gB;YAAA,c;YAAA,iB;YAAA,kB;YAAA,kB;YAAA,kB;YAAA,kC;YAAA,2C;QAAA,oB,CAAA;A,UAAA,2E;UAAA,iC;UAAA,6F;UAAA,iC;UAAA,yC;UAAA,iC;QAMA,C;iBANA,S,EAAA;A,YAAA,qC;YAAA,mB;mBAAA,E;gBAAA,iB;;mBAAA,C;gBAAA,2E;gBAAA,iC;;mBAAA,C;gBAAA,6F;gBAAA,iC;;mBAAA,C;gBAAA,yC;gBAAA,iC;;;gBAAA,4C;;UAMA,C;QANA,wB;QAAA,gF;MAMA,C;;;;SANAC,CAAAA,EAAA;A;;;QAAA,qH;MAMA,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAEA,4H;QAAA,kC;QAAA,4B;;SAAAJ,CAAA,O,EAAA,KAAAA,EAAA;A,YAAA,sB;YAAA,mC;QAAA,2E;QAAA,yB;MAGA,C;SAE0yLC,O,EAAkBC,K;;;QAL5zLC,CAAA,OAAAA,EAAA;A,YAAA,sB;YAAA,gB;YAAA,c;YAAA,iB;YAAA,kB;YAAA,kC;QAAA,oB,CAAA;A,UAAA,wF;UAAA,iC;QAGA,C;iBAHA,S,EAAA;A,YAAA,qC;YAAA,mB;mBAAA,E;gBAAA,iB;;mBAAA,C;gBAAA,wF;gBAAA,iC;;;gBAAA,4C;;UAGA,C;QAHA,wB;QAAA,uD;MAGA,C;;;;SAHAC,CAAAA,EAAA;A;;;QAAA,yC;MAGA,C;;;;;;;;;;;;;;;;;;kBATIC,O,EACAC,S,EAEAC,M;QALJ,uB;QAEI,oB;QACA,sB;QAEA,mB;;iBA3BR;A,QAAA,2H;MAAA,C;iBAAA;A,YAAAC,8B;QAAA,qD;QAAA,6D;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,kC;UAAA,Y;YAAA,uE;QAAA,mD;UAAA,Y;QAAA,mD;UAAA,Y;QAAA,iD;UAAA,Y;QAAA,W;MAAA,C;;QAsBI,uB;QAAA,yB;UAAA,qE;;;QAAA,qB;QAAA,uB;QAAA,oB;;;;;;;;;;;;;iBAtBJ;A,QAAA,qD;MAAA,C;iBAAA;A,QAAA,4B;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,mC;UAAA,Y;YAAA,wE;QAAA,mD;UAAA,Y;QAAA,W;MAAA,C;;QA8BI,yB;UAAA,uE;;;QAAA,kB;;;;;;;;;;;;;kBAlBA,a,EACI,O,EACA,S,EACA,M,EAHJ,kB;;;;;;;QAAAC,CAAAA,EAAA;A;;UAAA,I;;;;;gBAKI,kCAAsB,KAAtB,OAA+B,KAA/B,EAAiD,WAAP,KAAO,CAAjD,C;;gCACe,oBAAK,KAAL,O;;;;;;;oBAAfC,wB;uBACO,Q,CAAS,K;;;;;;;;;;;;;;MACpB,C;;;;;;;aARAC,CACIN,O,EACAC,S,EACAC,M,EAHJK,WAAAD,EAIY;A;;;;AAIZ,C;;;;;;;;;;;;;;;;;"}

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerRemote.js.export.d.ts

@@ -0,0 +1,3 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function createAttoWorker(url: string): AttoWorkerJs;

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerRemote.js.export.mjs

@@ -0,0 +1,12 @@
+import { createAttoWorker2428ybzyekz9b as createAttoWorker } from './AttoWorkerRemote.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+export {
+  createAttoWorker as createAttoWorker,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerRemote.js.export.mjs.map

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerRemote.js.export.mjs.map

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