@polkadot/types-codec 10.4.1 → 10.5.1

package/base/Enum.js

@@ -1,11 +1,6 @@
-var _Enum_def, _Enum_entryIndex, _Enum_indexes, _Enum_isBasic, _Enum_isIndexed, _Enum_raw;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { isHex, isNumber, isObject, isString, isU8a, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { identity, isHex, isNumber, isObject, isString, isU8a, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { mapToTypeMap, typesToMap } from '../utils/index.js';
 import { Null } from './Null.js';
-function noopSetDefinition(d) {
-    return d;
-}
 function isRustEnum(def) {
     const defValues = Object.values(def);
     if (defValues.some((v) => isNumber(v))) {
@@ -21,7 +16,7 @@ function extractDef(registry, _def) {
     let isBasic;
     let isIndexed;
     if (Array.isArray(_def)) {
-        for (let i = 0; i < _def.length; i++) {
+        for (let i = 0, count = _def.length; i < count; i++) {
             def[_def[i]] = { Type: Null, index: i };
         }
         isBasic = true;
@@ -29,7 +24,7 @@ function extractDef(registry, _def) {
     }
     else if (isRustEnum(_def)) {
         const [Types, keys] = mapToTypeMap(registry, _def);
-        for (let i = 0; i < keys.length; i++) {
+        for (let i = 0, count = keys.length; i < count; i++) {
             def[keys[i]] = { Type: Types[i], index: i };
         }
         isBasic = !Object.values(def).some(({ Type }) => Type !== Null);
@@ -37,7 +32,7 @@ function extractDef(registry, _def) {
     }
     else {
         const entries = Object.entries(_def);
-        for (let i = 0; i < entries.length; i++) {
+        for (let i = 0, count = entries.length; i < count; i++) {
             const [key, index] = entries[i];
             def[key] = { Type: Null, index };
         }
@@ -128,27 +123,21 @@ function decodeEnum(registry, def, value, index) {
  * an extension to enum where the value type is determined by the actual index.
  */
 export class Enum {
-    constructor(registry, Types, value, index, { definition, setDefinition = noopSetDefinition } = {}) {
-        _Enum_def.set(this, void 0);
-        _Enum_entryIndex.set(this, void 0);
-        _Enum_indexes.set(this, void 0);
-        _Enum_isBasic.set(this, void 0);
-        _Enum_isIndexed.set(this, void 0);
-        _Enum_raw.set(this, void 0);
+    constructor(registry, Types, value, index, { definition, setDefinition = identity } = {}) {
         const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
         // shortcut isU8a as used in SCALE decoding
         const decoded = isU8a(value) && value.length && !isNumber(index)
             ? createFromU8a(registry, def, value[0], value.subarray(1))
             : decodeEnum(registry, def, value, index);
         this.registry = registry;
-        __classPrivateFieldSet(this, _Enum_def, def, "f");
-        __classPrivateFieldSet(this, _Enum_isBasic, isBasic, "f");
-        __classPrivateFieldSet(this, _Enum_isIndexed, isIndexed, "f");
-        __classPrivateFieldSet(this, _Enum_indexes, Object.values(def).map(({ index }) => index), "f");
-        __classPrivateFieldSet(this, _Enum_entryIndex, __classPrivateFieldGet(this, _Enum_indexes, "f").indexOf(decoded.index), "f");
-        __classPrivateFieldSet(this, _Enum_raw, decoded.value, "f");
-        if (__classPrivateFieldGet(this, _Enum_raw, "f").initialU8aLength) {
-            this.initialU8aLength = 1 + __classPrivateFieldGet(this, _Enum_raw, "f").initialU8aLength;
+        this.__internal__def = def;
+        this.__internal__isBasic = isBasic;
+        this.__internal__isIndexed = isIndexed;
+        this.__internal__indexes = Object.values(def).map(({ index }) => index);
+        this.__internal__entryIndex = this.__internal__indexes.indexOf(decoded.index);
+        this.__internal__raw = decoded.value;
+        if (this.__internal__raw.initialU8aLength) {
+            this.initialU8aLength = 1 + this.__internal__raw.initialU8aLength;
         }
     }
     static with(Types) {
@@ -165,9 +154,10 @@ export class Enum {
                 const keys = Array.isArray(Types)
                     ? Types
                     : Object.keys(Types);
-                const asKeys = new Array(keys.length);
-                const isKeys = new Array(keys.length);
-                for (let i = 0; i < keys.length; i++) {
+                const count = keys.length;
+                const asKeys = new Array(count);
+                const isKeys = new Array(count);
+                for (let i = 0; i < count; i++) {
                     const name = stringPascalCase(keys[i]);
                     asKeys[i] = `as${name}`;
                     isKeys[i] = `is${name}`;
@@ -186,7 +176,7 @@ export class Enum {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return 1 + __classPrivateFieldGet(this, _Enum_raw, "f").encodedLength;
+        return 1 + this.__internal__raw.encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -198,55 +188,55 @@ export class Enum {
      * @description The index of the enum value
      */
     get index() {
-        return __classPrivateFieldGet(this, _Enum_indexes, "f")[__classPrivateFieldGet(this, _Enum_entryIndex, "f")];
+        return this.__internal__indexes[this.__internal__entryIndex];
     }
     /**
      * @description The value of the enum
      */
     get inner() {
-        return __classPrivateFieldGet(this, _Enum_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description true if this is a basic enum (no values)
      */
     get isBasic() {
-        return __classPrivateFieldGet(this, _Enum_isBasic, "f");
+        return this.__internal__isBasic;
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return __classPrivateFieldGet(this, _Enum_raw, "f").isEmpty;
+        return this.__internal__raw.isEmpty;
     }
     /**
      * @description Checks if the Enum points to a [[Null]] type
      */
     get isNone() {
-        return __classPrivateFieldGet(this, _Enum_raw, "f") instanceof Null;
+        return this.__internal__raw instanceof Null;
     }
     /**
      * @description The available keys for this enum
      */
     get defIndexes() {
-        return __classPrivateFieldGet(this, _Enum_indexes, "f");
+        return this.__internal__indexes;
     }
     /**
      * @description The available keys for this enum
      */
     get defKeys() {
-        return Object.keys(__classPrivateFieldGet(this, _Enum_def, "f"));
+        return Object.keys(this.__internal__def);
     }
     /**
      * @description The name of the type this enum value represents
      */
     get type() {
-        return this.defKeys[__classPrivateFieldGet(this, _Enum_entryIndex, "f")];
+        return this.defKeys[this.__internal__entryIndex];
     }
     /**
      * @description The value of the enum
      */
     get value() {
-        return __classPrivateFieldGet(this, _Enum_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -259,7 +249,7 @@ export class Enum {
         else if (isNumber(other)) {
             return this.toNumber() === other;
         }
-        else if (__classPrivateFieldGet(this, _Enum_isBasic, "f") && isString(other)) {
+        else if (this.__internal__isBasic && isString(other)) {
             return this.type === other;
         }
         else if (isHex(other)) {
@@ -278,10 +268,10 @@ export class Enum {
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        if (__classPrivateFieldGet(this, _Enum_isBasic, "f")) {
+        if (this.__internal__isBasic) {
             return { outer: [new Uint8Array([this.index])] };
         }
-        const { inner, outer = [] } = __classPrivateFieldGet(this, _Enum_raw, "f").inspect();
+        const { inner, outer = [] } = this.__internal__raw.inspect();
         return {
             inner,
             outer: [new Uint8Array([this.index]), ...outer]
@@ -297,17 +287,17 @@ export class Enum {
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended) {
-        return __classPrivateFieldGet(this, _Enum_isBasic, "f") || this.isNone
+        return this.__internal__isBasic || this.isNone
             ? this.type
-            : { [this.type]: __classPrivateFieldGet(this, _Enum_raw, "f").toHuman(isExtended) };
+            : { [this.type]: this.__internal__raw.toHuman(isExtended) };
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return __classPrivateFieldGet(this, _Enum_isBasic, "f")
+        return this.__internal__isBasic
             ? this.type
-            : { [stringCamelCase(this.type)]: __classPrivateFieldGet(this, _Enum_raw, "f").toJSON() };
+            : { [stringCamelCase(this.type)]: this.__internal__raw.toJSON() };
     }
     /**
      * @description Returns the number representation for the value
@@ -319,23 +309,23 @@ export class Enum {
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return __classPrivateFieldGet(this, _Enum_isBasic, "f")
+        return this.__internal__isBasic
             ? this.type
-            : { [stringCamelCase(this.type)]: __classPrivateFieldGet(this, _Enum_raw, "f").toPrimitive() };
+            : { [stringCamelCase(this.type)]: this.__internal__raw.toPrimitive() };
     }
     /**
      * @description Returns a raw struct representation of the enum types
      */
     _toRawStruct() {
-        if (__classPrivateFieldGet(this, _Enum_isBasic, "f")) {
-            return __classPrivateFieldGet(this, _Enum_isIndexed, "f")
+        if (this.__internal__isBasic) {
+            return this.__internal__isIndexed
                 ? this.defKeys.reduce((out, key, index) => {
-                    out[key] = __classPrivateFieldGet(this, _Enum_indexes, "f")[index];
+                    out[key] = this.__internal__indexes[index];
                     return out;
                 }, {})
                 : this.defKeys;
         }
-        const entries = Object.entries(__classPrivateFieldGet(this, _Enum_def, "f"));
+        const entries = Object.entries(this.__internal__def);
         return typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
             out[0][i] = Type;
             out[1][i] = key;
@@ -362,11 +352,10 @@ export class Enum {
      */
     toU8a(isBare) {
         return isBare
-            ? __classPrivateFieldGet(this, _Enum_raw, "f").toU8a(isBare)
+            ? this.__internal__raw.toU8a(isBare)
             : u8aConcatStrict([
                 new Uint8Array([this.index]),
-                __classPrivateFieldGet(this, _Enum_raw, "f").toU8a(isBare)
+                this.__internal__raw.toU8a(isBare)
             ]);
     }
 }
-_Enum_def = new WeakMap(), _Enum_entryIndex = new WeakMap(), _Enum_indexes = new WeakMap(), _Enum_isBasic = new WeakMap(), _Enum_isIndexed = new WeakMap(), _Enum_raw = new WeakMap();

package/base/Option.js

@@ -1,11 +1,6 @@
-var _Option_Type, _Option_raw;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
+import { identity, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
 import { typeToConstructor } from '../utils/index.js';
 import { Null } from './Null.js';
-function noopSetDefinition(d) {
-    return d;
-}
 class None extends Null {
     /**
      * @description Returns the base runtime type name for this instance
@@ -54,9 +49,7 @@ function decodeOption(registry, Type, value) {
  * with a value if/as required/found.
  */
 export class Option {
-    constructor(registry, typeName, value, { definition, setDefinition = noopSetDefinition } = {}) {
-        _Option_Type.set(this, void 0);
-        _Option_raw.set(this, void 0);
+    constructor(registry, typeName, value, { definition, setDefinition = identity } = {}) {
         const Type = definition || setDefinition(typeToConstructor(registry, typeName));
         const decoded = isU8a(value) && value.length && !isCodec(value)
             ? value[0] === 0
@@ -64,8 +57,8 @@ export class Option {
                 : new Type(registry, value.subarray(1))
             : decodeOption(registry, Type, value);
         this.registry = registry;
-        __classPrivateFieldSet(this, _Option_Type, Type, "f");
-        __classPrivateFieldSet(this, _Option_raw, decoded, "f");
+        this.__internal__Type = Type;
+        this.__internal__raw = decoded;
         if (decoded?.initialU8aLength) {
             this.initialU8aLength = 1 + decoded.initialU8aLength;
         }
@@ -87,7 +80,7 @@ export class Option {
      */
     get encodedLength() {
         // boolean byte (has value, doesn't have) along with wrapped length
-        return 1 + __classPrivateFieldGet(this, _Option_raw, "f").encodedLength;
+        return 1 + this.__internal__raw.encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -105,7 +98,7 @@ export class Option {
      * @description Checks if the Option has no value
      */
     get isNone() {
-        return __classPrivateFieldGet(this, _Option_raw, "f") instanceof None;
+        return this.__internal__raw instanceof None;
     }
     /**
      * @description Checks if the Option has a value
@@ -117,7 +110,7 @@ export class Option {
      * @description The actual value for the Option
      */
     get value() {
-        return __classPrivateFieldGet(this, _Option_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -135,7 +128,7 @@ export class Option {
         if (this.isNone) {
             return { outer: [new Uint8Array([0])] };
         }
-        const { inner, outer = [] } = __classPrivateFieldGet(this, _Option_raw, "f").inspect();
+        const { inner, outer = [] } = this.__internal__raw.inspect();
         return {
             inner,
             outer: [new Uint8Array([1]), ...outer]
@@ -155,7 +148,7 @@ export class Option {
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended) {
-        return __classPrivateFieldGet(this, _Option_raw, "f").toHuman(isExtended);
+        return this.__internal__raw.toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
@@ -163,7 +156,7 @@ export class Option {
     toJSON() {
         return this.isNone
             ? null
-            : __classPrivateFieldGet(this, _Option_raw, "f").toJSON();
+            : this.__internal__raw.toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
@@ -171,13 +164,13 @@ export class Option {
     toPrimitive() {
         return this.isNone
             ? null
-            : __classPrivateFieldGet(this, _Option_raw, "f").toPrimitive();
+            : this.__internal__raw.toPrimitive();
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType(isBare) {
-        const wrapped = this.registry.getClassName(__classPrivateFieldGet(this, _Option_Type, "f")) || new (__classPrivateFieldGet(this, _Option_Type, "f"))(this.registry).toRawType();
+        const wrapped = this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType();
         return isBare
             ? wrapped
             : `Option<${wrapped}>`;
@@ -186,7 +179,7 @@ export class Option {
      * @description Returns the string representation of the value
      */
     toString() {
-        return __classPrivateFieldGet(this, _Option_raw, "f").toString();
+        return this.__internal__raw.toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
@@ -194,12 +187,12 @@ export class Option {
      */
     toU8a(isBare) {
         if (isBare) {
-            return __classPrivateFieldGet(this, _Option_raw, "f").toU8a(true);
+            return this.__internal__raw.toU8a(true);
         }
         const u8a = new Uint8Array(this.encodedLength);
         if (this.isSome) {
             u8a.set([1]);
-            u8a.set(__classPrivateFieldGet(this, _Option_raw, "f").toU8a(), 1);
+            u8a.set(this.__internal__raw.toU8a(), 1);
         }
         return u8a;
     }
@@ -210,7 +203,7 @@ export class Option {
         if (this.isNone) {
             throw new Error('Option: unwrapping a None value');
         }
-        return __classPrivateFieldGet(this, _Option_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description Returns the value that the Option represents (if available) or defaultValue if none
@@ -228,7 +221,6 @@ export class Option {
     unwrapOrDefault() {
         return this.isSome
             ? this.unwrap()
-            : new (__classPrivateFieldGet(this, _Option_Type, "f"))(this.registry);
+            : new this.__internal__Type(this.registry);
     }
 }
-_Option_Type = new WeakMap(), _Option_raw = new WeakMap();

package/base/Tuple.js

@@ -1,16 +1,11 @@
-var _Tuple_Types;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
+import { identity, isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from '../abstract/Array.js';
-import { decodeU8a, mapToTypeMap, typeToConstructor } from '../utils/index.js';
-function noopSetDefinition(d) {
-    return d;
-}
+import { decodeU8a, mapToTypeMap, typesToConstructors, typeToConstructor } from '../utils/index.js';
 /** @internal */
 function decodeTuple(registry, result, value, Classes) {
     if (Array.isArray(value)) {
         const Types = Classes[0];
-        for (let i = 0; i < Types.length; i++) {
+        for (let i = 0, count = Types.length; i < count; i++) {
             try {
                 const entry = value?.[i];
                 result[i] = entry instanceof Types[i]
@@ -28,7 +23,7 @@ function decodeTuple(registry, result, value, Classes) {
     }
     else if (!value || !result.length) {
         const Types = Classes[0];
-        for (let i = 0; i < Types.length; i++) {
+        for (let i = 0, count = Types.length; i < count; i++) {
             result[i] = new Types[i](registry);
         }
         return [result, 0];
@@ -42,18 +37,17 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 export class Tuple extends AbstractArray {
-    constructor(registry, Types, value, { definition, setDefinition = noopSetDefinition } = {}) {
+    constructor(registry, Types, value, { definition, setDefinition = identity } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
-            ? [Types.map((t) => typeToConstructor(registry, t)), []]
+            ? [typesToConstructors(registry, Types), []]
             : isFunction(Types) || isString(Types)
                 ? [[typeToConstructor(registry, Types)], []]
                 : mapToTypeMap(registry, Types));
         super(registry, Classes[0].length);
-        _Tuple_Types.set(this, void 0);
         this.initialU8aLength = (isU8a(value)
             ? decodeU8a(registry, this, value, Classes)
             : decodeTuple(registry, this, value, Classes))[1];
-        __classPrivateFieldSet(this, _Tuple_Types, Classes, "f");
+        this.__internal__Types = Classes;
     }
     static with(Types) {
         let definition;
@@ -70,7 +64,7 @@ export class Tuple extends AbstractArray {
      */
     get encodedLength() {
         let total = 0;
-        for (let i = 0; i < this.length; i++) {
+        for (let i = 0, count = this.length; i < count; i++) {
             total += this[i].encodedLength;
         }
         return total;
@@ -79,9 +73,9 @@ export class Tuple extends AbstractArray {
      * @description The types definition of the tuple
      */
     get Types() {
-        return __classPrivateFieldGet(this, _Tuple_Types, "f")[1].length
-            ? __classPrivateFieldGet(this, _Tuple_Types, "f")[1]
-            : __classPrivateFieldGet(this, _Tuple_Types, "f")[0].map((T) => new T(this.registry).toRawType());
+        return this.__internal__Types[1].length
+            ? this.__internal__Types[1]
+            : this.__internal__Types[0].map((T) => new T(this.registry).toRawType());
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
@@ -95,7 +89,7 @@ export class Tuple extends AbstractArray {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        const types = __classPrivateFieldGet(this, _Tuple_Types, "f")[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        const types = this.__internal__Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
         return `(${types.join(',')})`;
     }
     /**
@@ -113,4 +107,3 @@ export class Tuple extends AbstractArray {
         return u8aConcatStrict(this.toU8aInner(isBare));
     }
 }
-_Tuple_Types = new WeakMap();

package/base/Vec.js

@@ -1,13 +1,8 @@
-var _Vec_Type;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { compactFromU8aLim, isHex, isU8a, logger, stringify, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, identity, isHex, isU8a, logger, stringify, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from '../abstract/Array.js';
 import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
-function noopSetDefinition(d) {
-    return d;
-}
 function decodeVecLength(value) {
     if (Array.isArray(value)) {
         return [value, value.length, 0];
@@ -58,14 +53,13 @@ export function decodeVec(registry, result, value, startAt, Type) {
  * specific encoding/decoding on top of the base type.
  */
 export class Vec extends AbstractArray {
-    constructor(registry, Type, value = [], { definition, setDefinition = noopSetDefinition } = {}) {
+    constructor(registry, Type, value = [], { definition, setDefinition = identity } = {}) {
         const [decodeFrom, length, startAt] = decodeVecLength(value);
         super(registry, length);
-        _Vec_Type.set(this, void 0);
-        __classPrivateFieldSet(this, _Vec_Type, definition || setDefinition(typeToConstructor(registry, Type)), "f");
+        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
         this.initialU8aLength = (isU8a(decodeFrom)
-            ? decodeU8aVec(registry, this, decodeFrom, startAt, __classPrivateFieldGet(this, _Vec_Type, "f"))
-            : decodeVec(registry, this, decodeFrom, startAt, __classPrivateFieldGet(this, _Vec_Type, "f")))[0];
+            ? decodeU8aVec(registry, this, decodeFrom, startAt, this.__internal__Type)
+            : decodeVec(registry, this, decodeFrom, startAt, this.__internal__Type))[0];
     }
     static with(Type) {
         let definition;
@@ -81,17 +75,17 @@ export class Vec extends AbstractArray {
      * @description The type for the items
      */
     get Type() {
-        return __classPrivateFieldGet(this, _Vec_Type, "f").name;
+        return this.__internal__Type.name;
     }
     /**
      * @description Finds the index of the value in the array
      */
     indexOf(other) {
         // convert type first, this removes overhead from the eq
-        const check = other instanceof __classPrivateFieldGet(this, _Vec_Type, "f")
+        const check = other instanceof this.__internal__Type
             ? other
-            : new (__classPrivateFieldGet(this, _Vec_Type, "f"))(this.registry, other);
-        for (let i = 0; i < this.length; i++) {
+            : new this.__internal__Type(this.registry, other);
+        for (let i = 0, count = this.length; i < count; i++) {
             if (check.eq(this[i])) {
                 return i;
             }
@@ -102,7 +96,6 @@ export class Vec extends AbstractArray {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `Vec<${this.registry.getClassName(__classPrivateFieldGet(this, _Vec_Type, "f")) || new (__classPrivateFieldGet(this, _Vec_Type, "f"))(this.registry).toRawType()}>`;
+        return `Vec<${this.registry.getClassName(this.__internal__Type) || new this.__internal__Type(this.registry).toRawType()}>`;
     }
 }
-_Vec_Type = new WeakMap();

package/base/VecFixed.js

@@ -1,25 +1,19 @@
-var _VecFixed_Type;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { isU8a, u8aConcatStrict } from '@polkadot/util';
+import { identity, isU8a, u8aConcatStrict } from '@polkadot/util';
 import { AbstractArray } from '../abstract/Array.js';
 import { decodeU8aVec, typeToConstructor } from '../utils/index.js';
 import { decodeVec } from './Vec.js';
-function noopSetDefinition(d) {
-    return d;
-}
 /**
  * @name VecFixed
  * @description
  * This manages codec arrays of a fixed length
  */
 export class VecFixed extends AbstractArray {
-    constructor(registry, Type, length, value = [], { definition, setDefinition = noopSetDefinition } = {}) {
+    constructor(registry, Type, length, value = [], { definition, setDefinition = identity } = {}) {
         super(registry, length);
-        _VecFixed_Type.set(this, void 0);
-        __classPrivateFieldSet(this, _VecFixed_Type, definition || setDefinition(typeToConstructor(registry, Type)), "f");
+        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
         this.initialU8aLength = (isU8a(value)
-            ? decodeU8aVec(registry, this, value, 0, __classPrivateFieldGet(this, _VecFixed_Type, "f"))
-            : decodeVec(registry, this, value, 0, __classPrivateFieldGet(this, _VecFixed_Type, "f")))[1];
+            ? decodeU8aVec(registry, this, value, 0, this.__internal__Type)
+            : decodeVec(registry, this, value, 0, this.__internal__Type))[1];
     }
     static with(Type, length) {
         let definition;
@@ -35,14 +29,14 @@ export class VecFixed extends AbstractArray {
      * @description The type for the items
      */
     get Type() {
-        return new (__classPrivateFieldGet(this, _VecFixed_Type, "f"))(this.registry).toRawType();
+        return new this.__internal__Type(this.registry).toRawType();
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
         let total = 0;
-        for (let i = 0; i < this.length; i++) {
+        for (let i = 0, count = this.length; i < count; i++) {
             total += this[i].encodedLength;
         }
         return total;
@@ -70,4 +64,3 @@ export class VecFixed extends AbstractArray {
         return `[${this.Type};${this.length}]`;
     }
 }
-_VecFixed_Type = new WeakMap();