@attocash/commons-js 5.0.0

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

@@ -0,0 +1,236 @@
+import { AttoHasher_instance3904w4qpo055r as AttoHasher_instance } from './AttoHasher.js.mjs';
+import {
+  _UByte___get_data__impl__jof9qr2p2xx2i2jvnz8 as _UByte___get_data__impl__jof9qr,
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Companion_getInstance19ckbg90y6ov9 as Companion_getInstance } from './AttoAlgorithm.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 { AttoPublicKey2ecx82jmcdweu as AttoPublicKey } from './AttoPublicKey.mjs';
+import { to2cs3ny02qtbcb as to } from '../../../../kotlin-kotlin-stdlib/kotlin/Tuples.mjs';
+import { Regexxgw0gjiagf4z as Regex } from '../../../../kotlin-kotlin-stdlib/kotlin/text/regex.mjs';
+import { contentEquals1cdp6c846cfdi as contentEquals } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { primitiveArrayConcatwxgknw08pmlb as primitiveArrayConcat } from '../../../../kotlin-kotlin-stdlib/noPackageHacks.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 { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { AttoAddressAsByteArraySerializer_getInstance5b6d6uuo8kst as AttoAddressAsByteArraySerializer_getInstance } from './serialiazer/AttoAddressAsByteArraySerializer.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 { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { writeUByte3nig1vidorr05 as writeUByte } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sinks.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Base32_getInstance1zhax53mffzee as Base32_getInstance } from './utils/Base32.mjs';
+import { substring3saq8ornu0luv as substring } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+import { replace3le3ie7l9k8aq as replace } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function checksum($this, algorithm, publicKey) {
+  return AttoHasher_instance.d2x(5, [algorithm, publicKey]);
+}
+function checksum_0($this, algorithm, publicKey) {
+  // Inline function 'kotlin.UByte.toByte' call
+  var this_0 = algorithm.code;
+  var tmp$ret$0 = _UByte___get_data__impl__jof9qr(this_0);
+  // Inline function 'kotlin.byteArrayOf' call
+  var tmp$ret$1 = new Int8Array([tmp$ret$0]);
+  return checksum($this, tmp$ret$1, publicKey.value);
+}
+function toAlgorithmPublicKey($this, decoded) {
+  var tmp = Companion_getInstance();
+  // Inline function 'kotlin.toUByte' call
+  var this_0 = decoded[0];
+  var tmp$ret$0 = _UByte___init__impl__g9hnc4(this_0);
+  var algorithm = tmp.from(tmp$ret$0);
+  var publicKey = new (AttoPublicKey())(sliceArray(decoded, until(1, 33)));
+  return to(algorithm, publicKey);
+}
+function toAlgorithmPublicKey_0($this, value) {
+  return toAlgorithmPublicKey($this, fromAddress(value));
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.text.toRegex' call
+        var this_0 = '^atto://[a-z2-7]{61}$';
+        tmp.g2x_1 = Regex().qi(this_0);
+        this.h2x_1 = 5;
+      }
+      isValid(value) {
+        if (!this.g2x_1.ri(value)) {
+          return false;
+        }
+        var decoded = fromAddress(value);
+        var _destruct__k2r9zo = toAlgorithmPublicKey(this, decoded);
+        var algorithm = _destruct__k2r9zo.gl();
+        var publicKey = _destruct__k2r9zo.hl();
+        var checksum = sliceArray(decoded, until(33, decoded.length));
+        return contentEquals(checksum, checksum_0(this, algorithm, publicKey));
+      }
+      isValidPath(path) {
+        var value = 'atto://' + path;
+        return this.isValid(value);
+      }
+      toAddress(algorithm, publicKey) {
+        // Inline function 'kotlin.UByte.toByte' call
+        var this_0 = algorithm.code;
+        var tmp$ret$0 = _UByte___get_data__impl__jof9qr(this_0);
+        // Inline function 'kotlin.byteArrayOf' call
+        var algorithm_0 = new Int8Array([tmp$ret$0]);
+        var publicKey_0 = publicKey.value;
+        var checksum_0 = checksum(this, algorithm_0, publicKey_0);
+        // Inline function 'kotlin.collections.plus' call
+        // Inline function 'kotlin.collections.plus' call
+        var this_1 = primitiveArrayConcat([algorithm_0, publicKey_0]);
+        var tmp$ret$3 = primitiveArrayConcat([this_1, checksum_0]);
+        return toAddress(tmp$ret$3);
+      }
+      parseSerialized(serialized) {
+        var tmp = Companion_getInstance();
+        // Inline function 'kotlin.toUByte' call
+        var this_0 = serialized[0];
+        var tmp$ret$0 = _UByte___init__impl__g9hnc4(this_0);
+        var algorithm = tmp.from(tmp$ret$0);
+        var publicKey = new (AttoPublicKey())(sliceArray(serialized, until(1, serialized.length)));
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      parse(value) {
+        // Inline function 'kotlin.require' call
+        if (!this.isValid(value)) {
+          var message = value + ' is invalid';
+          throw IllegalArgumentException().u(toString(message));
+        }
+        var _destruct__k2r9zo = toAlgorithmPublicKey_0(this, value);
+        var algorithm = _destruct__k2r9zo.gl();
+        var publicKey = _destruct__k2r9zo.hl();
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      parsePath(path) {
+        var value = 'atto://' + path;
+        return this.parse(value);
+      }
+      q2u() {
+        return AttoAddressAsByteArraySerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var AttoAddressClass;
+function AttoAddress() {
+  if (AttoAddressClass === VOID) {
+    class $ {
+      constructor(algorithm, publicKey) {
+        Companion_getInstance_0();
+        this.algorithm = algorithm;
+        this.publicKey = publicKey;
+        this.schema = 'atto://';
+        this.path = Companion_getInstance_0().toAddress(this.algorithm, this.publicKey);
+        this.value = this.schema + this.path;
+      }
+      t2v() {
+        return this.algorithm;
+      }
+      q2v() {
+        return this.publicKey;
+      }
+      i2x() {
+        return this.schema;
+      }
+      j2x() {
+        return this.path;
+      }
+      s1() {
+        return this.value;
+      }
+      toBuffer() {
+        // Inline function 'kotlin.apply' call
+        var this_0 = new (Buffer())();
+        writeUByte(this_0, this.algorithm.code);
+        this_0.n2s(this.publicKey.value, 0, this.publicKey.value.length);
+        return this_0;
+      }
+      toString() {
+        return this.value;
+      }
+      gl() {
+        return this.algorithm;
+      }
+      hl() {
+        return this.publicKey;
+      }
+      k2x(algorithm, publicKey) {
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      copy(algorithm, publicKey, $super) {
+        algorithm = algorithm === VOID ? this.algorithm : algorithm;
+        publicKey = publicKey === VOID ? this.publicKey : publicKey;
+        return $super === VOID ? this.k2x(algorithm, publicKey) : $super.k2x.call(this, algorithm, publicKey);
+      }
+      hashCode() {
+        var result = this.algorithm.hashCode();
+        result = imul(result, 31) + this.publicKey.hashCode() | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoAddress()))
+          return false;
+        var tmp0_other_with_cast = other instanceof AttoAddress() ? other : THROW_CCE();
+        if (!this.algorithm.equals(tmp0_other_with_cast.algorithm))
+          return false;
+        if (!this.publicKey.equals(tmp0_other_with_cast.publicKey))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoAddress', VOID, VOID, VOID, VOID, VOID, {0: AttoAddressAsByteArraySerializer_getInstance});
+    AttoAddressClass = $;
+  }
+  return AttoAddressClass;
+}
+function fromAddress(_this__u8e3s4) {
+  var tmp = Base32_getInstance();
+  // Inline function 'kotlin.text.uppercase' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$1 = substring(_this__u8e3s4, 7).toUpperCase();
+  return tmp.n2x(tmp$ret$1 + '===');
+}
+function toAddress(_this__u8e3s4) {
+  // Inline function 'kotlin.require' call
+  if (!(_this__u8e3s4.length === 38)) {
+    var message = 'ByteArray should have 38 bytes';
+    throw IllegalArgumentException().u(toString(message));
+  }
+  // Inline function 'kotlin.text.lowercase' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return replace(Base32_getInstance().o2x(_this__u8e3s4), '=', '').toLowerCase();
+}
+//region block: exports
+export {
+  Companion as Companionbjcqn3f8pqzu,
+  AttoAddress as AttoAddressi1gjrmqbg81z,
+  Companion_getInstance_0 as Companion_getInstance2vcugmik704gt,
+};
+//endregion
+
+//# sourceMappingURL=AttoAddress.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAddress.kt","unsigned/src/kotlin/UByte.kt","src/kotlin/text/regex/RegexExtensions.kt","js/src/generated/_ArraysJs.kt","src/kotlin/util/Preconditions.kt","src/kotlin/util/Standard.kt","js/src/kotlin/text/stringJs.kt"],"sourcesContent":[null,null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["checksum","algorithm","publicKey","toAlgorithmPublicKey","decoded","value","isValid","isValidPath","path","toAddress","parse","serialized","message","parsePath","serializer","<get-algorithm>","<get-publicKey>","<get-schema>","<get-path>","<get-value>","toBuffer","toString","result","fromAddress","<this>"],"mappings":"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"}

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.export.d.ts

@@ -0,0 +1,33 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare abstract class AttoAlgorithm {
+    private constructor();
+    static get V1(): AttoAlgorithm & {
+        get name(): "V1";
+        get ordinal(): 0;
+    };
+    get name(): "V1";
+    get ordinal(): 0;
+    get code(): any/* UByte */;
+    get privateKeySize(): number;
+    get publicKeySize(): number;
+    get hashSize(): number;
+    static values(): Array<AttoAlgorithm>;
+    static valueOf(value: string): AttoAlgorithm;
+}
+/** @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 AttoAlgorithm.$metadata$ {
+    const constructor: abstract new () => AttoAlgorithm;
+}
+export declare namespace AttoAlgorithm {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        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 constructor /* implements SerializerFactory */ {
+            from(code: any/* UByte */): AttoAlgorithm;
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import {
+  AttoAlgorithm18y667ds7g2yn as AttoAlgorithm,
+  valuestkl21n5yn994 as values,
+  valueOf1l4wbphcx59k2 as valueOf,
+  AttoAlgorithm_V1_getInstance3t14aeju2v8fs as AttoAlgorithm_V1_getInstance,
+  Companion32jhfeb4yz79l as Companion,
+  Companion_getInstance19ckbg90y6ov9 as Companion_getInstance,
+} from './AttoAlgorithm.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoAlgorithm_0 = AttoAlgorithm();
+AttoAlgorithm_0.values = values;
+AttoAlgorithm_0.valueOf = valueOf;
+defineProp(AttoAlgorithm_0, 'V1', AttoAlgorithm_V1_getInstance);
+defineProp(AttoAlgorithm_0, 'Companion', Companion_getInstance);
+export {
+  AttoAlgorithm_0 as AttoAlgorithm,
+};
+//endregion
+
+//# sourceMappingURL=AttoAlgorithm.export.mjs.map

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

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

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

@@ -0,0 +1,162 @@
+import { createSimpleEnumSerializer2guioz11kk1m0 as createSimpleEnumSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/Enums.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { mapCapacity1h45rc3eh9p2l as mapCapacity } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { coerceAtLeast2bkz8m9ik7hep as coerceAtLeast } from '../../../../kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import {
+  UBytep4j7r1t64gz1 as UByte,
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.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 { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { SerializerFactory1qv9hivitncuv as SerializerFactory } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginHelperInterfaces.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 { THROW_IAE23kobfj9wdoxr as THROW_IAE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { enumEntries20mr21zbe3az4 as enumEntries } from '../../../../kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function _get_$cachedSerializer__te6jhj($this) {
+  return $this.p2u_1.s1();
+}
+function AttoAlgorithm$Companion$_anonymous__z50osy() {
+  return createSimpleEnumSerializer('cash.atto.commons.AttoAlgorithm', values());
+}
+var AttoAlgorithm_V1_instance;
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.collections.associateBy' call
+        var this_0 = get_entries();
+        var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_0, 10)), 16);
+        // Inline function 'kotlin.collections.associateByTo' call
+        var destination = LinkedHashMap().vb(capacity);
+        var _iterator__ex2g4s = this_0.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var element = _iterator__ex2g4s.f1();
+          var tmp$ret$0 = new (UByte())(element.code);
+          destination.d3(tmp$ret$0, element);
+        }
+        tmp.o2u_1 = destination;
+        var tmp_0 = this;
+        var tmp_1 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+        tmp_0.p2u_1 = lazy(tmp_1, AttoAlgorithm$Companion$_anonymous__z50osy);
+      }
+      from(code) {
+        var tmp0_elvis_lhs = this.o2u_1.w2(new (UByte())(code));
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          throw IllegalArgumentException().u('Unsupported algorithm ' + new (UByte())(code) + ' code');
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      q2u() {
+        return _get_$cachedSerializer__te6jhj(this);
+      }
+      x15(typeParamsSerializers) {
+        return this.q2u();
+      }
+    }
+    initMetadataForCompanion($, VOID, [SerializerFactory()]);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  AttoAlgorithm_initEntries();
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+function values() {
+  return [AttoAlgorithm_V1_getInstance()];
+}
+function valueOf(value) {
+  if (value === 'V1')
+    return AttoAlgorithm_V1_getInstance();
+  else {
+    AttoAlgorithm_initEntries();
+    THROW_IAE('No enum constant value.');
+  }
+}
+function get_entries() {
+  if ($ENTRIES == null)
+    $ENTRIES = enumEntries(values());
+  return $ENTRIES;
+}
+var AttoAlgorithm_entriesInitialized;
+function AttoAlgorithm_initEntries() {
+  if (AttoAlgorithm_entriesInitialized)
+    return Unit_instance;
+  AttoAlgorithm_entriesInitialized = true;
+  AttoAlgorithm_V1_instance = new (AttoAlgorithm())('V1', 0, _UByte___init__impl__g9hnc4(0), 32, 32, 32);
+  Companion_getInstance();
+}
+var $ENTRIES;
+var AttoAlgorithmClass;
+function AttoAlgorithm() {
+  if (AttoAlgorithmClass === VOID) {
+    class $ extends Enum() {
+      constructor(name, ordinal, code, privateKeySize, publicKeySize, hashSize) {
+        super(name, ordinal);
+        this.code = code;
+        this.privateKeySize = privateKeySize;
+        this.publicKeySize = publicKeySize;
+        this.hashSize = hashSize;
+      }
+      p2x() {
+        return this.code;
+      }
+      q2x() {
+        return this.privateKeySize;
+      }
+      r2x() {
+        return this.publicKeySize;
+      }
+      s2x() {
+        return this.hashSize;
+      }
+      get name() {
+        return this.i3();
+      }
+      get ordinal() {
+        return this.j3();
+      }
+    }
+    initMetadataForClass($, 'AttoAlgorithm', VOID, VOID, VOID, VOID, VOID, {0: Companion_getInstance});
+    AttoAlgorithmClass = $;
+  }
+  return AttoAlgorithmClass;
+}
+function AttoAlgorithm_V1_getInstance() {
+  AttoAlgorithm_initEntries();
+  return AttoAlgorithm_V1_instance;
+}
+//region block: exports
+export {
+  Companion as Companion32jhfeb4yz79l,
+  get_entries as get_entries129oc6f40ghxh,
+  valueOf as valueOf1l4wbphcx59k2,
+  values as valuestkl21n5yn994,
+  AttoAlgorithm as AttoAlgorithm18y667ds7g2yn,
+  AttoAlgorithm_V1_getInstance as AttoAlgorithm_V1_getInstance3t14aeju2v8fs,
+  Companion_getInstance as Companion_getInstance19ckbg90y6ov9,
+};
+//endregion
+
+//# sourceMappingURL=AttoAlgorithm.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAlgorithm.kt","common/src/generated/_Collections.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-$cachedSerializer>","AttoAlgorithm$Companion$<anonymous>","capacity","element","from","code","serializer","values","valueOf","value","<get-entries>","privateKeySize","publicKeySize","hashSize","<get-code>","<get-privateKeySize>","<get-publicKeySize>","<get-hashSize>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;uCAgBIA,CAAA,KAAAA,EAAA;A,EAAA,uB;AAIA,C;mDAJAC,CAAAA,EAAA;A,EAAA,8E;AAIA,C;;;;;;;;kBAH4C,I;;qBAAR,a;YCsqCpCC,WAAwD,cAAzC,YAAY,gCAAwB,EAAxB,CAAZ,CAAyC,EAAc,EAAd,C;;0BACnC,mBAAoB,QAApB,C;YA2BL,oBA3BT,MA2BS,K;eAAA,sB,EAAM;A,cAAjBC,UAAW,sB;wCACgB,O,CDnsCwB,I;UCmsCpD,WAAY,IAAI,SAAJ,EAA0B,OAA1B,C;QAChB,C;QDpsC4C,YCqsCrC,W;oBDtsCP,I;oBAAA,8C;QAAA,qE;;UAGIC,CAASC,IAATD,EAAuC;A,YAAA,6CAAI,IAAJ,E;;QAAA,2B;UAAa,mCAAgC,wBAAhC,iBAAuD,IAAvD,IAA2D,OAA3D,C;;gBAAb,c;;QAA+E,U;MAAD,C;SAHzHE,CAAAA,EAAA;A,QAAA,2C;MAIA,C;SAJAA,C,qBAAAA,EAAA;A,QAAA,iB;MAIA,C;;;;;;;;;;;;;;eApBJC,CAAAA,E;;C;gBAAAC,CAKAC,KALAD,E;;;;;;;C;oBAAAE,CAAAA,E;;;;C;;;;;;oDAAA,I,EAAA,C,EAaO,8B,EAAI,E,EAAI,E,EAAI,E;;;;;;;;iCALfL,I,EACAM,c,EACAC,a,EACAC,Q;;QAHA,gB;QACA,oC;QACA,kC;QACA,wB;;SAHAC,CAAAA,EAAA;A,QAAA,gB;MAAc,C;SACdC,CAAAA,EAAA;A,QAAA,0B;MAAsB,C;SACtBC,CAAAA,EAAA;A,QAAA,yB;MAAqB,C;SACrBC,CAAAA,EAAA;A,QAAA,oB;MAAgB,C;;;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AttoAmount.export.d.ts

@@ -0,0 +1,51 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare abstract class AttoUnit {
+    private constructor();
+    static get ATTO(): AttoUnit & {
+        get name(): "ATTO";
+        get ordinal(): 0;
+    };
+    static get RAW(): AttoUnit & {
+        get name(): "RAW";
+        get ordinal(): 1;
+    };
+    get name(): "ATTO" | "RAW";
+    get ordinal(): 0 | 1;
+    get prefix(): string;
+    static values(): Array<AttoUnit>;
+    static valueOf(value: string): AttoUnit;
+}
+/** @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 AttoUnit.$metadata$ {
+    const constructor: abstract new () => AttoUnit;
+}
+export declare class AttoAmount /* implements Comparable<AttoAmount> */ {
+    constructor(raw: any/* ULong */);
+    get raw(): any/* ULong */;
+    toFormattedString(unit: AttoUnit): string;
+    plus(amount: AttoAmount): AttoAmount;
+    minus(amount: AttoAmount): AttoAmount;
+    toString(): string;
+    copy(raw?: any/* ULong */): AttoAmount;
+    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 AttoAmount.$metadata$ {
+    const constructor: abstract new () => AttoAmount;
+}
+export declare namespace AttoAmount {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        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 constructor {
+            get MAX(): AttoAmount;
+            get MIN(): AttoAmount;
+            from(unit: AttoUnit, string: string): AttoAmount;
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import {
+  AttoUnit3uf7k0bjq9xrg as AttoUnit,
+  values3ntpkxfaw56c5 as values,
+  valueOf2yt2l9kimc6n as valueOf,
+  AttoUnit_ATTO_getInstance1gwhthkel17m5 as AttoUnit_ATTO_getInstance,
+  AttoUnit_RAW_getInstance1qbk9zmheijip as AttoUnit_RAW_getInstance,
+  AttoAmount28z2ffm4ih7im as AttoAmount,
+  Companion311shwy120dnf as Companion,
+  Companion_getInstancezafbg69jdanb as Companion_getInstance,
+} from './AttoAmount.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoUnit_0 = AttoUnit();
+AttoUnit_0.values = values;
+AttoUnit_0.valueOf = valueOf;
+defineProp(AttoUnit_0, 'ATTO', AttoUnit_ATTO_getInstance);
+defineProp(AttoUnit_0, 'RAW', AttoUnit_RAW_getInstance);
+var AttoAmount_0 = AttoAmount();
+defineProp(AttoAmount_0, 'Companion', Companion_getInstance);
+export {
+  AttoUnit_0 as AttoUnit,
+  AttoAmount_0 as AttoAmount,
+};
+//endregion
+
+//# sourceMappingURL=AttoAmount.export.mjs.map

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

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