@polkadot/types-codec 10.0.1 → 10.1.2

package/base/Enum.js

@@ -1,3 +1,5 @@
+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 { mapToTypeMap, typesToMap } from '../utils/index.js';
 import { Null } from './Null.js';
@@ -126,39 +128,40 @@ function decodeEnum(registry, def, value, index) {
  * an extension to enum where the value type is determined by the actual index.
  */
 export class Enum {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #def;
-    #entryIndex;
-    #indexes;
-    #isBasic;
-    #isIndexed;
-    #raw;
     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);
         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;
-        this.#def = def;
-        this.#isBasic = isBasic;
-        this.#isIndexed = isIndexed;
-        this.#indexes = Object.values(def).map(({ index }) => index);
-        this.#entryIndex = this.#indexes.indexOf(decoded.index);
-        this.#raw = decoded.value;
-        if (this.#raw.initialU8aLength) {
-            this.initialU8aLength = 1 + this.#raw.initialU8aLength;
+        __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;
         }
     }
     static with(Types) {
+        var _a;
         let definition;
         // eslint-disable-next-line no-return-assign
         const setDefinition = (d) => definition = d;
-        return class extends Enum {
-            static {
+        return _a = class extends Enum {
+                constructor(registry, value, index) {
+                    super(registry, Types, value, index, { definition, setDefinition });
+                }
+            },
+            (() => {
                 const keys = Array.isArray(Types)
                     ? Types
                     : Object.keys(Types);
@@ -169,24 +172,21 @@ export class Enum {
                     asKeys[i] = `as${name}`;
                     isKeys[i] = `is${name}`;
                 }
-                objectProperties(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
-                objectProperties(this.prototype, asKeys, (k, i, self) => {
+                objectProperties(_a.prototype, isKeys, (_, i, self) => self.type === keys[i]);
+                objectProperties(_a.prototype, asKeys, (k, i, self) => {
                     if (self.type !== keys[i]) {
                         throw new Error(`Cannot convert '${self.type}' via ${k}`);
                     }
                     return self.value;
                 });
-            }
-            constructor(registry, value, index) {
-                super(registry, Types, value, index, { definition, setDefinition });
-            }
-        };
+            })(),
+            _a;
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return 1 + this.#raw.encodedLength;
+        return 1 + __classPrivateFieldGet(this, _Enum_raw, "f").encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -198,55 +198,55 @@ export class Enum {
      * @description The index of the enum value
      */
     get index() {
-        return this.#indexes[this.#entryIndex];
+        return __classPrivateFieldGet(this, _Enum_indexes, "f")[__classPrivateFieldGet(this, _Enum_entryIndex, "f")];
     }
     /**
      * @description The value of the enum
      */
     get inner() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _Enum_raw, "f");
     }
     /**
      * @description true if this is a basic enum (no values)
      */
     get isBasic() {
-        return this.#isBasic;
+        return __classPrivateFieldGet(this, _Enum_isBasic, "f");
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.#raw.isEmpty;
+        return __classPrivateFieldGet(this, _Enum_raw, "f").isEmpty;
     }
     /**
      * @description Checks if the Enum points to a [[Null]] type
      */
     get isNone() {
-        return this.#raw instanceof Null;
+        return __classPrivateFieldGet(this, _Enum_raw, "f") instanceof Null;
     }
     /**
      * @description The available keys for this enum
      */
     get defIndexes() {
-        return this.#indexes;
+        return __classPrivateFieldGet(this, _Enum_indexes, "f");
     }
     /**
      * @description The available keys for this enum
      */
     get defKeys() {
-        return Object.keys(this.#def);
+        return Object.keys(__classPrivateFieldGet(this, _Enum_def, "f"));
     }
     /**
      * @description The name of the type this enum value represents
      */
     get type() {
-        return this.defKeys[this.#entryIndex];
+        return this.defKeys[__classPrivateFieldGet(this, _Enum_entryIndex, "f")];
     }
     /**
      * @description The value of the enum
      */
     get value() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _Enum_raw, "f");
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -259,7 +259,7 @@ export class Enum {
         else if (isNumber(other)) {
             return this.toNumber() === other;
         }
-        else if (this.#isBasic && isString(other)) {
+        else if (__classPrivateFieldGet(this, _Enum_isBasic, "f") && isString(other)) {
             return this.type === other;
         }
         else if (isHex(other)) {
@@ -278,10 +278,10 @@ export class Enum {
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        if (this.#isBasic) {
+        if (__classPrivateFieldGet(this, _Enum_isBasic, "f")) {
             return { outer: [new Uint8Array([this.index])] };
         }
-        const { inner, outer = [] } = this.#raw.inspect();
+        const { inner, outer = [] } = __classPrivateFieldGet(this, _Enum_raw, "f").inspect();
         return {
             inner,
             outer: [new Uint8Array([this.index]), ...outer]
@@ -297,17 +297,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 this.#isBasic || this.isNone
+        return __classPrivateFieldGet(this, _Enum_isBasic, "f") || this.isNone
             ? this.type
-            : { [this.type]: this.#raw.toHuman(isExtended) };
+            : { [this.type]: __classPrivateFieldGet(this, _Enum_raw, "f").toHuman(isExtended) };
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return this.#isBasic
+        return __classPrivateFieldGet(this, _Enum_isBasic, "f")
             ? this.type
-            : { [stringCamelCase(this.type)]: this.#raw.toJSON() };
+            : { [stringCamelCase(this.type)]: __classPrivateFieldGet(this, _Enum_raw, "f").toJSON() };
     }
     /**
      * @description Returns the number representation for the value
@@ -319,23 +319,23 @@ export class Enum {
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return this.#isBasic
+        return __classPrivateFieldGet(this, _Enum_isBasic, "f")
             ? this.type
-            : { [stringCamelCase(this.type)]: this.#raw.toPrimitive() };
+            : { [stringCamelCase(this.type)]: __classPrivateFieldGet(this, _Enum_raw, "f").toPrimitive() };
     }
     /**
      * @description Returns a raw struct representation of the enum types
      */
     _toRawStruct() {
-        if (this.#isBasic) {
-            return this.#isIndexed
+        if (__classPrivateFieldGet(this, _Enum_isBasic, "f")) {
+            return __classPrivateFieldGet(this, _Enum_isIndexed, "f")
                 ? this.defKeys.reduce((out, key, index) => {
-                    out[key] = this.#indexes[index];
+                    out[key] = __classPrivateFieldGet(this, _Enum_indexes, "f")[index];
                     return out;
                 }, {})
                 : this.defKeys;
         }
-        const entries = Object.entries(this.#def);
+        const entries = Object.entries(__classPrivateFieldGet(this, _Enum_def, "f"));
         return typesToMap(this.registry, entries.reduce((out, [key, { Type }], i) => {
             out[0][i] = Type;
             out[1][i] = key;
@@ -362,10 +362,11 @@ export class Enum {
      */
     toU8a(isBare) {
         return isBare
-            ? this.#raw.toU8a(isBare)
+            ? __classPrivateFieldGet(this, _Enum_raw, "f").toU8a(isBare)
             : u8aConcatStrict([
                 new Uint8Array([this.index]),
-                this.#raw.toU8a(isBare)
+                __classPrivateFieldGet(this, _Enum_raw, "f").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/Int.d.ts

@@ -1,5 +1,5 @@
-import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types';
-import { AbstractInt } from '../abstract/Int';
+import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
 /**
  * @name Int
  * @description

package/base/Null.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, Inspect, IU8a, Registry } from '../types';
+import type { Codec, Inspect, IU8a, Registry } from '../types/index.js';
 /**
  * @name Null
  * @description

package/base/Null.js

@@ -5,13 +5,10 @@ import { isNull } from '@polkadot/util';
  * Implements a type that does not contain anything (apart from `null`)
  */
 export class Null {
-    encodedLength = 0;
-    isEmpty = true;
-    registry;
-    createdAtHash;
-    initialU8aLength = 0;
-    isStorageFallback;
     constructor(registry) {
+        this.encodedLength = 0;
+        this.isEmpty = true;
+        this.initialU8aLength = 0;
         this.registry = registry;
     }
     /**

package/base/Option.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, Inspect, IOption, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, Inspect, IOption, IU8a, Registry } from '../types/index.js';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;

package/base/Option.js

@@ -1,3 +1,5 @@
+var _Option_Type, _Option_raw;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
 import { typeToConstructor } from '../utils/index.js';
 import { Null } from './Null.js';
@@ -52,13 +54,9 @@ function decodeOption(registry, Type, value) {
  * with a value if/as required/found.
  */
 export class Option {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #Type;
-    #raw;
     constructor(registry, typeName, value, { definition, setDefinition = noopSetDefinition } = {}) {
+        _Option_Type.set(this, void 0);
+        _Option_raw.set(this, void 0);
         const Type = definition || setDefinition(typeToConstructor(registry, typeName));
         const decoded = isU8a(value) && value.length && !isCodec(value)
             ? value[0] === 0
@@ -66,8 +64,8 @@ export class Option {
                 : new Type(registry, value.subarray(1))
             : decodeOption(registry, Type, value);
         this.registry = registry;
-        this.#Type = Type;
-        this.#raw = decoded;
+        __classPrivateFieldSet(this, _Option_Type, Type, "f");
+        __classPrivateFieldSet(this, _Option_raw, decoded, "f");
         if (decoded?.initialU8aLength) {
             this.initialU8aLength = 1 + decoded.initialU8aLength;
         }
@@ -89,7 +87,7 @@ export class Option {
      */
     get encodedLength() {
         // boolean byte (has value, doesn't have) along with wrapped length
-        return 1 + this.#raw.encodedLength;
+        return 1 + __classPrivateFieldGet(this, _Option_raw, "f").encodedLength;
     }
     /**
      * @description returns a hash of the contents
@@ -107,7 +105,7 @@ export class Option {
      * @description Checks if the Option has no value
      */
     get isNone() {
-        return this.#raw instanceof None;
+        return __classPrivateFieldGet(this, _Option_raw, "f") instanceof None;
     }
     /**
      * @description Checks if the Option has a value
@@ -119,7 +117,7 @@ export class Option {
      * @description The actual value for the Option
      */
     get value() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _Option_raw, "f");
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -137,7 +135,7 @@ export class Option {
         if (this.isNone) {
             return { outer: [new Uint8Array([0])] };
         }
-        const { inner, outer = [] } = this.#raw.inspect();
+        const { inner, outer = [] } = __classPrivateFieldGet(this, _Option_raw, "f").inspect();
         return {
             inner,
             outer: [new Uint8Array([1]), ...outer]
@@ -157,7 +155,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 this.#raw.toHuman(isExtended);
+        return __classPrivateFieldGet(this, _Option_raw, "f").toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
@@ -165,7 +163,7 @@ export class Option {
     toJSON() {
         return this.isNone
             ? null
-            : this.#raw.toJSON();
+            : __classPrivateFieldGet(this, _Option_raw, "f").toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
@@ -173,13 +171,13 @@ export class Option {
     toPrimitive() {
         return this.isNone
             ? null
-            : this.#raw.toPrimitive();
+            : __classPrivateFieldGet(this, _Option_raw, "f").toPrimitive();
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType(isBare) {
-        const wrapped = this.registry.getClassName(this.#Type) || new this.#Type(this.registry).toRawType();
+        const wrapped = this.registry.getClassName(__classPrivateFieldGet(this, _Option_Type, "f")) || new (__classPrivateFieldGet(this, _Option_Type, "f"))(this.registry).toRawType();
         return isBare
             ? wrapped
             : `Option<${wrapped}>`;
@@ -188,7 +186,7 @@ export class Option {
      * @description Returns the string representation of the value
      */
     toString() {
-        return this.#raw.toString();
+        return __classPrivateFieldGet(this, _Option_raw, "f").toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
@@ -196,12 +194,12 @@ export class Option {
      */
     toU8a(isBare) {
         if (isBare) {
-            return this.#raw.toU8a(true);
+            return __classPrivateFieldGet(this, _Option_raw, "f").toU8a(true);
         }
         const u8a = new Uint8Array(this.encodedLength);
         if (this.isSome) {
             u8a.set([1]);
-            u8a.set(this.#raw.toU8a(), 1);
+            u8a.set(__classPrivateFieldGet(this, _Option_raw, "f").toU8a(), 1);
         }
         return u8a;
     }
@@ -212,7 +210,7 @@ export class Option {
         if (this.isNone) {
             throw new Error('Option: unwrapping a None value');
         }
-        return this.#raw;
+        return __classPrivateFieldGet(this, _Option_raw, "f");
     }
     /**
      * @description Returns the value that the Option represents (if available) or defaultValue if none
@@ -230,6 +228,7 @@ export class Option {
     unwrapOrDefault() {
         return this.isSome
             ? this.unwrap()
-            : new this.#Type(this.registry);
+            : new (__classPrivateFieldGet(this, _Option_Type, "f"))(this.registry);
     }
-}
+}
+_Option_Type = new WeakMap(), _Option_raw = new WeakMap();

package/base/Result.d.ts

@@ -1,5 +1,5 @@
-import type { Codec, CodecClass, IResult, Registry } from '../types';
-import { Enum } from './Enum';
+import type { Codec, CodecClass, IResult, Registry } from '../types/index.js';
+import { Enum } from './Enum.js';
 /**
  * @name Result
  * @description

package/base/Tuple.d.ts

@@ -1,5 +1,5 @@
-import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
-import { AbstractArray } from '../abstract/Array';
+import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
 type TupleType = (CodecClass | string);
 type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;

package/base/Tuple.js

@@ -1,3 +1,5 @@
+var _Tuple_Types;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from '../abstract/Array.js';
 import { decodeU8a, mapToTypeMap, typeToConstructor } from '../utils/index.js';
@@ -40,7 +42,6 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 export class Tuple extends AbstractArray {
-    #Types;
     constructor(registry, Types, value, { definition, setDefinition = noopSetDefinition } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
             ? [Types.map((t) => typeToConstructor(registry, t)), []]
@@ -48,10 +49,11 @@ export class Tuple extends AbstractArray {
                 ? [[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];
-        this.#Types = Classes;
+        __classPrivateFieldSet(this, _Tuple_Types, Classes, "f");
     }
     static with(Types) {
         let definition;
@@ -77,9 +79,9 @@ export class Tuple extends AbstractArray {
      * @description The types definition of the tuple
      */
     get Types() {
-        return this.#Types[1].length
-            ? this.#Types[1]
-            : this.#Types[0].map((T) => new T(this.registry).toRawType());
+        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());
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
@@ -93,7 +95,7 @@ export class Tuple extends AbstractArray {
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        const types = this.#Types[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
+        const types = __classPrivateFieldGet(this, _Tuple_Types, "f")[0].map((T) => this.registry.getClassName(T) || new T(this.registry).toRawType());
         return `(${types.join(',')})`;
     }
     /**
@@ -110,4 +112,5 @@ export class Tuple extends AbstractArray {
     toU8a(isBare) {
         return u8aConcatStrict(this.toU8aInner(isBare));
     }
-}
+}
+_Tuple_Types = new WeakMap();

package/base/UInt.d.ts

@@ -1,5 +1,5 @@
-import type { CodecClass, UIntBitLength } from '../types';
-import { AbstractInt } from '../abstract/Int';
+import type { CodecClass, UIntBitLength } from '../types/index.js';
+import { AbstractInt } from '../abstract/Int.js';
 /**
  * @name UInt
  * @description

package/base/Vec.d.ts

@@ -1,6 +1,6 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecClass, Registry } from '../types';
-import { AbstractArray } from '../abstract/Array';
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;

package/base/Vec.js

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

package/base/VecAny.d.ts

@@ -1,5 +1,5 @@
-import type { Codec } from '../types';
-import { AbstractArray } from '../abstract/Array';
+import type { Codec } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
 /**
  * @name VecAny
  * @description

package/base/VecFixed.d.ts

@@ -1,6 +1,6 @@
 import type { HexString } from '@polkadot/util/types';
-import type { Codec, CodecClass, Inspect, Registry } from '../types';
-import { AbstractArray } from '../abstract/Array';
+import type { Codec, CodecClass, Inspect, Registry } from '../types/index.js';
+import { AbstractArray } from '../abstract/Array.js';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;

package/base/VecFixed.js

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