@attocash/cli 0.1.0

package/node_modules/@attocash/commons-worker/commons-commons-worker.mjs

@@ -0,0 +1,702 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  AutoCloseable1l5p57f9lp7kv as AutoCloseable,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  VOID3gxj6tk5isa35 as VOID,
+  Unit_instance3vdlo4e4f5ggx as Unit_instance,
+  Exceptiondt2hlxn7j7vw as Exception,
+  constructCallableReference23y65rf941mch as constructCallableReference,
+  HashMap1a0ld5kgwhmhv as HashMap,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  _UShort___get_data__impl__g02451joe1vsk2vach as _UShort___get_data__impl__g0245,
+  protoOf180f3jzyo7rfj as protoOf,
+  toByte4i43936u611k as toByte,
+  fromInt2ii0rejb1w62w as fromInt,
+  _ULong___init__impl__c78o9k3fkiaf1q5xsf7 as _ULong___init__impl__c78o9k,
+  _ULong___get_data__impl__fggpzb35t7vg7og3i8u as _ULong___get_data__impl__fggpzb,
+  multiply2k9eolhnz1bjv as multiply,
+  add2suhfggl4zvkk as add,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+  ulongDivide3e52ct8hxp5n7 as ulongDivide,
+  LazyThreadSafetyMode_PUBLICATION_getInstance20ynwq7b0awd8 as LazyThreadSafetyMode_PUBLICATION_getInstance,
+  lazy1261dae0bgscp as lazy,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  createThis2j2avj17cvnv2 as createThis,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  toString1pkumu07cwy4m as toString,
+  promisify1z0ncraq1ipzh as promisify,
+  await335x4cz7ixnm4 as await_0,
+  _UShort___init__impl__jigrne1zu56ujvuii2n as _UShort___init__impl__jigrne,
+} from '@attocash/commons-core/kotlin-kotlin-stdlib.mjs';
+import {
+  Companion_instancer1aiy15xy072 as Companion_instance,
+  Companion_instance1lv0f3n6qbbrs as Companion_instance_0,
+  AttoWorkTarget3v4zqc5kfdpel as AttoWorkTarget,
+  AttoWorkrxvyu0kmlxrx as AttoWork,
+  toByteArray1xevcsrk0l409 as toByteArray,
+  values1ix93lj72gxe9 as values,
+  AttoInstantAsLongSerializer_getInstance28lzw2ejfk8eg as AttoInstantAsLongSerializer_getInstance,
+  AttoWorkAsStringSerializer_getInstance2p64tpzgy1wj6 as AttoWorkAsStringSerializer_getInstance,
+  toHexcxaq2tti5e5x as toHex,
+} from '@attocash/commons-core/commons-commons-core.mjs';
+import {
+  Dispatchers_getInstance20p7pyqnrepag as Dispatchers_getInstance,
+  asyncz02dsa2nb2zt as async,
+  SupervisorJobythnfxkr3jxc as SupervisorJob,
+  CoroutineScopelux7s7zphw7e as CoroutineScope,
+  Mutex16li1l0asjv17 as Mutex,
+  cancel36mj9lv3a0whl as cancel,
+  Job13y4jkazwjho0 as Job,
+  Key_instancebefxze3q9f64 as Key_instance,
+  get_isActivehakov5bm97hw as get_isActive,
+  yieldyvh2mab0488 as yield_0,
+  CompletableDeferred2lnqvsbvx74d3 as CompletableDeferred,
+  launch1c91vkjzdi9sd as launch,
+} from '@attocash/commons-transport/kotlinx-coroutines-core.mjs';
+import {
+  createSimpleEnumSerializer2guioz11kk1m0 as createSimpleEnumSerializer,
+  PluginGeneratedSerialDescriptorqdzeg5asqhfg as PluginGeneratedSerialDescriptor,
+  UnknownFieldExceptiona60e3a6v1xqo as UnknownFieldException,
+  StringSerializer_getInstancerxlnwnlbnwri as StringSerializer_getInstance,
+  typeParametersSerializers2likxjr48tr7y as typeParametersSerializers,
+  GeneratedSerializer1f7t7hssdd2ws as GeneratedSerializer,
+  throwMissingFieldException2cmke0v3ynf14 as throwMissingFieldException,
+  SerializableWithd2dap36updxd as SerializableWith,
+} from '@attocash/commons-core/kotlinx-serialization-kotlinx-serialization-core.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+class Companion {
+  k3j(parallelism) {
+    return new AttoWorkerCpu(parallelism);
+  }
+  l3j() {
+    return defaultCpuWorker();
+  }
+}
+class AttoWorker {}
+function *work(network, timestamp, target, $completion) {
+  var threshold = Companion_instance.p2q(network, timestamp);
+  return yield* this.m3j(threshold, target, $completion);
+}
+function *work_0(block, $completion) {
+  var target = block.y2h();
+  return yield* this.n3j(block.network, block.timestamp, target, $completion);
+}
+class AttoWorkerCache {
+  constructor(delegate, dispatcher) {
+    dispatcher = dispatcher === VOID ? Dispatchers_getInstance().q32_1 : dispatcher;
+    this.p3j_1 = delegate;
+    this.q3j_1 = CoroutineScope(dispatcher.xl(SupervisorJob()));
+    this.r3j_1 = Mutex();
+    this.s3j_1 = HashMap.v8();
+  }
+  *m3j(threshold, target, $completion) {
+    var deferred = yield* /*#__NOINLINE__*/delegateWork(this, target, AttoWorkerCache$work$slambda(this, threshold), $completion);
+    var work = yield* deferred.d2u($completion);
+    // Inline function 'kotlinx.coroutines.sync.withLock' call
+    var this_0 = this.r3j_1;
+    yield* this_0.c3h(null, $completion);
+    var tmp;
+    try {
+      tmp = this.s3j_1.h4(target);
+    }finally {
+      this_0.o3g(null);
+    }
+    if (Companion_instance.r2q(threshold, target, work.value)) {
+      return work;
+    }
+    return yield* this.m3j(threshold, target, $completion);
+  }
+  *n3j(network, timestamp, target, $completion) {
+    var deferred = yield* /*#__NOINLINE__*/delegateWork(this, target, AttoWorkerCache$work$slambda_0(this, network, timestamp), $completion);
+    var work = yield* deferred.d2u($completion);
+    // Inline function 'kotlinx.coroutines.sync.withLock' call
+    var this_0 = this.r3j_1;
+    yield* this_0.c3h(null, $completion);
+    var tmp;
+    try {
+      tmp = this.s3j_1.h4(target);
+    }finally {
+      this_0.o3g(null);
+    }
+    if (Companion_instance.t2q(network, timestamp, target, work.value)) {
+      return work;
+    }
+    return yield* this.n3j(network, timestamp, target, $completion);
+  }
+  *o3j(block, $completion) {
+    var tmp = block.y2h();
+    var deferred = yield* /*#__NOINLINE__*/delegateWork(this, tmp, AttoWorkerCache$work$slambda_1(this, block), $completion);
+    var work = yield* deferred.d2u($completion);
+    // Inline function 'kotlinx.coroutines.sync.withLock' call
+    var this_0 = this.r3j_1;
+    yield* this_0.c3h(null, $completion);
+    var tmp_0;
+    try {
+      tmp_0 = this.s3j_1.h4(block.y2h());
+    }finally {
+      this_0.o3g(null);
+    }
+    var nextTarget = new AttoWorkTarget(block.hash.value);
+    yield* /*#__NOINLINE__*/delegateWork(this, nextTarget, AttoWorkerCache$work$slambda_2(this, block), $completion);
+    if (work.isValid(block)) {
+      return work;
+    }
+    return yield* this.o3j(block, $completion);
+  }
+  q6() {
+    this.s3j_1.j4();
+    cancel(this.q3j_1);
+    this.p3j_1.q6();
+  }
+}
+class AttoWorkerCpu {
+  constructor(parallelism) {
+    this.t3j_1 = parallelism;
+    this.u3j_1 = SupervisorJob();
+    var tmp = this;
+    var tmp_0 = Dispatchers_getInstance().q32_1;
+    // Inline function 'kotlin.UShort.toInt' call
+    var this_0 = this.t3j_1;
+    var tmp$ret$0 = _UShort___get_data__impl__g0245(this_0) & 65535;
+    tmp.v3j_1 = tmp_0.i2y(tmp$ret$0);
+  }
+  *m3j(threshold, target, $completion) {
+    var workJob = Job(this.u3j_1);
+    // Inline function 'kotlin.js.getCoroutineContext' call
+    var tmp0_safe_receiver = $completion.sc().ed(Key_instance);
+    var tmp;
+    if (tmp0_safe_receiver == null) {
+      tmp = null;
+    } else {
+      tmp = tmp0_safe_receiver.r2s(AttoWorkerCpu$work$lambda(workJob));
+    }
+    var callerCancellation = tmp;
+    try {
+      var controller = new WorkerController(this.v3j_1.xl(workJob), this.t3j_1, threshold, target.s2q_1);
+      return yield* controller.b3k($completion);
+    }finally {
+      if (callerCancellation == null)
+        null;
+      else {
+        callerCancellation.d2v();
+      }
+      workJob.z2s();
+    }
+  }
+  q6() {
+    this.u3j_1.z2s();
+  }
+}
+class WorkerController {
+  constructor(context, parallelism, threshold, target) {
+    this.w3j_1 = parallelism;
+    this.x3j_1 = threshold;
+    this.y3j_1 = target;
+    this.z3j_1 = CoroutineScope(context);
+    var tmp = this;
+    // Inline function 'kotlin.apply' call
+    var this_0 = CompletableDeferred();
+    this_0.r2s(WorkerController$result$lambda(this));
+    tmp.a3k_1 = this_0;
+  }
+  *b3k($completion) {
+    var tmp0 = _ULong___init__impl__c78o9k(-1n);
+    // Inline function 'kotlin.UShort.toULong' call
+    var this_0 = this.w3j_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.w3j_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.z3j_1, VOID, VOID, WorkerController$calculate$slambda(index, rangeSize, this));
+      }
+       while (inductionVariable < times);
+    try {
+      return yield* this.a3k_1.d2u($completion);
+    }finally {
+      cancel(this.z3j_1);
+    }
+  }
+}
+class Companion_0 {
+  constructor() {
+    Companion_instance_2 = 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.c3k_1 = [lazy(tmp_0, AttoWorkerOperations$Request$Companion$$childSerializers$_anonymous__k0cb7d), null, null];
+  }
+}
+class $serializer {
+  constructor() {
+    $serializer_instance = this;
+    var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('cash.atto.commons.worker.AttoWorkerOperations.Request', this, 3);
+    tmp0_serialDesc.s16('network', false);
+    tmp0_serialDesc.s16('timestamp', false);
+    tmp0_serialDesc.s16('target', false);
+    this.d3k_1 = tmp0_serialDesc;
+  }
+  e3k(encoder, value) {
+    var tmp0_desc = this.d3k_1;
+    var tmp1_output = encoder.ez(tmp0_desc);
+    var tmp2_cached = Companion_getInstance_0().c3k_1;
+    tmp1_output.v10(tmp0_desc, 0, tmp2_cached[0].b3(), value.f3k_1);
+    tmp1_output.v10(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), value.g3k_1);
+    tmp1_output.t10(tmp0_desc, 2, value.h3k_1);
+    tmp1_output.fz(tmp0_desc);
+  }
+  qu(encoder, value) {
+    return this.e3k(encoder, value instanceof Request ? value : THROW_CCE());
+  }
+  ru(decoder) {
+    var tmp0_desc = this.d3k_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.ez(tmp0_desc);
+    var tmp8_cached = Companion_getInstance_0().c3k_1;
+    if (tmp7_input.tz()) {
+      tmp4_local0 = tmp7_input.qz(tmp0_desc, 0, tmp8_cached[0].b3(), tmp4_local0);
+      tmp3_bitMask0 = tmp3_bitMask0 | 1;
+      tmp5_local1 = tmp7_input.qz(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), tmp5_local1);
+      tmp3_bitMask0 = tmp3_bitMask0 | 2;
+      tmp6_local2 = tmp7_input.oz(tmp0_desc, 2);
+      tmp3_bitMask0 = tmp3_bitMask0 | 4;
+    } else
+      while (tmp1_flag) {
+        tmp2_index = tmp7_input.uz(tmp0_desc);
+        switch (tmp2_index) {
+          case -1:
+            tmp1_flag = false;
+            break;
+          case 0:
+            tmp4_local0 = tmp7_input.qz(tmp0_desc, 0, tmp8_cached[0].b3(), tmp4_local0);
+            tmp3_bitMask0 = tmp3_bitMask0 | 1;
+            break;
+          case 1:
+            tmp5_local1 = tmp7_input.qz(tmp0_desc, 1, AttoInstantAsLongSerializer_getInstance(), tmp5_local1);
+            tmp3_bitMask0 = tmp3_bitMask0 | 2;
+            break;
+          case 2:
+            tmp6_local2 = tmp7_input.oz(tmp0_desc, 2);
+            tmp3_bitMask0 = tmp3_bitMask0 | 4;
+            break;
+          default:
+            throw UnknownFieldException.lw(tmp2_index);
+        }
+      }
+    tmp7_input.fz(tmp0_desc);
+    return Request.i3k(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
+  }
+  pu() {
+    return this.d3k_1;
+  }
+  h17() {
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return [Companion_getInstance_0().c3k_1[0].b3(), AttoInstantAsLongSerializer_getInstance(), StringSerializer_getInstance()];
+  }
+}
+class Companion_1 {}
+class $serializer_0 {
+  constructor() {
+    $serializer_instance_0 = this;
+    var tmp0_serialDesc = new PluginGeneratedSerialDescriptor('cash.atto.commons.worker.AttoWorkerOperations.Response', this, 1);
+    tmp0_serialDesc.s16('work', false);
+    this.j3k_1 = tmp0_serialDesc;
+  }
+  k3k(encoder, value) {
+    var tmp0_desc = this.j3k_1;
+    var tmp1_output = encoder.ez(tmp0_desc);
+    tmp1_output.v10(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), value.l3k_1);
+    tmp1_output.fz(tmp0_desc);
+  }
+  qu(encoder, value) {
+    return this.k3k(encoder, value instanceof Response ? value : THROW_CCE());
+  }
+  ru(decoder) {
+    var tmp0_desc = this.j3k_1;
+    var tmp1_flag = true;
+    var tmp2_index = 0;
+    var tmp3_bitMask0 = 0;
+    var tmp4_local0 = null;
+    var tmp5_input = decoder.ez(tmp0_desc);
+    if (tmp5_input.tz()) {
+      tmp4_local0 = tmp5_input.qz(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), tmp4_local0);
+      tmp3_bitMask0 = tmp3_bitMask0 | 1;
+    } else
+      while (tmp1_flag) {
+        tmp2_index = tmp5_input.uz(tmp0_desc);
+        switch (tmp2_index) {
+          case -1:
+            tmp1_flag = false;
+            break;
+          case 0:
+            tmp4_local0 = tmp5_input.qz(tmp0_desc, 0, AttoWorkAsStringSerializer_getInstance(), tmp4_local0);
+            tmp3_bitMask0 = tmp3_bitMask0 | 1;
+            break;
+          default:
+            throw UnknownFieldException.lw(tmp2_index);
+        }
+      }
+    tmp5_input.fz(tmp0_desc);
+    return Response.m3k(tmp3_bitMask0, tmp4_local0, null);
+  }
+  pu() {
+    return this.j3k_1;
+  }
+  h17() {
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return [AttoWorkAsStringSerializer_getInstance()];
+  }
+}
+class Request {
+  constructor(network, timestamp, target) {
+    Companion_getInstance_0();
+    this.f3k_1 = network;
+    this.g3k_1 = timestamp;
+    this.h3k_1 = target;
+  }
+  toString() {
+    return 'Request(network=' + this.f3k_1.toString() + ', timestamp=' + this.g3k_1.toString() + ', target=' + this.h3k_1 + ')';
+  }
+  hashCode() {
+    var result = this.f3k_1.hashCode();
+    result = imul(result, 31) + this.g3k_1.hashCode() | 0;
+    result = imul(result, 31) + getStringHashCode(this.h3k_1) | 0;
+    return result;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Request))
+      return false;
+    if (!this.f3k_1.equals(other.f3k_1))
+      return false;
+    if (!this.g3k_1.equals(other.g3k_1))
+      return false;
+    if (!(this.h3k_1 === other.h3k_1))
+      return false;
+    return true;
+  }
+  static i3k(seen0, network, timestamp, target, serializationConstructorMarker) {
+    Companion_getInstance_0();
+    if (!(7 === (7 & seen0))) {
+      throwMissingFieldException(seen0, 7, $serializer_getInstance().d3k_1);
+    }
+    var $this = createThis(this);
+    $this.f3k_1 = network;
+    $this.g3k_1 = timestamp;
+    $this.h3k_1 = target;
+    return $this;
+  }
+}
+class Response {
+  constructor(work) {
+    this.l3k_1 = work;
+  }
+  toString() {
+    return 'Response(work=' + this.l3k_1.toString() + ')';
+  }
+  hashCode() {
+    return this.l3k_1.hashCode();
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Response))
+      return false;
+    if (!this.l3k_1.equals(other.l3k_1))
+      return false;
+    return true;
+  }
+  static m3k(seen0, work, serializationConstructorMarker) {
+    if (!(1 === (1 & seen0))) {
+      throwMissingFieldException(seen0, 1, $serializer_getInstance_0().j3k_1);
+    }
+    var $this = createThis(this);
+    $this.l3k_1 = work;
+    return $this;
+  }
+}
+class AttoWorkerOperations {}
+function *work_1(network, timestamp, target, $completion) {
+  var request = new Request(network, timestamp, toHex(target.s2q_1));
+  var response = yield* this.n3k(request, $completion);
+  var work = response.l3k_1;
+  // Inline function 'kotlin.require' call
+  if (!Companion_instance.t2q(network, timestamp, target, work.value)) {
+    var message = 'Worker returned invalid work for network=' + network.toString() + ' timestamp=' + timestamp.toString() + ' target=' + toHex(target.s2q_1);
+    throw IllegalArgumentException.n2(toString(message));
+  }
+  return work;
+}
+class AttoWorkerAsync {
+  constructor(worker, dispatcher) {
+    this.worker = worker;
+  }
+  o3k() {
+    return this.worker;
+  }
+  *m3j(threshold, target, $completion) {
+    return yield* this.worker.m3j(threshold, target, $completion);
+  }
+  workThreshold(threshold, target) {
+    return promisify(($completion) => this.m3j(threshold, target, $completion));
+  }
+  *p3k(threshold, target, $completion) {
+    return this.workThreshold === protoOf(AttoWorkerAsync).workThreshold ? (yield* this.m3j(threshold, target, $completion)) : (yield* await_0(this.workThreshold(threshold, target), $completion));
+  }
+  *n3j(network, timestamp, target, $completion) {
+    return yield* this.worker.n3j(network, timestamp, target, $completion);
+  }
+  workNetwork(network, timestamp, target) {
+    return promisify(($completion) => this.n3j(network, timestamp, target, $completion));
+  }
+  *q3k(network, timestamp, target, $completion) {
+    return this.workNetwork === protoOf(AttoWorkerAsync).workNetwork ? (yield* this.n3j(network, timestamp, target, $completion)) : (yield* await_0(this.workNetwork(network, timestamp, target), $completion));
+  }
+  *o3j(block, $completion) {
+    return yield* this.worker.o3j(block, $completion);
+  }
+  workBlock(block) {
+    return promisify(($completion) => this.o3j(block, $completion));
+  }
+  *r3k(block, $completion) {
+    return this.workBlock === protoOf(AttoWorkerAsync).workBlock ? (yield* this.o3j(block, $completion)) : (yield* await_0(this.workBlock(block), $completion));
+  }
+}
+//endregion
+var Companion_instance_1;
+function Companion_getInstance() {
+  return Companion_instance_1;
+}
+function toAsync(_this__u8e3s4, dispatcher) {
+  return new AttoWorkerAsync(_this__u8e3s4, dispatcher);
+}
+function cached(_this__u8e3s4, dispatcher) {
+  dispatcher = dispatcher === VOID ? Dispatchers_getInstance().q32_1 : dispatcher;
+  return new AttoWorkerCache(_this__u8e3s4, dispatcher);
+}
+function *delegateWork($this, target, delegate, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.r3j_1;
+  yield* this_0.c3h(null, $completion);
+  var tmp;
+  try {
+    var deferred = $this.s3j_1.o4(target);
+    if (!(deferred == null)) {
+      return deferred;
+    }
+    deferred = async($this.q3j_1, VOID, VOID, AttoWorkerCache$delegateWork$slambda(delegate, target, $this));
+    var tmp0 = $this.s3j_1;
+    // Inline function 'kotlin.collections.set' call
+    var value = deferred;
+    tmp0.g4(target, value);
+    return deferred;
+  }finally {
+    this_0.o3g(null);
+  }
+}
+function AttoWorkerCache$delegateWork$slambda($delegate, $target, this$0) {
+  return constructCallableReference(function *($this$async, $completion) {
+    var tmp;
+    try {
+      return yield* $delegate($target, $completion);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Exception) {
+        var e = $p;
+        // Inline function 'kotlinx.coroutines.sync.withLock' call
+        var this_0 = this$0.r3j_1;
+        yield* this_0.c3h(null, $completion);
+        var tmp_1;
+        try {
+          tmp_1 = this$0.s3j_1.h4($target);
+        }finally {
+          this_0.o3g(null);
+        }
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+  }, 1);
+}
+function AttoWorkerCache$work$slambda(this$0, $threshold) {
+  return constructCallableReference(function *(it, $completion) {
+    return yield* this$0.p3j_1.m3j($threshold, it, $completion);
+  }, 1);
+}
+function AttoWorkerCache$work$slambda_0(this$0, $network, $timestamp) {
+  return constructCallableReference(function *(it, $completion) {
+    return yield* this$0.p3j_1.n3j($network, $timestamp, it, $completion);
+  }, 1);
+}
+function AttoWorkerCache$work$slambda_1(this$0, $block) {
+  return constructCallableReference(function *(it, $completion) {
+    return yield* this$0.p3j_1.o3j($block, $completion);
+  }, 1);
+}
+function AttoWorkerCache$work$slambda_2(this$0, $block) {
+  return constructCallableReference(function *(it, $completion) {
+    return yield* this$0.p3j_1.n3j($block.network, Companion_instance_0.now(), it, $completion);
+  }, 1);
+}
+function AttoWorkerCpu$work$lambda($workJob) {
+  return (cause) => {
+    var tmp;
+    if (!(cause == null)) {
+      $workJob.z2s();
+      tmp = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function tryComplete($this, work) {
+  if (!Companion_instance.q2q($this.x3j_1, $this.y3j_1, work)) {
+    return false;
+  }
+  // Inline function 'kotlin.collections.copyOf' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$0 = work.slice();
+  return $this.a3k_1.c2y(new AttoWork(tmp$ret$0));
+}
+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.z3j_1);
+    return Unit_instance;
+  };
+}
+function WorkerController$calculate$slambda($i, $rangeSize, this$0) {
+  return constructCallableReference(function *($this$launch, $completion) {
+    // Inline function 'kotlin.toULong' call
+    var this_0 = $i;
+    var tmp0 = _ULong___init__impl__c78o9k(fromInt(this_0));
+    // Inline function 'kotlin.ULong.times' call
+    var other = $rangeSize;
+    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 = $rangeSize;
+    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;
+    var iterationsUntilYield = 4096;
+    while (!(current === end) && get_isActive($this$launch)) {
+      if (tryComplete(this$0, work))
+        return Unit_instance;
+      incrementByteArray(this$0, 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()));
+      iterationsUntilYield = iterationsUntilYield - 1 | 0;
+      if (iterationsUntilYield === 0) {
+        iterationsUntilYield = 4096;
+        yield* yield_0($completion);
+      }
+    }
+    return Unit_instance;
+  }, 1);
+}
+function AttoWorkerOperations$Request$Companion$$childSerializers$_anonymous__k0cb7d() {
+  return createSimpleEnumSerializer('cash.atto.commons.AttoNetwork', values());
+}
+var Companion_instance_2;
+function Companion_getInstance_0() {
+  if (Companion_instance_2 === VOID)
+    new Companion_0();
+  return Companion_instance_2;
+}
+var $serializer_instance;
+function $serializer_getInstance() {
+  if ($serializer_instance === VOID)
+    new $serializer();
+  return $serializer_instance;
+}
+var Companion_instance_3;
+function Companion_getInstance_1() {
+  return Companion_instance_3;
+}
+var $serializer_instance_0;
+function $serializer_getInstance_0() {
+  if ($serializer_instance_0 === VOID)
+    new $serializer_0();
+  return $serializer_instance_0;
+}
+function defaultCpuWorker() {
+  return Companion_instance_1.k3j(_UShort___init__impl__jigrne(1));
+}
+//region block: post-declaration
+initMetadataForCompanion(Companion);
+initMetadataForInterface(AttoWorker, 'AttoWorker', VOID, VOID, [AutoCloseable], [2, 3, 1]);
+initMetadataForClass(AttoWorkerCache, 'AttoWorkerCache', VOID, VOID, [AttoWorker], [2, 3, 1]);
+protoOf(AttoWorkerCpu).n3j = work;
+protoOf(AttoWorkerCpu).o3j = work_0;
+initMetadataForClass(AttoWorkerCpu, 'AttoWorkerCpu', VOID, VOID, [AttoWorker], [2, 3, 1]);
+initMetadataForClass(WorkerController, 'WorkerController', VOID, VOID, VOID, [0]);
+initMetadataForCompanion(Companion_0);
+protoOf($serializer).i17 = typeParametersSerializers;
+initMetadataForObject($serializer, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForCompanion(Companion_1);
+protoOf($serializer_0).i17 = typeParametersSerializers;
+initMetadataForObject($serializer_0, '$serializer', VOID, VOID, [GeneratedSerializer]);
+initMetadataForClass(Request, 'Request', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance});
+initMetadataForClass(Response, 'Response', VOID, VOID, VOID, VOID, VOID, {0: $serializer_getInstance_0});
+initMetadataForInterface(AttoWorkerOperations, 'AttoWorkerOperations', VOID, VOID, [AttoWorker], [1, 3, 2]);
+initMetadataForClass(AttoWorkerAsync, 'AttoWorkerAsync', VOID, VOID, VOID, [2, 3, 1]);
+//endregion
+//region block: init
+Companion_instance_1 = new Companion();
+Companion_instance_3 = new Companion_1();
+//endregion
+//region block: exports
+export {
+  AttoWorkerAsync as AttoWorkerAsync,
+};
+export {
+  Request as Request2o3t1kyfw778m,
+  Response as Response3lq22kwwmc6vl,
+  AttoWorkerOperations as AttoWorkerOperations1gnkwfcdzd0wa,
+  cached as cached1s4yf99twpuut,
+  toAsync as toAsync10i9ow1f352l5,
+  Companion_instance_1 as Companion_instance1kp6jnubfith,
+  work_0 as work3q0nhsjbo6lx9,
+  work_1 as work2x6e1hnelgs5b,
+};
+//endregion
+
+//# sourceMappingURL=commons-commons-worker.mjs.map