@attocash/commons-test 6.0.0

package/commons-commons-core/cash/atto/commons/AttoWork.mjs

@@ -0,0 +1,236 @@
+import {
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+  checkLength3j1sz9qw7d9m6 as checkLength,
+  toHexcxaq2tti5e5x as toHex,
+  toULong2ecnriauv8ptn as toULong,
+} from './Extensions.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  getTargetgiem2nmxlcxo as getTarget,
+  isValid2btj0q2riexuc as isValid,
+} from './AttoWorkTarget.mjs';
+import {
+  contentEquals1cdp6c846cfdi as contentEquals,
+  contentHashCode25jw6rgkgywwr as contentHashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  Companion_getInstance2p3k72yokmh5j as Companion_getInstance,
+  get_entries3gde2hky4su5g as get_entries,
+} from './AttoNetwork.mjs';
+import {
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  Companion_getInstance3qu5ydsg8audm as Companion_getInstance_0,
+  toLocalDateTime2fafgh396r2y5 as toLocalDateTime,
+} from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/TimeZone.mjs';
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialDescriptors.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import { System_instance15pw2079e4stg as System_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/time/Clock.mjs';
+import {
+  doubleToULong2nujnatydtf7 as doubleToULong,
+  ulongDivide3e52ct8hxp5n7 as ulongDivide,
+  ulongCompare29yg6v52hxi4l as ulongCompare,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
+import {
+  _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
+  _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
+  ULong3f9k7s38t3rfp as ULong,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import { multiply2k9eolhnz1bjv as multiply } from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
+import { toMapcf6xfku344cz as toMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Maps.mjs';
+import { AttoHasher_instance3904w4qpo055r as AttoHasher_instance } from './AttoHasher.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_thresholdCache() {
+  _init_properties_AttoWork_kt__ln1ynz();
+  return thresholdCache;
+}
+var thresholdCache;
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.SIZE = 8;
+      }
+      u4r() {
+        return this.SIZE;
+      }
+      parse(value) {
+        return new (AttoWork())(fromHexToByteArray(value));
+      }
+      p3q() {
+        return AttoWorkAsStringSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_1() {
+  return Companion_instance;
+}
+var AttoWorkClass;
+function AttoWork() {
+  if (AttoWorkClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+        checkLength(this.value, 8);
+      }
+      z1() {
+        return this.value;
+      }
+      isValid(block) {
+        return isValid(Companion_instance, block.network, block.timestamp, getTarget(block), this.value);
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoWork()))
+          return false;
+        return contentEquals(this.value, other.value);
+      }
+      hashCode() {
+        return contentHashCode(this.value);
+      }
+      toString() {
+        return toHex(this.value);
+      }
+      ne() {
+        return this.value;
+      }
+      n4p(value) {
+        return new (AttoWork())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.n4p(value) : $super.n4p.call(this, value);
+      }
+    }
+    initMetadataForClass($, 'AttoWork', VOID, VOID, VOID, VOID, VOID, {0: AttoWorkAsStringSerializer_getInstance});
+    AttoWorkClass = $;
+  }
+  return AttoWorkClass;
+}
+function getThreshold(_this__u8e3s4, network, timestamp) {
+  _init_properties_AttoWork_kt__ln1ynz();
+  if (timestamp.h4k(Companion_getInstance().INITIAL_INSTANT) < 0) {
+    throw IllegalArgumentException().i1('Timestamp(' + timestamp.toString() + ') lower than initialInstant(' + Companion_getInstance().INITIAL_INSTANT.toString() + ')');
+  }
+  return ensureNotNull(ensureNotNull(get_thresholdCache().j3(network)).j3(toLocalDateTime(timestamp.value, Companion_getInstance_0().a4g_1).x43())).ur_1;
+}
+var AttoWorkAsStringSerializerClass;
+function AttoWorkAsStringSerializer() {
+  if (AttoWorkAsStringSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoWorkAsStringSerializer_instance = this;
+        this.y4s_1 = PrimitiveSerialDescriptor('AttoWorkAsString', STRING_getInstance());
+      }
+      z1s() {
+        return this.y4s_1;
+      }
+      z4s(encoder, value) {
+        encoder.q1y(value.toString());
+      }
+      a1t(encoder, value) {
+        return this.z4s(encoder, value instanceof AttoWork() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        return Companion_instance.parse(decoder.h1x());
+      }
+    }
+    initMetadataForObject($, 'AttoWorkAsStringSerializer', VOID, VOID, [KSerializer()]);
+    AttoWorkAsStringSerializerClass = $;
+  }
+  return AttoWorkAsStringSerializerClass;
+}
+var AttoWorkAsStringSerializer_instance;
+function AttoWorkAsStringSerializer_getInstance() {
+  if (AttoWorkAsStringSerializer_instance === VOID)
+    new (AttoWorkAsStringSerializer())();
+  return AttoWorkAsStringSerializer_instance;
+}
+function initializeThresholdCache() {
+  _init_properties_AttoWork_kt__ln1ynz();
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  var cache = LinkedHashMap().s4();
+  var _iterator__ex2g4s = get_entries().k1();
+  while (_iterator__ex2g4s.l1()) {
+    var network = _iterator__ex2g4s.m1();
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    var yearMap = LinkedHashMap().s4();
+    var inductionVariable = Companion_getInstance().INITIAL_DATE.y43_1;
+    var last = toLocalDateTime(System_instance.oo(), Companion_getInstance_0().a4g_1).x43() + 10 | 0;
+    if (inductionVariable <= last)
+      do {
+        var year = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.math.pow' call
+        var x = (year - Companion_getInstance().INITIAL_DATE.y43_1 | 0) / Companion_getInstance().DOUBLING_PERIOD;
+        // Inline function 'kotlin.toULong' call
+        var this_0 = Math.pow(2.0, x);
+        var decreaseFactor = doubleToULong(this_0);
+        var tmp0 = Companion_getInstance().INITIAL_LIVE_THRESHOLD;
+        // Inline function 'kotlin.ULong.times' call
+        var other = network.thresholdIncreaseFactor;
+        var initialThreshold = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
+        var tmp2 = year;
+        // Inline function 'kotlin.ULong.div' call
+        var tmp$ret$5 = ulongDivide(initialThreshold, decreaseFactor);
+        // Inline function 'kotlin.collections.set' call
+        var value = new (ULong())(tmp$ret$5);
+        yearMap.m3(tmp2, value);
+      }
+       while (!(year === last));
+    // Inline function 'kotlin.collections.set' call
+    var value_0 = toMap(yearMap);
+    cache.m3(network, value_0);
+  }
+  return toMap(cache);
+}
+function isValid_0(_this__u8e3s4, threshold, target, work) {
+  _init_properties_AttoWork_kt__ln1ynz();
+  var difficult = toULong(AttoHasher_instance.g4l(8, [work, target]));
+  // Inline function 'kotlin.ULong.compareTo' call
+  return ulongCompare(_ULong___get_data__impl__fggpzb(difficult), _ULong___get_data__impl__fggpzb(threshold)) <= 0;
+}
+var properties_initialized_AttoWork_kt_b4scvz;
+function _init_properties_AttoWork_kt__ln1ynz() {
+  if (!properties_initialized_AttoWork_kt_b4scvz) {
+    properties_initialized_AttoWork_kt_b4scvz = true;
+    thresholdCache = initializeThresholdCache();
+  }
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion1lrb5n4gqkde2,
+  AttoWork as AttoWorkrxvyu0kmlxrx,
+  getThreshold as getThreshold18fzjxt4pr6o4,
+  isValid_0 as isValid18m1w55cgubl3,
+  Companion_getInstance_1 as Companion_getInstance3hq710dmrbb22,
+  Companion_instance as Companion_instance34cvisfr2k5u0,
+  AttoWorkAsStringSerializer_getInstance as AttoWorkAsStringSerializer_getInstance1rziw3lwqzo0n,
+};
+//endregion
+
+//# sourceMappingURL=AttoWork.mjs.map

package/commons-commons-core/cash/atto/commons/AttoWork.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoWork.kt","src/kotlin/collections/Maps.kt","js/src/kotlin/math.kt","unsigned/src/kotlin/ULong.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-thresholdCache>","<get-SIZE>","parse","value","serializer","<get-value>","isValid","block","equals","other","hashCode","toString","getThreshold","<this>","network","timestamp","<get-descriptor>","serialize","encoder","deserialize","decoder","initializeThresholdCache","cache","yearMap","year","decreaseFactor","initialThreshold","threshold","target","work","difficult","<init properties AttoWork.kt>"],"mappings":"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"}

package/commons-commons-core/cash/atto/commons/AttoWorkTarget.mjs

@@ -0,0 +1,147 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { getKClassFromExpression348iqjl4fnx2f as getKClassFromExpression } from '../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  contentEquals1cdp6c846cfdi as contentEquals,
+  contentHashCode25jw6rgkgywwr as contentHashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import {
+  toHexcxaq2tti5e5x as toHex,
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+} from './Extensions.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 './AttoBlock.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  isValid18m1w55cgubl3 as isValid,
+  Companion_instance34cvisfr2k5u0 as Companion_instance,
+  getThreshold18fzjxt4pr6o4 as getThreshold,
+} from './AttoWork.mjs';
+import { Companion_getInstance2p3k72yokmh5j as Companion_getInstance } from './AttoNetwork.mjs';
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialDescriptors.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.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_0() {
+  return Companion_instance_0;
+}
+var AttoWorkTargetClass;
+function AttoWorkTarget() {
+  if (AttoWorkTargetClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.a4t_1 = value;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+          return false;
+        if (!(other instanceof AttoWorkTarget()))
+          THROW_CCE();
+        if (!contentEquals(this.a4t_1, other.a4t_1))
+          return false;
+        return true;
+      }
+      hashCode() {
+        return contentHashCode(this.a4t_1);
+      }
+      toString() {
+        return toHex(this.a4t_1);
+      }
+    }
+    initMetadataForClass($, 'AttoWorkTarget', VOID, VOID, VOID, VOID, VOID, {0: AttoWorkTargetAsStringSerializer_getInstance});
+    AttoWorkTargetClass = $;
+  }
+  return AttoWorkTargetClass;
+}
+function getTarget(_this__u8e3s4) {
+  var tmp;
+  if (_this__u8e3s4 instanceof AttoOpenBlock()) {
+    tmp = new (AttoWorkTarget())(_this__u8e3s4.d4j_1.value);
+  } else {
+    if (isInterface(_this__u8e3s4, PreviousSupport())) {
+      tmp = new (AttoWorkTarget())(_this__u8e3s4.previous.value);
+    } else {
+      throw IllegalArgumentException().i1('Unsupported block type ' + toString(_this__u8e3s4));
+    }
+  }
+  return tmp;
+}
+function isValid_0(_this__u8e3s4, threshold, target, work) {
+  return isValid(_this__u8e3s4, threshold, target.a4t_1, work);
+}
+function isValid_1(_this__u8e3s4, network, timestamp, target, work) {
+  if (timestamp.h4k(Companion_getInstance().INITIAL_INSTANT) < 0) {
+    return false;
+  }
+  return isValid_0(_this__u8e3s4, getThreshold(Companion_instance, network, timestamp), target, work);
+}
+var AttoWorkTargetAsStringSerializerClass;
+function AttoWorkTargetAsStringSerializer() {
+  if (AttoWorkTargetAsStringSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoWorkTargetAsStringSerializer_instance = this;
+        this.b4t_1 = PrimitiveSerialDescriptor('AttoWorkTargetAsString', STRING_getInstance());
+      }
+      z1s() {
+        return this.b4t_1;
+      }
+      c4t(encoder, value) {
+        encoder.q1y(value.toString());
+      }
+      a1t(encoder, value) {
+        return this.c4t(encoder, value instanceof AttoWorkTarget() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        return new (AttoWorkTarget())(fromHexToByteArray(decoder.h1x()));
+      }
+    }
+    initMetadataForObject($, 'AttoWorkTargetAsStringSerializer', VOID, VOID, [KSerializer()]);
+    AttoWorkTargetAsStringSerializerClass = $;
+  }
+  return AttoWorkTargetAsStringSerializerClass;
+}
+var AttoWorkTargetAsStringSerializer_instance;
+function AttoWorkTargetAsStringSerializer_getInstance() {
+  if (AttoWorkTargetAsStringSerializer_instance === VOID)
+    new (AttoWorkTargetAsStringSerializer())();
+  return AttoWorkTargetAsStringSerializer_instance;
+}
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
+//region block: exports
+export {
+  AttoWorkTarget as AttoWorkTarget3v4zqc5kfdpel,
+  getTarget as getTargetgiem2nmxlcxo,
+  isValid_0 as isValid331pazae51bpo,
+  isValid_1 as isValid2btj0q2riexuc,
+};
+//endregion
+
+//# sourceMappingURL=AttoWorkTarget.mjs.map

package/commons-commons-core/cash/atto/commons/AttoWorkTarget.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoWorkTarget.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["value","equals","other","hashCode","toString","getTarget","<this>","isValid","threshold","target","work","network","timestamp","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcIA,K;QAAA,kB;;YAESC,CAAWC,KAAXD,EAAiC;A,QAClC,aAAS,KAAT,C;UAAgB,OAAO,I;QACvB,aAAS,IAAT,IAAiB,8DAAe,KAAf,EAAjB,C;UAA8C,OAAO,K;cAEzD,K;;QAEI,KAAO,cAAN,IAAM,CAAN,KAAM,EAAc,KAAd,CAAoB,KAApB,CAAP,C;UAAmC,OAAO,K;QAE9C,OAAO,I;MACX,C;cAESE,CAAAA,EAAsB;A,QAAuB,OAAjB,gBAAN,IAAM,CAAN,KAAM,C;MAAgB,C;cAE5CC,CAAAA,EAAyB;A,QAAa,OAAP,MAAN,IAAM,CAAN,KAAM,C;MAAM,C;;;;;;;kBAGlDC,CAAIC,aAAJD,EACI;A;EACI,IADE,aACF,4B;iCAAmC,a,CAAK,K,CAAU,K;;IAClD,gBAFE,aAEF,qB;mCAAqC,a,CAAK,Q,CAAS,K;;MAC3C,oCAAgC,yBAAhC,YAAwD,aAAxD,E;;;EACX,U;AAAD,C;kBAIJE,CAAID,a,EACAE,S,EACAC,M,EACAC,IAHJH,EAIa;A,EAAsC,OAAtC,uBAAQ,SAAR,EAAmB,MAAnB,CAA0B,KAA1B,EAAiC,IAAjC,C;AAAqC,C;kBAElDA,CAAID,a,EACAK,O,EACAC,S,EACAH,M,EACAC,IAJJH,EAKW;A,EACH,0CAAY,eAAZ,M,CAA6B;A,IAC7B,OAAO,K;EACX,C;EACA,OAAO,yBAAiB,iCAAa,OAAb,EAAsB,SAAtB,CAAjB,EAAmD,MAAnD,EAA2D,IAA3D,C;AACX,C;;;;;;;QAG8B,uCAA0B,wBAA1B,uB;;SAAjBM,CAAAA,EAAA;A,QAAA,iB;MAAa,C;SAEbC,CACLC,O,EACAf,KAFKc,EAGP;A,QACE,OAAQ,KAAa,KAAM,WAAnB,C;MACZ,C;UAI+iJC,O,EAAkBf,K;;;SAFxjJgB,CAAgBC,OAAhBD,EAAoD;A,QAA2D,8BAArB,mBAAvB,OAAQ,MAAe,CAAqB,C;MAAD,C;;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/Extensions.export.d.mts

@@ -0,0 +1,4 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function toHex(_this_: Int8Array): string;
+export declare function fromHexToByteArray(_this_: string): Int8Array;

package/commons-commons-core/cash/atto/commons/Extensions.export.mjs

@@ -0,0 +1,16 @@
+import {
+  toHexcxaq2tti5e5x as toHex,
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+} from './Extensions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+export {
+  toHex as toHex,
+  fromHexToByteArray as fromHexToByteArray,
+};
+//endregion
+
+//# sourceMappingURL=Extensions.export.mjs.map

package/commons-commons-core/cash/atto/commons/Extensions.export.mjs.map

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

package/commons-commons-core/cash/atto/commons/Extensions.mjs

@@ -0,0 +1,147 @@
+import { Companion_getInstance2zux61tby3qbv as Companion_getInstance } from '../../../../kotlin-kotlin-stdlib/kotlin/text/HexFormat.mjs';
+import { toHexString5bhtjxqec7ow as toHexString } from '../../../../kotlin-kotlin-stdlib/kotlin/text/HexExtensions.mjs';
+import { chunked1r6ubl9km7ic5 as chunked } from '../../../../kotlin-kotlin-stdlib/kotlin/text/_Strings.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { toInt5qdj874w69jh as toInt } from '../../../../kotlin-kotlin-stdlib/kotlin/text/numberConversions.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { toByteArray3caw0hip00os as toByteArray } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { writeInstant2bpcbovpq78pu as writeInstant } from './AttoBufferExtensions.mjs';
+import {
+  readByteArray1ri21h2rciakw as readByteArray,
+  readULongLe85hcoxmq2r21 as readULongLe,
+} from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.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 { writeULongLe1350gdjm9hbuc as writeULongLe } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sinks.mjs';
+import { SafeContinuation1x0fxyaxo6cwq as SafeContinuation } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/SafeContinuationJs.mjs';
+import { intercepted2ogpsikxxj4u0 as intercepted } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function toHex(_this__u8e3s4) {
+  return toHexString(_this__u8e3s4, Companion_getInstance().ym_1);
+}
+function fromHexToByteArray(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = chunked(_this__u8e3s4, 2);
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().u(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.k1();
+  while (_iterator__ex2g4s.l1()) {
+    var item = _iterator__ex2g4s.m1();
+    var tmp$ret$0 = toByte(toInt(item, 16));
+    destination.v(tmp$ret$0);
+  }
+  return toByteArray(destination);
+}
+function toByteArray_0(_this__u8e3s4) {
+  var buffer = new (Buffer())();
+  writeInstant(buffer, _this__u8e3s4);
+  return readByteArray(buffer);
+}
+function checkLength(_this__u8e3s4, size) {
+  // Inline function 'kotlin.require' call
+  if (!(_this__u8e3s4.length === size)) {
+    var message = 'Byte array contains ' + _this__u8e3s4.length + ' characters but should contains ' + size;
+    throw IllegalArgumentException().i1(toString(message));
+  }
+}
+function toULong(_this__u8e3s4) {
+  var buffer = new (Buffer())();
+  buffer.e1m(_this__u8e3s4);
+  return readULongLe(buffer);
+}
+function toHex_0(_this__u8e3s4) {
+  return toHex_1(_this__u8e3s4.o4l());
+}
+function toByteArray_1(_this__u8e3s4) {
+  var buffer = new (Buffer())();
+  writeULongLe(buffer, _this__u8e3s4);
+  return readByteArray(buffer);
+}
+function toHex_1(_this__u8e3s4) {
+  return toHex(readByteArray(_this__u8e3s4.s1m()));
+}
+function toUint8Array(_this__u8e3s4) {
+  var output = new Uint8Array(_this__u8e3s4.length);
+  // Inline function 'kotlin.repeat' call
+  var times = _this__u8e3s4.length;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'org.khronos.webgl.set' call
+      // Inline function 'kotlin.js.asDynamic' call
+      output[index] = _this__u8e3s4[index];
+    }
+     while (inductionVariable < times);
+  return output;
+}
+function toByteArray_2(_this__u8e3s4) {
+  var output = new Int8Array(_this__u8e3s4.length);
+  // Inline function 'kotlin.repeat' call
+  var times = _this__u8e3s4.length;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'org.khronos.webgl.get' call
+      // Inline function 'kotlin.js.asDynamic' call
+      output[index] = _this__u8e3s4[index];
+    }
+     while (inductionVariable < times);
+  return output;
+}
+function await_0(_this__u8e3s4, $completion) {
+  var safe = SafeContinuation().mc(intercepted($completion));
+  var tmp = await$lambda(safe);
+  _this__u8e3s4.then(tmp, await$lambda_0(safe));
+  return safe.nc();
+}
+function await$lambda($cont) {
+  return (it) => {
+    // Inline function 'kotlin.coroutines.resume' call
+    var this_0 = $cont;
+    // Inline function 'kotlin.Companion.success' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(it);
+    this_0.vb(tmp$ret$0);
+    return Unit_instance;
+  };
+}
+function await$lambda_0($cont) {
+  return (it) => {
+    // Inline function 'kotlin.coroutines.resumeWithException' call
+    var this_0 = $cont;
+    // Inline function 'kotlin.Companion.failure' call
+    var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(it));
+    this_0.vb(tmp$ret$0);
+    return Unit_instance;
+  };
+}
+//region block: exports
+export {
+  checkLength as checkLength3j1sz9qw7d9m6,
+  fromHexToByteArray as fromHexToByteArrayplx5jrfi7guj,
+  toByteArray_2 as toByteArray3f5i5urnfv0wu,
+  toByteArray_0 as toByteArray18blahk7gwuv4,
+  toByteArray_1 as toByteArray1xevcsrk0l409,
+  toHex as toHexcxaq2tti5e5x,
+  toHex_0 as toHexvmspn7gav672,
+  toULong as toULong2ecnriauv8ptn,
+  toUint8Array as toUint8Array1omfedyjm9v5o,
+  await_0 as await162n0spjlh1n8,
+};
+//endregion
+
+//# sourceMappingURL=Extensions.mjs.map

package/commons-commons-core/cash/atto/commons/Extensions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/Extensions.kt","common/src/generated/_Collections.kt","src/kotlin/util/Preconditions.kt","../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/Extensions.kt","src/kotlin/util/Standard.kt","libraries/stdlib/js/src/org.w3c/org.khronos.webgl.kt","src/kotlin/coroutines/Continuation.kt","src/kotlin/util/Result.kt"],"sourcesContent":[null,null,null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["toHex","<this>","fromHexToByteArray","item","toByteArray","buffer","checkLength","size","message","toULong","toUint8Array","output","index","await","$completion","safe","await$lambda","await$lambda$lambda"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAWAA,CAAIC,aAAJD,EAAgC;A,EAAqC,OAAhC,YAAL,aAAK,0BAAsB,IAAtB,C;AAA+B,C;2BAQpEE,CAAID,aAAJC,EACI;A;eAAA,uBAAQ,CAAR,C;;oBCsgDa,cAAa,gCAAwB,EAAxB,CAAb,C;MAuEA,oBAvEN,MAuEM,K;SAAA,sB,EACT;A,QADCC,OAAQ,sB;QD5kDmB,YAAR,OAAV,MC6kDgB,ID7kDhB,EAAM,EAAN,CAAU,C;IC6kDpB,WAAY,GAAI,SAAJ,C;EAAmB,C;ED5kDjB,OAAb,YC6kDE,WD7kDF,C;AAAY,C;sBAMrBC,CAAIH,aAAJG,EAAyC;A,MACrCC,yB;EACO,aAAP,MAAO,EAAa,aAAb,C;EACP,OAAc,cAAP,MAAO,C;AAClB,C;oBARAC,CAAIL,a,EAAsBM,IAA1BD,EAAqC;A;EEW7B,MFVI,cAAK,MAAL,KAAa,IEUjB,E,CAAQ;A,QACRE,UFX0B,sBAAD,GAAuB,aAAvB,CAA4B,MAA5B,GAAiC,kCAAjC,GAAkE,I;IEY3F,oCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;AFZJ,C;gBAQAC,CAAIR,aAAJQ,EAA+B;A,MAC3BJ,yB;EACA,MAAO,KAAM,aAAN,C;EACP,OAAc,YAAP,MAAO,C;AAClB,C;gBAvBAL,CAAIC,aAAJD,EAAuC;A,EAAkB,OAAP,QAAX,mBAAW,C;AAAM,C;sBAyBxDI,CAAIH,aAAJG,EAAmC;A,MAC/BC,yB;EACO,aAAP,MAAO,EAAa,aAAb,C;EACP,OAAc,cAAP,MAAO,C;AAClB,C;gBA/BAL,CAAIC,aAAJD,EAA6B;A,EAAmC,OAAP,MAAhB,cAAZ,aAAK,MAAO,CAAgB,C;AAAM,C;qBGK/DU,CAAIT,aAAJS,EAAyC;A,MACrCC,SAAa,eAAW,aAAX,CAAW,MAAX,C;;cACN,a,CAAA,M;MCuIO,qB;EAAd,wBAAsB,KAAtB,C;OAAA;A,UAAKC,QAAS,iB;MAAA,6C;;;MDtIV,MEk8B6D,CD3zBtD,KC2zBsD,IFl8B7C,cCuIT,KDvIS,C;;ICsIpB,4BAAsB,KAAtB,C;EDpIA,OAAO,M;AACX,C;sBAdAR,CAAIH,aAAJG,EAAwC;A,MACpCO,SAAa,cAAU,aAAV,CAAU,MAAV,C;;cACN,a,CAAA,M;MC+IO,qB;EAAd,wBAAsB,KAAtB,C;OAAA;A,UAAKC,QAAS,iB;MAAA,6C;;;MD9IV,OC+IO,KD/IP,IAAgB,aEs8BsC,CDvzB/C,KCuzB+C,C;;IDxzB1D,4BAAsB,KAAtB,C;ED5IA,OAAO,M;AACX,C;gBAUQC,CAAQZ,a,EAARa,WAAAD,EACJ;A,MGqHIE,6BAA8B,YHlHwW,WGkHxW,CAA9BA,C;YHpHK,aGqHC,IHrHD,C;EAAL,wBAA0B,eGqHpB,IHrHoB,CAA1B,C;EACJ,OGqHI,IAAK,K;AHrHT,C;qBADSC,C,KAAAA,E;SAAAC,CAAA,EAAAA,KAAA;A;iBAAE,K;;QIgEU,YAAb,6BJhEe,EIgEf,C;IDhDR,UAAkB,SAAlB,C;IHhB2B,oB;EAAA,C;C;uBAAGD,C,KAAAA,E;SAAAC,CAAA,EAAAA,KAAA;A;iBAAE,K;;QIyEQ,YAAhC,6BAAO,cJzE0C,EIyE1C,CAAP,C;IDhDR,UAAkB,SAAlB,C;IHzB6D,oB;EAAA,C;C;;;;;"}