@attocash/commons-test 6.0.0

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

@@ -0,0 +1,203 @@
+import { SupervisorJobythnfxkr3jxc as SupervisorJob } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Supervisor.mjs';
+import { Dispatchers_getInstanceitgtkvqfcnx3 as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+import { _UShort___get_data__impl__g0245hlms5v6vgvnl as _UShort___get_data__impl__g0245 } from '../../../../../kotlin-kotlin-stdlib/kotlin/UShort.mjs';
+import { Job13y4jkazwjho0 as Job } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Job.mjs';
+import {
+  work3ude3jw3qwf7i as work,
+  work30rrtknet8hfg as work_0,
+  AttoWorker1vldrz4t7huug as AttoWorker,
+} from './AttoWorker.mjs';
+import { protoOf180f3jzyo7rfj as protoOf } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} 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,
+  isValid18m1w55cgubl3 as isValid,
+  AttoWorkrxvyu0kmlxrx as AttoWork,
+} from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import {
+  cancel36mj9lv3a0whl as cancel,
+  get_isActivehakov5bm97hw as get_isActive,
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  CoroutineScopelux7s7zphw7e as CoroutineScope_0,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  fromInt2ii0rejb1w62w as fromInt,
+  multiply2k9eolhnz1bjv as multiply,
+  add2suhfggl4zvkk as add,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
+import {
+  _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
+  _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import { toByteArray1xevcsrk0l409 as toByteArray } from '../../../../../commons-commons-core/cash/atto/commons/Extensions.mjs';
+import { get_ONEazvfdh9ju3d4 as get_ONE } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { CompletableDeferred2lnqvsbvx74d3 as CompletableDeferred } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CompletableDeferred.mjs';
+import { ulongDivide3e52ct8hxp5n7 as ulongDivide } from '../../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
+import { launch1c91vkjzdi9sd as launch } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Builders.common.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function cpu(_this__u8e3s4, parallelism) {
+  return new (AttoWorkerCpu())(parallelism);
+}
+var AttoWorkerCpuClass;
+function AttoWorkerCpu() {
+  if (AttoWorkerCpuClass === VOID) {
+    class $ {
+      constructor(parallelism) {
+        this.k53_1 = parallelism;
+        this.l53_1 = SupervisorJob();
+        var tmp = this;
+        var tmp_0 = Dispatchers_getInstance().o13_1;
+        // Inline function 'kotlin.UShort.toInt' call
+        var this_0 = this.k53_1;
+        var tmp$ret$0 = _UShort___get_data__impl__g0245(this_0) & 65535;
+        tmp.m53_1 = tmp_0.oz(tmp$ret$0);
+      }
+      f52(threshold, target, $completion) {
+        var controller = new (WorkerController())(this.m53_1.cl(this.l53_1).cl(Job()), this.k53_1, threshold, target.a4t_1);
+        return controller.s53($completion);
+      }
+      a6() {
+        this.l53_1.mu();
+      }
+    }
+    protoOf($).g52 = work;
+    protoOf($).h52 = work_0;
+    initMetadataForClass($, 'AttoWorkerCpu', VOID, VOID, [AttoWorker()], [2, 3, 1]);
+    AttoWorkerCpuClass = $;
+  }
+  return AttoWorkerCpuClass;
+}
+function tryComplete($this, work) {
+  if (!isValid(Companion_instance, $this.o53_1, $this.p53_1, work)) {
+    return false;
+  }
+  // Inline function 'kotlin.collections.copyOf' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$1 = work.slice();
+  return $this.r53_1.iz(new (AttoWork())(tmp$ret$1));
+}
+function incrementByteArray($this, byteArray) {
+  var carry = 1;
+  var inductionVariable = 0;
+  var last = byteArray.length - 1 | 0;
+  if (inductionVariable <= last)
+    $l$loop: do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var sum = (byteArray[i] & 255) + carry | 0;
+      byteArray[i] = toByte(sum);
+      carry = sum > 255 ? 1 : 0;
+    }
+     while (carry !== 0 && inductionVariable <= last);
+}
+function WorkerController$result$lambda(this$0) {
+  return (it) => {
+    cancel(this$0.q53_1);
+    return Unit_instance;
+  };
+}
+var WorkerController$calculate$slambdaClass;
+function WorkerController$calculate$slambda() {
+  if (WorkerController$calculate$slambdaClass === VOID) {
+    class $ {
+      constructor($i, $rangeSize, this$0) {
+        this.t53_1 = $i;
+        this.u53_1 = $rangeSize;
+        this.v53_1 = this$0;
+      }
+      b1c($this$launch, $completion) {
+        // Inline function 'kotlin.toULong' call
+        var this_0 = this.t53_1;
+        var tmp0 = _ULong___init__impl__c78o9k(fromInt(this_0));
+        // Inline function 'kotlin.ULong.times' call
+        var other = this.u53_1;
+        var start = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
+        // Inline function 'kotlin.ULong.plus' call
+        var other_0 = this.u53_1;
+        var end = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(start), _ULong___get_data__impl__fggpzb(other_0)));
+        var work = toByteArray(start);
+        var current = start;
+        while (!(current === end) && get_isActive($this$launch)) {
+          if (tryComplete(this.v53_1, work))
+            return Unit_instance;
+          incrementByteArray(this.v53_1, work);
+          // Inline function 'kotlin.ULong.inc' call
+          var this_1 = current;
+          current = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(this_1), get_ONE()));
+        }
+      }
+      bd(p1, $completion) {
+        return this.b1c((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    WorkerController$calculate$slambdaClass = $;
+  }
+  return WorkerController$calculate$slambdaClass;
+}
+function WorkerController$calculate$slambda_0($i, $rangeSize, this$0) {
+  var i = new (WorkerController$calculate$slambda())($i, $rangeSize, this$0);
+  var l = ($this$launch, $completion) => i.b1c($this$launch, $completion);
+  l.$arity = 1;
+  return l;
+}
+var WorkerControllerClass;
+function WorkerController() {
+  if (WorkerControllerClass === VOID) {
+    class $ {
+      constructor(context, parallelism, threshold, target) {
+        this.n53_1 = parallelism;
+        this.o53_1 = threshold;
+        this.p53_1 = target;
+        this.q53_1 = CoroutineScope_0(context);
+        var tmp = this;
+        // Inline function 'kotlin.apply' call
+        var this_0 = CompletableDeferred();
+        this_0.eu(WorkerController$result$lambda(this));
+        tmp.r53_1 = this_0;
+      }
+      s53($completion) {
+        var tmp0 = _ULong___init__impl__c78o9k(-1n);
+        // Inline function 'kotlin.UShort.toULong' call
+        var this_0 = this.n53_1;
+        // Inline function 'kotlin.ULong.div' call
+        var other = _ULong___init__impl__c78o9k(fromInt(_UShort___get_data__impl__g0245(this_0)) & 65535n);
+        var rangeSize = ulongDivide(tmp0, other);
+        // Inline function 'kotlin.UShort.toInt' call
+        var this_1 = this.n53_1;
+        // Inline function 'kotlin.repeat' call
+        var times = _UShort___get_data__impl__g0245(this_1) & 65535;
+        var inductionVariable = 0;
+        if (inductionVariable < times)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            launch(this.q53_1, VOID, VOID, WorkerController$calculate$slambda_0(index, rangeSize, this));
+          }
+           while (inductionVariable < times);
+        return this.r53_1.pv($completion);
+      }
+    }
+    initMetadataForClass($, 'WorkerController', VOID, VOID, VOID, [0]);
+    WorkerControllerClass = $;
+  }
+  return WorkerControllerClass;
+}
+//region block: exports
+export {
+  cpu as cpu2fo88rg25ie8d,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkerCpu.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-worker/src/commonMain/kotlin/cash/atto/commons/worker/AttoWorkerCpu.kt","unsigned/src/kotlin/UShort.kt","js/src/generated/_ArraysJs.kt","src/kotlin/util/Standard.kt","unsigned/src/kotlin/ULong.kt"],"sourcesContent":[null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["cpu","<this>","parallelism","work","threshold","target","$completion","controller","close","tryComplete","incrementByteArray","byteArray","carry","i","sum","WorkerController$result$lambda","WorkerController$result$lambda$lambda","$rangeSize","invoke","start","end","current","WorkerController$calculate$slambda","WorkerController$calculate$slambda$lambda","context","calculate","rangeSize","index"],"mappings":"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"}

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

@@ -0,0 +1,351 @@
+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,
+  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 { AttoInstantAsLongSerializer_getInstance2fa8f20kvnk9j as AttoInstantAsLongSerializer_getInstance } from '../../../../../commons-commons-core/cash/atto/commons/AttoInstant.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 { AttoWorkAsStringSerializer_getInstance1rziw3lwqzo0n as AttoWorkAsStringSerializer_getInstance } from '../../../../../commons-commons-core/cash/atto/commons/AttoWork.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 { 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 { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.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.w53_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.a25('network', false);
+        tmp0_serialDesc.a25('timestamp', false);
+        tmp0_serialDesc.a25('target', false);
+        this.x53_1 = tmp0_serialDesc;
+      }
+      y53(encoder, value) {
+        var tmp0_desc = this.x53_1;
+        var tmp1_output = encoder.m1x(tmp0_desc);
+        var tmp2_cached = Companion_getInstance().w53_1;
+        tmp1_output.d1z(tmp0_desc, 0, tmp2_cached[0].z1(), value.z53_1);
+        tmp1_output.d1z(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), value.a54_1);
+        tmp1_output.b1z(tmp0_desc, 2, value.b54_1);
+        tmp1_output.n1x(tmp0_desc);
+      }
+      a1t(encoder, value) {
+        return this.y53(encoder, value instanceof Request() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        var tmp0_desc = this.x53_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.m1x(tmp0_desc);
+        var tmp8_cached = Companion_getInstance().w53_1;
+        if (tmp7_input.b1y()) {
+          tmp4_local0 = tmp7_input.y1x(tmp0_desc, 0, tmp8_cached[0].z1(), tmp4_local0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+          tmp5_local1 = tmp7_input.y1x(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), tmp5_local1);
+          tmp3_bitMask0 = tmp3_bitMask0 | 2;
+          tmp6_local2 = tmp7_input.w1x(tmp0_desc, 2);
+          tmp3_bitMask0 = tmp3_bitMask0 | 4;
+        } else
+          while (tmp1_flag) {
+            tmp2_index = tmp7_input.c1y(tmp0_desc);
+            switch (tmp2_index) {
+              case -1:
+                tmp1_flag = false;
+                break;
+              case 0:
+                tmp4_local0 = tmp7_input.y1x(tmp0_desc, 0, tmp8_cached[0].z1(), tmp4_local0);
+                tmp3_bitMask0 = tmp3_bitMask0 | 1;
+                break;
+              case 1:
+                tmp5_local1 = tmp7_input.y1x(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), tmp5_local1);
+                tmp3_bitMask0 = tmp3_bitMask0 | 2;
+                break;
+              case 2:
+                tmp6_local2 = tmp7_input.w1x(tmp0_desc, 2);
+                tmp3_bitMask0 = tmp3_bitMask0 | 4;
+                break;
+              default:
+                throw UnknownFieldException().v1u(tmp2_index);
+            }
+          }
+        tmp7_input.n1x(tmp0_desc);
+        return Request().c54(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
+      }
+      z1s() {
+        return this.x53_1;
+      }
+      p25() {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        return [Companion_getInstance().w53_1[0].z1(), AttoInstantAsLongSerializer_getInstance(), StringSerializer_getInstance()];
+      }
+    }
+    protoOf($).q25 = 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.a25('work', false);
+        this.d54_1 = tmp0_serialDesc;
+      }
+      e54(encoder, value) {
+        var tmp0_desc = this.d54_1;
+        var tmp1_output = encoder.m1x(tmp0_desc);
+        tmp1_output.d1z(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), value.f54_1);
+        tmp1_output.n1x(tmp0_desc);
+      }
+      a1t(encoder, value) {
+        return this.e54(encoder, value instanceof Response() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        var tmp0_desc = this.d54_1;
+        var tmp1_flag = true;
+        var tmp2_index = 0;
+        var tmp3_bitMask0 = 0;
+        var tmp4_local0 = null;
+        var tmp5_input = decoder.m1x(tmp0_desc);
+        if (tmp5_input.b1y()) {
+          tmp4_local0 = tmp5_input.y1x(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), tmp4_local0);
+          tmp3_bitMask0 = tmp3_bitMask0 | 1;
+        } else
+          while (tmp1_flag) {
+            tmp2_index = tmp5_input.c1y(tmp0_desc);
+            switch (tmp2_index) {
+              case -1:
+                tmp1_flag = false;
+                break;
+              case 0:
+                tmp4_local0 = tmp5_input.y1x(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), tmp4_local0);
+                tmp3_bitMask0 = tmp3_bitMask0 | 1;
+                break;
+              default:
+                throw UnknownFieldException().v1u(tmp2_index);
+            }
+          }
+        tmp5_input.n1x(tmp0_desc);
+        return Response().g54(tmp3_bitMask0, tmp4_local0, null);
+      }
+      z1s() {
+        return this.d54_1;
+      }
+      p25() {
+        // Inline function 'kotlin.arrayOf' call
+        // Inline function 'kotlin.js.unsafeCast' call
+        // Inline function 'kotlin.js.asDynamic' call
+        return [AttoWorkAsStringSerializer_getInstance()];
+      }
+    }
+    protoOf($).q25 = 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;
+}
+function *_generator_work__qfjd2h($this, network, timestamp, target, $completion) {
+  var request = new (Request())(network, timestamp, toHex(target.a4t_1));
+  var tmp = $this.h54(request, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var response = tmp;
+  return response.f54_1;
+}
+var RequestClass;
+function Request() {
+  if (RequestClass === VOID) {
+    class $ {
+      constructor(network, timestamp, target) {
+        Companion_getInstance();
+        this.z53_1 = network;
+        this.a54_1 = timestamp;
+        this.b54_1 = target;
+      }
+      toString() {
+        return 'Request(network=' + this.z53_1.toString() + ', timestamp=' + this.a54_1.toString() + ', target=' + this.b54_1 + ')';
+      }
+      hashCode() {
+        var result = this.z53_1.hashCode();
+        result = imul(result, 31) + this.a54_1.hashCode() | 0;
+        result = imul(result, 31) + getStringHashCode(this.b54_1) | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Request()))
+          return false;
+        if (!this.z53_1.equals(other.z53_1))
+          return false;
+        if (!this.a54_1.equals(other.a54_1))
+          return false;
+        if (!(this.b54_1 === other.b54_1))
+          return false;
+        return true;
+      }
+      static c54(seen0, network, timestamp, target, serializationConstructorMarker) {
+        Companion_getInstance();
+        if (!(7 === (7 & seen0))) {
+          throwMissingFieldException(seen0, 7, $serializer_getInstance().x53_1);
+        }
+        var $this = createThis(this);
+        $this.z53_1 = network;
+        $this.a54_1 = timestamp;
+        $this.b54_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.f54_1.toString() + ')';
+      }
+      hashCode() {
+        return this.f54_1.hashCode();
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof Response()))
+          return false;
+        if (!this.f54_1.equals(other.f54_1))
+          return false;
+        return true;
+      }
+      static g54(seen0, work, serializationConstructorMarker) {
+        if (!(1 === (1 & seen0))) {
+          throwMissingFieldException(seen0, 1, $serializer_getInstance_0().d54_1);
+        }
+        var $this = createThis(this);
+        $this.f54_1 = work;
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'Response', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_0});
+    ResponseClass = $;
+  }
+  return ResponseClass;
+}
+function work(network, timestamp, target, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_work__qfjd2h.bind(VOID, this, network, timestamp, target), $completion);
+}
+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 work2rr5dmle2rak9,
+};
+//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","<generator-work>","network","timestamp","target","$completion","request","response","result","work"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oFAsBIA,CAAAA,EAAA;A,EAAA,4E;AAKA,C;;;;;;;kBALA,I;;;;;QAAA,kH;;;;;;;;;;;;;;;;;;;;YAAA,2H;QAAA,qC;QAAA,uC;QAAA,oC;QAAA,4B;;SAAAC,CAAA,O,EAAA,KAAAA,EAAA;A,YAAA,sB;YAAA,oC;YAAA,2C;QAAA,+D;QAAA,qF;QAAA,0C;QAAA,0B;MAKA,C;UAOo2LC,O,EAAkBC,K;;;SAZt3LC,CAAA,OAAAA,EAAA;A,YAAA,sB;YAAA,gB;YAAA,c;YAAA,iB;YAAA,kB;YAAA,kB;YAAA,kB;YAAA,mC;YAAA,2C;QAAA,qB,CAAA;A,UAAA,4E;UAAA,iC;UAAA,kG;UAAA,iC;UAAA,0C;UAAA,iC;QAKA,C;iBALA,S,EAAA;A,YAAA,sC;YAAA,mB;mBAAA,E;gBAAA,iB;;mBAAA,C;gBAAA,4E;gBAAA,iC;;mBAAA,C;gBAAA,kG;gBAAA,iC;;mBAAA,C;gBAAA,0C;gBAAA,iC;;;gBAAA,6C;;UAKA,C;QALA,yB;QAAA,gF;MAKA,C;;;;SALAC,CAAAA,EAAA;A;;;QAAA,yH;MAKA,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAEA,4H;QAAA,kC;QAAA,4B;;SAAAJ,CAAA,O,EAAA,KAAAA,EAAA;A,YAAA,sB;YAAA,oC;QAAA,oF;QAAA,0B;MAGA,C;UAEo2LC,O,EAAkBC,K;;;SALt3LC,CAAA,OAAAA,EAAA;A,YAAA,sB;YAAA,gB;YAAA,c;YAAA,iB;YAAA,kB;YAAA,mC;QAAA,qB,CAAA;A,UAAA,iG;UAAA,iC;QAGA,C;iBAHA,S,EAAA;A,YAAA,sC;YAAA,mB;mBAAA,E;gBAAA,iB;;mBAAA,C;gBAAA,iG;gBAAA,iC;;;gBAAA,6C;;UAGA,C;QAHA,yB;QAAA,uD;MAGA,C;;;;SAHAC,CAAAA,EAAA;A;;;QAAA,iD;MAGA,C;;;;;;;;;;;;;;iCApBiBC,CAAA,K,EACbC,O,EACAC,S,EACAC,M,EAHaC,WAAAJ,EAIL;A,MACRK,0BAAsB,OAAtBA,EAA+B,SAA/BA,EAAuD,MAAb,MAAa,CAAN,KAAM,CAAvDA,C;MACe,gBAAK,OAAL,c;;;MAAfC,c;EACA,OAAO,QAAP,CAAgB,K;AACpB,C;;;;;kBAIIL,O,EACAC,S,EACAC,M;QAJJ,uB;QAEI,oB;QACA,sB;QACA,mB;;iBA1BR;A,QAAA,2H;MAAA,C;iBAAA;A,YAAAI,8B;QAAA,qD;QAAA,6D;QAAA,a;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,kC;UAAA,Y;QAAA,oC;UAAA,Y;QAAA,oC;UAAA,Y;QAAA,kC;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;QAAA,oC;UAAA,Y;QAAA,W;MAAA,C;;QA6BI,yB;UAAA,uE;;;QAAA,kB;;;;;;;;;aAjBiBC,CACbP,O,EACAC,S,EACAC,M,EAHaC,WAAAI,E;;C;;;;;;;;;;;;;;;;;"}

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerAsyncBuilder.web.export.d.mts

@@ -0,0 +1,15 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoWorkerAsyncBuilder {
+    constructor(url: string);
+    headers(value: KtMap<string, string>): AttoWorkerAsyncBuilder;
+    header(name: string, value: string): AttoWorkerAsyncBuilder;
+    cached(value: boolean): AttoWorkerAsyncBuilder;
+    retryEvery(value: any/* Duration */): AttoWorkerAsyncBuilder;
+    retryEverySeconds(value: bigint): AttoWorkerAsyncBuilder;
+    build(): AttoWorkerAsync;
+}
+/** @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 AttoWorkerAsyncBuilder.$metadata$ {
+    const constructor: abstract new () => AttoWorkerAsyncBuilder;
+}

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerAsyncBuilder.web.export.mjs

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

package/commons-commons-worker-remote/cash/atto/commons/worker/AttoWorkerAsyncBuilder.web.export.mjs.map

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