@attocash/commons-js 5.3.0 → 6.0.0

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

@@ -0,0 +1,189 @@
+import { System_instance15pw2079e4stg as System_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/time/Clock.mjs';
+import { Companion_getInstance1jfygh5e58evr as Companion_getInstance } from '../../../../kotlin-kotlin-stdlib/kotlin/time/Instant.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 { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Comparable198qfk8pnblz0 as Comparable } from '../../../../kotlin-kotlin-stdlib/kotlin/Comparable.mjs';
+import { StringCompanionObject_instance3alxothmy382k as StringCompanionObject_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/primitiveCompanionObjects.mjs';
+import {
+  serializer1x79l67jvwntn as serializer,
+  serializerodflzzf6s3fp as serializer_0,
+} from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/builtins/BuiltinSerializers.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { Companion_instance3skn40jhkoxyn as Companion_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      p30(clock) {
+        return this.fromEpochMilliseconds(clock.uo().ip());
+      }
+      now() {
+        return this.p30(System_instance);
+      }
+      fromIso(value) {
+        return this.fromEpochMilliseconds(Companion_getInstance().ep(value).ip());
+      }
+      fromEpochMilliseconds(value) {
+        return new (AttoInstant())(Companion_getInstance().ei(value));
+      }
+      k2t() {
+        return AttoInstantAsLongSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+var AttoInstantClass;
+function AttoInstant() {
+  if (AttoInstantClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+      }
+      z1() {
+        return this.value;
+      }
+      jp(duration) {
+        return new (AttoInstant())(this.value.jp(duration));
+      }
+      kp(duration) {
+        return new (AttoInstant())(this.value.kp(duration));
+      }
+      q30(another) {
+        return this.value.lp(another.value);
+      }
+      x2u(other) {
+        return this.value.mp(other.value);
+      }
+      d(other) {
+        return this.x2u(other instanceof AttoInstant() ? other : THROW_CCE());
+      }
+      toEpochMilliseconds() {
+        return this.value.ip();
+      }
+      toString() {
+        return this.value.toString();
+      }
+      te() {
+        return this.value;
+      }
+      r30(value) {
+        return new (AttoInstant())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.r30(value) : $super.r30.call(this, value);
+      }
+      hashCode() {
+        return this.value.hashCode();
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoInstant()))
+          return false;
+        if (!this.value.equals(other.value))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoInstant', VOID, VOID, [Comparable()], VOID, VOID, {0: AttoInstantAsLongSerializer_getInstance});
+    AttoInstantClass = $;
+  }
+  return AttoInstantClass;
+}
+var AttoInstantAsStringSerializerClass;
+function AttoInstantAsStringSerializer() {
+  if (AttoInstantAsStringSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoInstantAsStringSerializer_instance = this;
+        this.s30_1 = serializer(StringCompanionObject_instance).u1k();
+      }
+      u1k() {
+        return this.s30_1;
+      }
+      t30(encoder, value) {
+        var iso = Companion_getInstance().ei(value.value.ip()).toString();
+        encoder.l1q(iso);
+      }
+      v1k(encoder, value) {
+        return this.t30(encoder, value instanceof AttoInstant() ? value : THROW_CCE());
+      }
+      w1k(decoder) {
+        return new (AttoInstant())(Companion_getInstance().ep(decoder.c1p()));
+      }
+    }
+    initMetadataForObject($, 'AttoInstantAsStringSerializer', VOID, VOID, [KSerializer()]);
+    AttoInstantAsStringSerializerClass = $;
+  }
+  return AttoInstantAsStringSerializerClass;
+}
+var AttoInstantAsStringSerializer_instance;
+function AttoInstantAsStringSerializer_getInstance() {
+  if (AttoInstantAsStringSerializer_instance === VOID)
+    new (AttoInstantAsStringSerializer())();
+  return AttoInstantAsStringSerializer_instance;
+}
+var AttoInstantAsLongSerializerClass;
+function AttoInstantAsLongSerializer() {
+  if (AttoInstantAsLongSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoInstantAsLongSerializer_instance = this;
+        this.u30_1 = serializer_0(Companion_instance).u1k();
+      }
+      u1k() {
+        return this.u30_1;
+      }
+      t30(encoder, value) {
+        encoder.h1q(value.value.ip());
+      }
+      v1k(encoder, value) {
+        return this.t30(encoder, value instanceof AttoInstant() ? value : THROW_CCE());
+      }
+      w1k(decoder) {
+        return new (AttoInstant())(Companion_getInstance().ei(decoder.y1o()));
+      }
+    }
+    initMetadataForObject($, 'AttoInstantAsLongSerializer', VOID, VOID, [KSerializer()]);
+    AttoInstantAsLongSerializerClass = $;
+  }
+  return AttoInstantAsLongSerializerClass;
+}
+var AttoInstantAsLongSerializer_instance;
+function AttoInstantAsLongSerializer_getInstance() {
+  if (AttoInstantAsLongSerializer_instance === VOID)
+    new (AttoInstantAsLongSerializer())();
+  return AttoInstantAsLongSerializer_instance;
+}
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion2vl7u277kvew6,
+  AttoInstant as AttoInstant2yy9f6h3xehmm,
+  Companion_getInstance_0 as Companion_getInstance3q7a6mt1f8ixs,
+  Companion_instance_0 as Companion_instance1fg0f1h3yksy8,
+  AttoInstantAsLongSerializer_getInstance as AttoInstantAsLongSerializer_getInstance2fa8f20kvnk9j,
+  AttoInstantAsStringSerializer_getInstance as AttoInstantAsStringSerializer_getInstance2ii72ba5elj3o,
+};
+//endregion
+
+//# sourceMappingURL=AttoInstant.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoInstant.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["now","clock","fromIso","value","fromEpochMilliseconds","serializer","<get-value>","plus","duration","minus","another","compareTo","other","toEpochMilliseconds","toString","<get-descriptor>","serialize","encoder","iso","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;SAyBQA,CAAQC,KAARD,EAAqC;A,QAAwD,OAAxD,2BAAsB,KAAM,KAAM,KAAlC,C;MAAuD,C;SAK5FA,CAAAA,EAAyB;A,QAAiB,OAAjB,yB;MAAgB,C;aAEzCE,CAAYC,KAAZD,EAA0C;A,QAAiE,OAAjE,2BAA8B,2BAAM,KAAN,CAAa,KAA3C,C;MAAgE,C;2BAE1GE,CAA0BD,KAA1BC,EAAsD;A,QAAiD,2BAA7B,2BAAsB,KAAtB,CAA6B,C;MAAD,C;SAX1GC,CAAAA,EAAA;A,QAAA,gD;MAYA,C;;;;;;;;;;;;;;;kBAdAF,K;QAAA,kB;;QAAAG,CAAAA,EAAA;A,QAAA,iB;MAAiB,C;QAiBRC,CAASC,QAATD,EAA4C;A,QAAiC,2BAArB,IAAM,CAAN,KAAM,IAAK,QAAL,CAAe,C;MAAD,C;QAG5EE,CAAUD,QAAVC,EAA6C;A,QAAkC,2BAAtB,IAAM,CAAN,KAAM,IAAM,QAAN,CAAgB,C;MAAD,C;SAG9EA,CAAUC,OAAVD,EAA4C;A,QAAqB,OAArB,cAAQ,OAAR,CAAgB,KAAhB,C;MAAoB,C;SAGhEE,CAAcC,KAAdD,EAAyC;A,QAA4B,OAA5B,IAAM,CAAN,KAAM,IAAU,KAAV,CAAgB,KAAhB,C;MAAqB,C;QAxBvEC,K;;;yBA0BNC,CAAAA,EAAkC;A,QAA2B,OAA3B,IAAM,CAAN,KAAM,K;MAAoB,C;cAEnDC,CAAAA,EAAyB;A,QAAgB,OAAhB,IAAM,CAAN,KAAM,W;MAAS,C;WAnDrD;A,QAAA,iB;MAAA,C;iBAAA;A,QAAA,iC;MAAA,C;;iCAAA,I,CAAA,K;;;iBAAA;A,QAAA,4B;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,sC;UAAA,Y;QAAA,oC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;;;;;;;QAsEoE,aAAb,0CAAa,M;;SAAvDC,CAAAA,EAAA;A,QAAA,iB;MAA+B,C;SAE/BC,CACLC,O,EACAd,KAFKa,EAGP;A,YACEE,MAAkB,2BAAsB,KAAY,CAAN,KAAM,KAAlC,CAAyD,W;QAC3E,OAAQ,KAAa,GAAb,C;MACZ,C;UAI4+HD,O,EAAkBd,K;;;SAFr/HgB,CAAgBC,OAAhBD,EAAiD;A,QAAkD,2BAA9B,2BAAM,OAAQ,MAAd,CAA8B,C;MAAD,C;;;;;;;;;;;;;;;;;;;QAvB7C,aAAb,gCAAa,M;;SAArDJ,CAAAA,EAAA;A,QAAA,iB;MAA+B,C;SAE/BC,CACLC,O,EACAd,KAFKa,EAGP;A,QACE,OAAQ,KAAW,KAAY,CAAN,KAAM,KAAvB,C;MACZ,C;UAkB4+HC,O,EAAkBd,K;;;SAhBr/HgB,CAAgBC,OAAhBD,EAAiD;A,QAAgE,2BAA5C,2BAAsB,OAAQ,MAA9B,CAA4C,C;MAAD,C;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,26 @@
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } 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 AttoJobClass;
+function AttoJob() {
+  if (AttoJobClass === VOID) {
+    class $ {
+      constructor(job) {
+        this.v30_1 = job;
+      }
+    }
+    initMetadataForClass($, 'AttoJob');
+    AttoJobClass = $;
+  }
+  return AttoJobClass;
+}
+//region block: exports
+export {
+  AttoJob as AttoJob1jkwx1uqpl60h,
+};
+//endregion
+
+//# sourceMappingURL=AttoJob.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoJob.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["job"],"mappings":";;;;;;;;;;kBAGYA,G;QAAR,gB;;;;;;;;;;;;"}

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

@@ -0,0 +1,16 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoKeyIndex {
+    constructor(value: any/* UInt */);
+    get value(): any/* UInt */;
+    toInt(): number;
+    copy(value?: any/* UInt */): AttoKeyIndex;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+/** @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 AttoKeyIndex.$metadata$ {
+    const constructor: abstract new () => AttoKeyIndex;
+}
+export declare function toAttoIndex(_this_: number): AttoKeyIndex;

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

@@ -0,0 +1,17 @@
+import {
+  AttoKeyIndex1s9zn741nq4qi as AttoKeyIndex,
+  toAttoIndex2ni1rb5a8nvsy as toAttoIndex,
+} from './AttoKeyIndex.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoKeyIndex_0 = AttoKeyIndex();
+export {
+  AttoKeyIndex_0 as AttoKeyIndex,
+  toAttoIndex as toAttoIndex,
+};
+//endregion
+
+//# sourceMappingURL=AttoKeyIndex.export.mjs.map

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

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

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

@@ -0,0 +1,82 @@
+import {
+  _UInt___get_data__impl__f0vqqw13y1a2xkii3dn as _UInt___get_data__impl__f0vqqw,
+  UInt1hthisrv6cndi as UInt,
+  UInt__hashCode_impl_z2mhuw2iplkmzznariq as UInt__hashCode_impl_z2mhuw,
+  _UInt___init__impl__l7qpdltd1eeof8nsuj as _UInt___init__impl__l7qpdl,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UInt.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { uintCompare18k97xs29243i as uintCompare } from '../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoKeyIndexClass;
+function AttoKeyIndex() {
+  if (AttoKeyIndexClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+      }
+      w30() {
+        return this.value;
+      }
+      toInt() {
+        // Inline function 'kotlin.UInt.toInt' call
+        var this_0 = this.value;
+        return _UInt___get_data__impl__f0vqqw(this_0);
+      }
+      x30() {
+        return this.value;
+      }
+      y30(value) {
+        return new (AttoKeyIndex())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.y30(value) : $super.y30.call(this, new (UInt())(value));
+      }
+      toString() {
+        return 'AttoKeyIndex(value=' + new (UInt())(this.value) + ')';
+      }
+      hashCode() {
+        return UInt__hashCode_impl_z2mhuw(this.value);
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoKeyIndex()))
+          return false;
+        if (!(this.value === other.value))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoKeyIndex');
+    AttoKeyIndexClass = $;
+  }
+  return AttoKeyIndexClass;
+}
+function toAttoIndex(_this__u8e3s4) {
+  // Inline function 'kotlin.toUInt' call
+  var tmp$ret$0 = _UInt___init__impl__l7qpdl(_this__u8e3s4);
+  return toAttoIndex_0(tmp$ret$0);
+}
+function compareTo(_this__u8e3s4, other) {
+  var tmp0 = _this__u8e3s4.value;
+  // Inline function 'kotlin.UInt.compareTo' call
+  var other_0 = other.value;
+  return uintCompare(_UInt___get_data__impl__f0vqqw(tmp0), _UInt___get_data__impl__f0vqqw(other_0));
+}
+function toAttoIndex_0(_this__u8e3s4) {
+  return new (AttoKeyIndex())(_this__u8e3s4);
+}
+//region block: exports
+export {
+  AttoKeyIndex as AttoKeyIndex1s9zn741nq4qi,
+  compareTo as compareTop92g04qgdk58,
+  toAttoIndex as toAttoIndex2ni1rb5a8nvsy,
+};
+//endregion
+
+//# sourceMappingURL=AttoKeyIndex.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoKeyIndex.kt","unsigned/src/kotlin/UInt.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["value","<get-value>","toInt","toAttoIndex","<this>","compareTo","other"],"mappings":";;;;;;;;;;;;;;;;;kBAUIA,K;QAAA,kB;;SAAAC,CAAAA,EAAA;A,QAAA,iB;MAAc,C;WAEdC,CAAAA,EAAmB;A;qBAAA,I,CAAA,K;QAAa,OC2SC,sC;MD3SF,C;YAZnC;A,QAAA,iB;MAAA,C;iBAAA;A,QAAA,kC;MAAA,C;;iCAAA,I,CAAA,K;;;iBAAA;A,QAAA,6D;MAAA,C;iBAAA;A,QAAA,6C;MAAA,C;oBAAA;A,QAAA,mB;UAAA,W;QAAA,uC;UAAA,Y;QAAA,kC;UAAA,Y;QAAA,W;MAAA,C;;;;;;;oBAyBAC,CAAIC,aAAJD,EAAsC;A;MCgYW,YAAV,2BDhYD,aCgYC,C;EDhY0B,OAAb,cAAT,SAAS,C;AAAY,C;kBATvDE,CAAID,a,EAAuBE,KAA3BD,EAAkD;A,aAAA,a,CAAA,K;;gBAAgB,K,CAAM,K;EAAM,OC8CjB,YAAiB,oCAAjB,EAA6B,+BAAN,OAAM,CAA7B,C;AD9CgB,C;sBAMtFF,CAAIC,aAAJD,EAAuC;A,EAAkB,4BAAL,aAAK,C;AAAD,C;;;;;"}

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

@@ -0,0 +1,33 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoMnemonic {
+    private constructor();
+    get words(): KtList<string>;
+    static fromWords(words: KtList<string>): AttoMnemonic;
+    static fromString(words: string): AttoMnemonic;
+    static fromEntropy(entropy: Int8Array): AttoMnemonic;
+    toEntropy(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    static generate(): AttoMnemonic;
+}
+/** @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 AttoMnemonic.$metadata$ {
+    const constructor: abstract new () => AttoMnemonic;
+}
+export declare namespace AttoMnemonic {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import {
+  AttoMnemonic1uk31w86z8akq as AttoMnemonic,
+  generate1mc2qawsf7uv as generate,
+  Companion14kj3l7ntrkj as Companion,
+  Companion_getInstancergomsh8k516y as Companion_getInstance,
+} from './AttoMnemonic.mjs';
+import { defineProp3ur6h3slcvq4x as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoMnemonic_0 = AttoMnemonic();
+AttoMnemonic_0.generate = generate;
+defineProp(AttoMnemonic_0, 'Companion', Companion_getInstance, VOID, true);
+export {
+  AttoMnemonic_0 as AttoMnemonic,
+};
+//endregion
+
+//# sourceMappingURL=AttoMnemonic.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoMnemonic.js.mjs

@@ -0,0 +1,23 @@
+import { SHA256 as SHA256 } from '@stablelib/sha256';
+import {
+  toUint8Array1omfedyjm9v5o as toUint8Array,
+  toByteArray3f5i5urnfv0wu as toByteArray,
+} from './Extensions.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function checksum(entropy) {
+  var hasher = new SHA256();
+  hasher.update(toUint8Array(entropy).subarray(0, 32));
+  var hash = toByteArray(hasher.digest());
+  return hash[0];
+}
+//region block: exports
+export {
+  checksum as checksum322oy0cmm2q4e,
+};
+//endregion
+
+//# sourceMappingURL=AttoMnemonic.js.mjs.map

package/commons-commons-core/cash/atto/commons/AttoMnemonic.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoMnemonic.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["checksum","entropy","hasher","hash"],"mappings":";;;;;;;;;;iBAIgBA,CAAaC,OAAbD,EAAuC;A,MACnDE,SAAa,Y;EACb,MAAO,QAAe,aAAR,OAAQ,CAAe,UAAS,CAAT,EAAY,EAAZ,CAA9B,C;MACPC,OAA2B,YAAhB,MAAO,SAAS,C;EAC3B,OAAO,KAAK,CAAL,C;AACX,C;;;;;"}

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

@@ -0,0 +1,184 @@
+import { SecureRandom_instance3d03x1xookdam as SecureRandom_instance } from './utils/SecureRandom.js.mjs';
+import { _UInt___init__impl__l7qpdltd1eeof8nsuj as _UInt___init__impl__l7qpdl } from '../../../../kotlin-kotlin-stdlib/kotlin/UInt.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  createThis2j2avj17cvnv2 as createThis,
+  equals2au1ep9vhcato as equals,
+  hashCodeq5arwsb9dgti as hashCode,
+  captureStack1fzi4aczwc4hg as captureStack,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { AttoMnemonicDictionary_getInstanceqswrfgrngkhy as AttoMnemonicDictionary_getInstance } from './AttoMnemonicDictionary.mjs';
+import { checksum322oy0cmm2q4e as checksum } from './AttoMnemonic.js.mjs';
+import { toList3jhuyej2anx2q as toList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { split2bvyvnrlcifjv as split } from '../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { until1jbpn0z3f8lbg as until } from '../../../../kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs';
+import { sliceArray2hu2ljigibgmi as sliceArray } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Arrays.mjs';
+import { RuntimeException1r3t0zl97011n as RuntimeException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { ensureNotNull1e947j3ixpazm as ensureNotNull } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { readByteArray1ri21h2rciakw as readByteArray } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      z30() {
+        var entropy = SecureRandom_instance.a31(_UInt___init__impl__l7qpdl(33));
+        return AttoMnemonic().fromEntropy(entropy);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function generate() {
+  return Companion_instance.z30();
+}
+function init_cash_atto_commons_AttoMnemonic(_this__u8e3s4) {
+}
+var AttoMnemonicClass;
+function AttoMnemonic() {
+  if (AttoMnemonicClass === VOID) {
+    class $ {
+      b31() {
+        return this.words;
+      }
+      static fromWords(words) {
+        var $this = createThis(this);
+        init_cash_atto_commons_AttoMnemonic($this);
+        if (!(words.n1() === 24)) {
+          throw AttoMnemonicException().f31('Mnemonic should have 24 words');
+        }
+        var _iterator__ex2g4s = words.k1();
+        while (_iterator__ex2g4s.l1()) {
+          var word = _iterator__ex2g4s.m1();
+          if (!AttoMnemonicDictionary_getInstance().h31_1.h2(word)) {
+            throw AttoMnemonicException().f31('The word ' + word + ' is not part of english mnemonic dictionary');
+          }
+        }
+        var entropyWithChecksum = toEntropyWithChecksum(words);
+        var checksum_0 = checksum(entropyWithChecksum);
+        if (!(entropyWithChecksum[32] === checksum_0)) {
+          throw AttoMnemonicException().f31('Invalid mnemonic');
+        }
+        $this.words = toList(words);
+        return $this;
+      }
+      static fromString(words) {
+        return this.fromWords(split(words, [' ']));
+      }
+      static fromEntropy(entropy) {
+        var $this = createThis(this);
+        init_cash_atto_commons_AttoMnemonic($this);
+        var words = ArrayList().u(24);
+        // Inline function 'kotlin.collections.copyOf' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var copy = entropy.slice();
+        copy[32] = checksum(entropy);
+        var scratch = 0;
+        var offset = 0;
+        var inductionVariable = 0;
+        var last = copy.length;
+        while (inductionVariable < last) {
+          var b = copy[inductionVariable];
+          inductionVariable = inductionVariable + 1 | 0;
+          scratch = scratch << 8;
+          scratch = scratch | b & 255;
+          offset = offset + 8 | 0;
+          if (offset >= 11) {
+            var index = scratch >> (offset - 11 | 0) & 2047;
+            offset = offset - 11 | 0;
+            words.v(AttoMnemonicDictionary_getInstance().g31_1.o1(index));
+          }
+        }
+        $this.words = toList(words);
+        return $this;
+      }
+      toEntropy() {
+        return sliceArray(toEntropyWithChecksum(this.words), until(0, 33));
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoMnemonic()))
+          return false;
+        if (!equals(this.words, other.words))
+          return false;
+        return true;
+      }
+      hashCode() {
+        return hashCode(this.words);
+      }
+      toString() {
+        return 'AttoMnemonic(words=' + this.words.n1() + ')';
+      }
+    }
+    initMetadataForClass($, 'AttoMnemonic');
+    AttoMnemonicClass = $;
+  }
+  return AttoMnemonicClass;
+}
+var AttoMnemonicExceptionClass;
+function AttoMnemonicException() {
+  if (AttoMnemonicExceptionClass === VOID) {
+    class $ extends RuntimeException() {
+      static f31(message) {
+        var $this = this.ma(message);
+        captureStack($this, $this.e31_1);
+        return $this;
+      }
+    }
+    initMetadataForClass($, 'AttoMnemonicException');
+    AttoMnemonicExceptionClass = $;
+  }
+  return AttoMnemonicExceptionClass;
+}
+function toEntropyWithChecksum(words) {
+  var buffer = new (Buffer())();
+  var scratch = 0;
+  var offset = 0;
+  var _iterator__ex2g4s = words.k1();
+  while (_iterator__ex2g4s.l1()) {
+    var word = _iterator__ex2g4s.m1();
+    var index = ensureNotNull(AttoMnemonicDictionary_getInstance().i31_1.p3(word));
+    scratch = scratch << 11;
+    scratch = scratch | index;
+    offset = offset + 11 | 0;
+    while (offset >= 8) {
+      buffer.x28(toByte(scratch >> (offset - 8 | 0)));
+      offset = offset - 8 | 0;
+    }
+  }
+  if (!(offset === 0)) {
+    buffer.x28(toByte(scratch << offset));
+  }
+  return readByteArray(buffer);
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion14kj3l7ntrkj,
+  AttoMnemonic as AttoMnemonic1uk31w86z8akq,
+  generate as generate1mc2qawsf7uv,
+  Companion_getInstance as Companion_getInstancergomsh8k516y,
+};
+//endregion
+
+//# sourceMappingURL=AttoMnemonic.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoMnemonic.kt","js/src/generated/_ArraysJs.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["generate","entropy","<get-words>","words","word","entropyWithChecksum","checksum","copy","scratch","offset","b","index","toEntropy","equals","other","hashCode","toString","message","toEntropyWithChecksum","buffer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA0FQA,CAAAA,EAA6B;A,YACzBC,UAA2B,0BAAgB,8BAAhB,C;QAC3B,kCAAoB,OAApB,C;MACJ,C;;;;;;;;;;;iBAHAD,CAAAA,E;;C;6CAtDR,a,EAAA;AA0EA,C;;;;;SAxEIE,CAAAA,EAAA;A,QAAA,iB;MAAsB,C;uBAGVC,K;;;QACJ,MAAA,KAAM,KAAN,KAAc,EAAd,E,CAAkB;A,UAClB,kCAA4B,+BAA5B,C;QACJ,C;YAEa,8B;eAAA,sB,EAAO;A,cAAfC,OAAQ,sB;UACL,KAA4B,qCAAJ,KAAI,IAAS,IAAT,CAA5B,C,CAA4C;A,YAC5C,kCAA6B,WAA7B,GAAuC,IAAvC,GAA2C,6CAA3C,C;UACJ,C;QACJ,C;YAEAC,sBAA0B,sBAAsB,KAAtB,C;YAC1BC,aAAe,SAAS,mBAAT,C;QAEX,0BAAoB,EAApB,MAA2B,UAA3B,E,CAAqC;A,UACrC,kCAA4B,kBAA5B,C;QACJ,C;QAEA,KAAK,SAAc,OAAN,KAAM,C;;;wBAIXH,K;8BAA4B,MAAN,KAAM,EAAM,KAAN,C;;yBAG5BF,O;;;YACRE,sBAA8B,EAA9BA,C;;;YAEAI,OAAW,OC4wBS,Q;QD3wBpB,KAAK,EAAL,IAAW,SAAS,OAAT,C;YACXC,UAAc,C;YACdC,SAAa,C;YACH,qB;YAAA,kB;eAAV,oBAAU,I,EAAV;A,cAAKC,IAAK,uB;UAAA,6C;UACN,UAAU,WAAY,C;UACtB,UAAU,UAAY,IAAc,G;UACpC,kBAAU,CAAV,I;UACI,cAAU,EAAV,C,CAAc;A,gBACdC,QAAiB,YAAY,SAAS,EAArB,QAA4B,I;YAC7C,kBAAU,EAAV,I;YACA,KAAM,GAAI,qCAAuB,KAAvB,IAA4B,KAA5B,CAAJ,C;UACV,C;;QAEJ,KAAK,SAAc,OAAN,KAAM,C;;;eAavBC,CAAAA,EAA6B;A,QAAmD,OAAtB,WAA7B,sBAAsB,IAAtB,CAAsB,KAAtB,CAA6B,EAAW,SAAQ,EAAR,CAAX,C;MAAqB,C;YAEtEC,CAAWC,KAAXD,EAAiC;A,QAClC,aAAS,KAAT,C;UAAgB,OAAO,I;QACvB,uC;UAAwB,OAAO,K;QAE/B,wBAAS,KAAT,CAAe,KAAf,E;UAAsB,OAAO,K;QAEjC,OAAO,I;MACX,C;cAESE,CAAAA,EAAsB;A,QAAgB,OAAV,SAAN,IAAM,CAAN,KAAM,C;MAAS,C;cAErCC,CAAAA,EAAyB;A,QAAmC,OAAlC,qBAAkC,GAAb,IAAM,CAAN,KAAM,KAAO,GAAF,G;MAAC,C;;;;;;;;;;;iBAIpEC,O;4BACiB,O;;;;;;;;;;8BAvGbC,CAA0Bf,KAA1Be,EAA0D;A,MAC9DC,yB;MAEAX,UAAc,C;MACdC,SAAa,C;MACA,8B;SAAA,sB,EAAO;A,QAAfL,OAAQ,sB;QACTO,QAAY,mDAAuB,KAAvB,IAA2B,IAA3B,E;IACZ,UAAU,WAAY,E;IACtB,UAAU,UAAW,K;IACrB,kBAAU,EAAV,I;WACO,UAAU,C,EAAG;A,MAChB,MAAO,KAAmC,OAAxB,YAAY,SAAS,CAArB,KAAwB,CAAnC,C;MACP,kBAAU,CAAV,I;IACJ,C;EACJ,C;EAEI,iBAAU,CAAV,E,CAAa;A,IACb,MAAO,KAA+B,OAApB,WAAY,MAAQ,CAA/B,C;EACX,C;EAEA,OAAc,cAAP,MAAO,C;AAClB,C;;;;;;;;"}