@attocash/commons-test 6.1.0 → 6.2.1

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

@@ -2,10 +2,10 @@ import {
   THROW_IAE23kobfj9wdoxr as THROW_IAE,
   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 { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
 import {
-  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
-  _UByte___get_data__impl__jof9qr2p2xx2i2jvnz8 as _UByte___get_data__impl__jof9qr,
+  _UByte___init__impl__g9hnc418b8pq346rvu4 as _UByte___init__impl__g9hnc4,
+  _UByte___get_data__impl__jof9qrfg5oujomrowy as _UByte___get_data__impl__jof9qr,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
 import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
 import {
@@ -15,19 +15,19 @@ import {
 } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
 import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
 import {
-  _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
-  _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
+  _ULong___init__impl__c78o9k2ace6d5rqjy3k as _ULong___init__impl__c78o9k,
+  _ULong___get_data__impl__fggpzb3nuonax14svlz as _ULong___get_data__impl__fggpzb,
   ULong3f9k7s38t3rfp as ULong,
-  ULong__toString_impl_f9au7kivnvhcxkib53 as ULong__toString_impl_f9au7k,
-  ULong__hashCode_impl_6hv2lb37naj4fr4k4il as ULong__hashCode_impl_6hv2lb,
-  Companion_getInstance1puqqwzccfvrg as Companion_getInstance,
+  ULong__toString_impl_f9au7k2d1ziqe8sg5kj as ULong__toString_impl_f9au7k,
+  ULong__hashCode_impl_6hv2lb2oce75u7fqjfc as ULong__hashCode_impl_6hv2lb,
+  Companion_getInstance3sq3iu5mj6qnr as Companion_getInstance,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
 import {
   multiply2k9eolhnz1bjv as multiply,
   add2suhfggl4zvkk as add,
   subtract2orl8z9upxd9l as subtract,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
-import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
 import { charArrayOf27f4r3dozbrk1 as charArrayOf } from '../../../../kotlin-kotlin-stdlib/kotlin/js/arrays.mjs';
 import {
   split3d3yeauc4rm2n as split,
@@ -81,19 +81,19 @@ function AttoUnit() {
       constructor(name, ordinal, prefix, scale) {
         super(name, ordinal);
         this.prefix = prefix;
-        this.c4m_1 = scale;
+        this.o4m_1 = scale;
       }
-      d4m() {
+      p4m() {
         return this.prefix;
       }
-      e4m() {
-        return this.c4m_1;
+      q4m() {
+        return this.o4m_1;
       }
       get name() {
-        return this.w3();
+        return this.i1();
       }
       get ordinal() {
-        return this.x3();
+        return this.z4();
       }
     }
     initMetadataForClass($, 'AttoUnit');
@@ -128,30 +128,30 @@ function Companion() {
     class $ {
       constructor() {
         Companion_instance = this;
-        this.f4m_1 = _ULong___init__impl__c78o9k(-446744073709551616n);
-        this.MAX = new (AttoAmount())(this.f4m_1);
-        this.g4m_1 = _ULong___init__impl__c78o9k(0n);
-        this.MIN = new (AttoAmount())(this.g4m_1);
+        this.r4m_1 = _ULong___init__impl__c78o9k(-446744073709551616n);
+        this.MAX = new (AttoAmount())(this.r4m_1);
+        this.s4m_1 = _ULong___init__impl__c78o9k(0n);
+        this.MIN = new (AttoAmount())(this.s4m_1);
       }
-      h4m() {
+      t4m() {
         return this.MAX;
       }
-      i4m() {
+      u4m() {
         return this.MIN;
       }
-      j4m(unit, string) {
+      v4m(unit, string) {
         var parts = split(string, charArrayOf([_Char___init__impl__6a9atx(46)]));
-        var wholePart = toULong(parts.o1(0));
-        var factor = scaleFactor(this, unit.c4m_1);
+        var wholePart = toULong(parts.v2(0));
+        var factor = scaleFactor(this, unit.o4m_1);
         // Inline function 'kotlin.ULong.times' call
         var scaledValue = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(wholePart), _ULong___get_data__impl__fggpzb(factor)));
-        if (parts.n1() > 1) {
-          var fractionalPart = toULong(parts.o1(1));
+        if (parts.u2() > 1) {
+          var fractionalPart = toULong(parts.v2(1));
           var tmp0 = scaledValue;
           // Inline function 'kotlin.ULong.times' call
           var tmp0_0 = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(fractionalPart), _ULong___get_data__impl__fggpzb(factor)));
           // Inline function 'kotlin.toUByte' call
-          var this_0 = parts.o1(1).length;
+          var this_0 = parts.v2(1).length;
           var tmp$ret$2 = _UByte___init__impl__g9hnc4(toByte(this_0));
           // Inline function 'kotlin.ULong.div' call
           var other = scaleFactor(this, tmp$ret$2);
@@ -161,7 +161,7 @@ function Companion() {
         }
         return new (AttoAmount())(scaledValue);
       }
-      q1g() {
+      y1g() {
         return AttoAmountAsULongSerializer_getInstance();
       }
     }
@@ -177,7 +177,7 @@ function Companion_getInstance_0() {
   return Companion_instance;
 }
 function from(unit, string) {
-  return Companion_getInstance_0().j4m(unit, string);
+  return Companion_getInstance_0().v4m(unit, string);
 }
 var AttoAmountClass;
 function AttoAmount() {
@@ -188,16 +188,16 @@ function AttoAmount() {
         this.raw = raw;
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.compareTo' call
-        var other = Companion_getInstance_0().f4m_1;
+        var other = Companion_getInstance_0().r4m_1;
         if (ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)) > 0) {
-          throw IllegalStateException().w4('' + new (ULong())(this.raw) + ' exceeds the max amount of ' + new (ULong())(Companion_getInstance_0().f4m_1));
+          throw IllegalStateException().o('' + new (ULong())(this.raw) + ' exceeds the max amount of ' + new (ULong())(Companion_getInstance_0().r4m_1));
         }
       }
-      k4m() {
+      w4m() {
         return this.raw;
       }
       toFormattedString(unit) {
-        var factor = scaleFactor(Companion_getInstance_0(), unit.c4m_1);
+        var factor = scaleFactor(Companion_getInstance_0(), unit.o4m_1);
         // Inline function 'kotlin.ULong.div' call
         var this_0 = this.raw;
         var wholePart = ulongDivide(this_0, factor);
@@ -210,7 +210,7 @@ function AttoAmount() {
         } else {
           var tmp_0 = ULong__toString_impl_f9au7k(fractionalPart);
           // Inline function 'kotlin.UByte.toInt' call
-          var this_2 = unit.c4m_1;
+          var this_2 = unit.o4m_1;
           var tmp$ret$2 = _UByte___get_data__impl__jof9qr(this_2) & 255;
           var fractionalStr = trimEnd(padStart(tmp_0, tmp$ret$2, _Char___init__impl__6a9atx(48)), charArrayOf([_Char___init__impl__6a9atx(48)]));
           tmp = '' + new (ULong())(wholePart) + '.' + fractionalStr;
@@ -233,7 +233,7 @@ function AttoAmount() {
           tmp = ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_1)) < 0;
         }
         if (tmp) {
-          throw IllegalStateException().w4('ULong overflow');
+          throw IllegalStateException().o('ULong overflow');
         }
         return new (AttoAmount())(total);
       }
@@ -245,31 +245,31 @@ function AttoAmount() {
         // Inline function 'kotlin.ULong.compareTo' call
         var other_0 = this.raw;
         if (ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_0)) > 0) {
-          throw IllegalStateException().w4('ULong underflow');
+          throw IllegalStateException().o('ULong underflow');
         }
         return new (AttoAmount())(total);
       }
-      l4m(other) {
+      x4m(other) {
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.compareTo' call
         var other_0 = other.raw;
         return ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other_0));
       }
       d(other) {
-        return this.l4m(other instanceof AttoAmount() ? other : THROW_CCE());
+        return this.x4m(other instanceof AttoAmount() ? other : THROW_CCE());
       }
       toString() {
         return '' + new (ULong())(this.raw);
       }
-      m4m() {
+      y4m() {
         return this.raw;
       }
-      n4m(raw) {
+      z4m(raw) {
         return new (AttoAmount())(raw);
       }
       copy(raw, $super) {
         raw = raw === VOID ? this.raw : raw;
-        return $super === VOID ? this.n4m(raw) : $super.n4m.call(this, new (ULong())(raw));
+        return $super === VOID ? this.z4m(raw) : $super.z4m.call(this, new (ULong())(raw));
       }
       hashCode() {
         return ULong__hashCode_impl_6hv2lb(this.raw);
@@ -298,19 +298,19 @@ function AttoAmountAsULongSerializer() {
     class $ {
       constructor() {
         AttoAmountAsULongSerializer_instance = this;
-        this.o4m_1 = serializer(Companion_getInstance()).os();
+        this.a4n_1 = serializer(Companion_getInstance()).ws();
       }
-      os() {
-        return this.o4m_1;
+      ws() {
+        return this.a4n_1;
       }
-      p4m(encoder, value) {
-        serializer(Companion_getInstance()).ps(encoder, new (ULong())(value.raw));
+      b4n(encoder, value) {
+        serializer(Companion_getInstance()).xs(encoder, new (ULong())(value.raw));
       }
-      ps(encoder, value) {
-        return this.p4m(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
+      xs(encoder, value) {
+        return this.b4n(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
       }
-      qs(decoder) {
-        return new (AttoAmount())(serializer(Companion_getInstance()).qs(decoder).ur_1);
+      ys(decoder) {
+        return new (AttoAmount())(serializer(Companion_getInstance()).ys(decoder).cs_1);
       }
     }
     initMetadataForObject($, 'AttoAmountAsULongSerializer', VOID, VOID, [KSerializer()]);
@@ -340,11 +340,11 @@ export {
   values as values3ntpkxfaw56c5,
   AttoUnit as AttoUnit3uf7k0bjq9xrg,
   toAttoAmount as toAttoAmount2kbgjtdbld3yn,
-  from as from1fjx23mt482ol,
-  AttoUnit_ATTO_getInstance as AttoUnit_ATTO_getInstance1gwhthkel17m5,
-  AttoUnit_RAW_getInstance as AttoUnit_RAW_getInstance1qbk9zmheijip,
-  Companion_getInstance_0 as Companion_getInstancezafbg69jdanb,
-  AttoAmountAsULongSerializer_getInstance as AttoAmountAsULongSerializer_getInstanceh2609yxm2twf,
+  from as from3jnisfe2fcztd,
+  AttoUnit_ATTO_getInstance as AttoUnit_ATTO_getInstancew3eagleomrkc,
+  AttoUnit_RAW_getInstance as AttoUnit_RAW_getInstance11a119riojt51,
+  Companion_getInstance_0 as Companion_getInstance28cx33iqjvgos,
+  AttoAmountAsULongSerializer_getInstance as AttoAmountAsULongSerializer_getInstance1nj84x863plt3,
 };
 //endregion
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAmount.kt","src/kotlin/util/Standard.kt","unsigned/src/kotlin/ULong.kt","unsigned/src/kotlin/UByte.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","valueOf","value","prefix","scale","<get-prefix>","<get-scale>","pow","<this>","exponent","result","index","scaleFactor","<get-MAX>","<get-MIN>","from","unit","string","parts","wholePart","factor","scaledValue","fractionalPart","serializer","raw","<get-raw>","toString","fractionalStr","plus","amount","total","minus","compareTo","other","toAttoAmount","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":"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"}
+{"version":3,"sources":["../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAmount.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/src/kotlin/util/Standard.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/unsigned/src/kotlin/ULong.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/unsigned/src/kotlin/UByte.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","valueOf","value","prefix","scale","<get-prefix>","<get-scale>","pow","<this>","exponent","result","index","scaleFactor","<get-MAX>","<get-MIN>","from","unit","string","parts","wholePart","factor","scaledValue","fractionalPart","serializer","raw","<get-raw>","toString","fractionalStr","plus","amount","total","minus","compareTo","other","toAttoAmount","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":"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"}

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

@@ -29,23 +29,21 @@ export declare abstract class AttoBlockType {
     static values(): Array<AttoBlockType>;
     static valueOf(value: string): AttoBlockType;
 }
-/** @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 AttoBlockType.$metadata$ {
-    const constructor: abstract new () => AttoBlockType;
-}
 export declare namespace AttoBlockType {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoBlockType;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            from(code: any/* UByte */): AttoBlockType;
-            private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                from(code: any/* UByte */): AttoBlockType;
+                private constructor();
+            }
         }
     }
 }
@@ -77,18 +75,18 @@ export declare interface AttoBlock extends HeightSupport, AddressSupport, AttoHa
         readonly "cash.atto.commons.AttoBlock": unique symbol;
     } & HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"];
 }
-export declare abstract class AttoBlock {
-    static readonly getInstance: () => typeof AttoBlock.$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 */
-export declare namespace AttoBlock.$metadata$ {
-    abstract class type extends KtSingleton<constructor>() {
+export declare namespace AttoBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
         private constructor();
     }
-    abstract class constructor /* implements SerializerFactory */ {
-        fromBuffer(serializedBlock: any/* Buffer */): Nullable<AttoBlock>;
-        private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                fromBuffer(serializedBlock: any/* Buffer */): Nullable<AttoBlock>;
+                private constructor();
+            }
+        }
     }
 }
 export declare interface PreviousSupport {
@@ -137,22 +135,20 @@ export declare class AttoSendBlock implements AttoBlock, PreviousSupport {
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"];
 }
-/** @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 AttoSendBlock.$metadata$ {
-    const constructor: abstract new () => AttoSendBlock;
-}
 export declare namespace AttoSendBlock {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoSendBlock;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
         }
     }
 }
@@ -179,22 +175,20 @@ export declare class AttoReceiveBlock implements AttoBlock, PreviousSupport, Rec
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"];
 }
-/** @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 AttoReceiveBlock.$metadata$ {
-    const constructor: abstract new () => AttoReceiveBlock;
-}
 export declare namespace AttoReceiveBlock {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoReceiveBlock;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
         }
     }
 }
@@ -223,22 +217,20 @@ export declare class AttoOpenBlock implements AttoBlock, ReceiveSupport, Represe
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
 }
-/** @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 AttoOpenBlock.$metadata$ {
-    const constructor: abstract new () => AttoOpenBlock;
-}
 export declare namespace AttoOpenBlock {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoOpenBlock;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
         }
     }
 }
@@ -266,22 +258,20 @@ export declare class AttoChangeBlock implements AttoBlock, PreviousSupport, Repr
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
 }
-/** @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 AttoChangeBlock.$metadata$ {
-    const constructor: abstract new () => AttoChangeBlock;
-}
 export declare namespace AttoChangeBlock {
-    abstract class Companion {
-        static readonly getInstance: () => typeof Companion.$metadata$.type;
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AttoChangeBlock;
+    }
+    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 type extends KtSingleton<constructor>() {
-            private constructor();
-        }
-        abstract class constructor {
-            private constructor();
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
         }
     }
 }

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

@@ -2,27 +2,27 @@ import {
   AttoBlockType2o3t26mpp4g1m as AttoBlockType,
   values1esofir5pvotm as values,
   valueOfb8c3bsf1tbuo as valueOf,
-  AttoBlockType_UNKNOWN_getInstance3dnnplul63rg3 as AttoBlockType_UNKNOWN_getInstance,
-  AttoBlockType_OPEN_getInstance2qq2w4m4uqmq7 as AttoBlockType_OPEN_getInstance,
-  AttoBlockType_RECEIVE_getInstancemszz2w4jvf1a as AttoBlockType_RECEIVE_getInstance,
-  AttoBlockType_SEND_getInstance381mhjyjs1zzi as AttoBlockType_SEND_getInstance,
-  AttoBlockType_CHANGE_getInstance3orw5rx2tjqv2 as AttoBlockType_CHANGE_getInstance,
+  AttoBlockType_UNKNOWN_getInstancet56bcf0mseow as AttoBlockType_UNKNOWN_getInstance,
+  AttoBlockType_OPEN_getInstanced9q3m2lcdhjc as AttoBlockType_OPEN_getInstance,
+  AttoBlockType_RECEIVE_getInstance2ttd23fht8r8c as AttoBlockType_RECEIVE_getInstance,
+  AttoBlockType_SEND_getInstancegazxf48jkoys as AttoBlockType_SEND_getInstance,
+  AttoBlockType_CHANGE_getInstance16tigzuncmwfi as AttoBlockType_CHANGE_getInstance,
   Companion3u1bosrh7rroz as Companion,
-  Companion_getInstance2phtijzt3ebp3 as Companion_getInstance,
+  Companion_getInstance3p2p1zqlfsf85 as Companion_getInstance,
   Companion1dgdscbdp629o as Companion_0,
-  Companion_getInstance1l72fs50ibztr as Companion_getInstance_0,
+  Companion_getInstance8qxfgiduss8m as Companion_getInstance_0,
   AttoSendBlock3okbwu66utugk as AttoSendBlock,
   Companion2stbuimptwsmu as Companion_1,
-  Companion_getInstance1oozvss6gswmf as Companion_getInstance_1,
+  Companion_getInstance1ivg04alq47sd as Companion_getInstance_1,
   AttoReceiveBlock1rskhrovahuhh as AttoReceiveBlock,
   Companion35frkk3dh8l5t as Companion_2,
-  Companion_getInstance3uyok5rq53k69 as Companion_getInstance_2,
+  Companion_getInstance2k3tq4pfqwmoi as Companion_getInstance_2,
   AttoOpenBlock12k0m6lgjqi4d as AttoOpenBlock,
   Companion22hic3dn5hjie as Companion_3,
-  Companion_getInstance30jgubha5f9hp as Companion_getInstance_3,
+  Companion_getInstanceu54nysjf7szp as Companion_getInstance_3,
   AttoChangeBlock2ght5eopbdd3a as AttoChangeBlock,
   Companion3m333c3oak3ah as Companion_4,
-  Companion_getInstance22d8d928ihuoo as Companion_getInstance_4,
+  Companion_getInstance3sgmvfe80pw99 as Companion_getInstance_4,
 } from './AttoBlock.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';
@@ -40,7 +40,8 @@ defineProp(AttoBlockType_0, 'RECEIVE', AttoBlockType_RECEIVE_getInstance, VOID,
 defineProp(AttoBlockType_0, 'SEND', AttoBlockType_SEND_getInstance, VOID, true);
 defineProp(AttoBlockType_0, 'CHANGE', AttoBlockType_CHANGE_getInstance, VOID, true);
 defineProp(AttoBlockType_0, 'Companion', Companion_getInstance, VOID, true);
-var AttoBlock = {getInstance: Companion_getInstance_0};
+var AttoBlock = {};
+defineProp(AttoBlock, 'Companion', Companion_getInstance_0, VOID, true);
 var AttoSendBlock_0 = AttoSendBlock();
 defineProp(AttoSendBlock_0, 'Companion', Companion_getInstance_1, VOID, true);
 var AttoReceiveBlock_0 = AttoReceiveBlock();

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

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