@polkadot/types-codec 10.0.1 → 10.1.2

package/abstract/Array.d.ts

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

package/abstract/Array.js

@@ -8,10 +8,6 @@ import { compareArray } from '../utils/compareArray.js';
  * @noInheritDoc
  */
 export class AbstractArray extends Array {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
     /**
      * @description This ensures that operators such as clice, filter, map, etc. return
      * new Array instances (without this we need to apply overrides)

package/abstract/Base.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, Codec, Inspect, IU8a, Registry } from '../types';
+import type { AnyJson, BareOpts, Codec, Inspect, IU8a, Registry } from '../types/index.js';
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value

package/abstract/Base.js

@@ -1,16 +1,14 @@
+var _AbstractBase_raw;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractBase {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #raw;
     constructor(registry, value, initialU8aLength) {
+        _AbstractBase_raw.set(this, void 0);
         this.initialU8aLength = initialU8aLength;
-        this.#raw = value;
+        __classPrivateFieldSet(this, _AbstractBase_raw, value, "f");
         this.registry = registry;
     }
     /**
@@ -29,73 +27,74 @@ export class AbstractBase {
      * @description returns the inner (wrapped value)
      */
     get inner() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.#raw.isEmpty;
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").isEmpty;
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return this.#raw.eq(other);
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").eq(other);
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        return this.#raw.inspect();
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").inspect();
     }
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
     toHex(isLe) {
-        return this.#raw.toHex(isLe);
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toHex(isLe);
     }
     /**
      * @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, _AbstractBase_raw, "f").toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return this.#raw.toJSON();
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return this.#raw.toPrimitive();
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toPrimitive();
     }
     /**
      * @description Returns the string representation of the value
      */
     toString() {
-        return this.#raw.toString();
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
      * @param isBare true when the value has none of the type-specific prefixes (internal)
      */
     toU8a(isBare) {
-        return this.#raw.toU8a(isBare);
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toU8a(isBare);
     }
     /**
      * @description Returns the inner wrapped value (equivalent to valueOf)
      */
     unwrap() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
     }
     /**
      * @description Returns the inner wrapped value
      */
     valueOf() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
     }
-}
+}
+_AbstractBase_raw = new WeakMap();

package/abstract/Int.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { HexString } from '@polkadot/util/types';
-import type { AnyNumber, Inspect, INumber, IU8a, Registry, UIntBitLength } from '../types';
+import type { AnyNumber, Inspect, INumber, IU8a, Registry, UIntBitLength } from '../types/index.js';
 import { BN } from '@polkadot/util';
 export declare const DEFAULT_UINT_BITS = 64;
 /**

package/abstract/Int.js

@@ -1,7 +1,9 @@
+var _AbstractInt_bitLength;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBigInt, isBn, isFunction, isHex, isNumber, isObject, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
 export const DEFAULT_UINT_BITS = 64;
 const MAX_NUMBER_BITS = 52;
-const MUL_P = new BN(1_00_00);
+const MUL_P = new BN(10000);
 const FORMATTERS = [
     ['Perquintill', BN_QUINTILL],
     ['Perbill', BN_BILLION],
@@ -58,13 +60,6 @@ function decodeAbstractInt(value, isNegative) {
  * @noInheritDoc
  */
 export class AbstractInt extends BN {
-    registry;
-    encodedLength;
-    isUnsigned;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #bitLength;
     constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
         // Construct via a string/number, which will be passed in the BN constructor.
         // It would be ideal to actually return a BN, but there is an issue:
@@ -76,10 +71,11 @@ export class AbstractInt extends BN {
                 ? u8aToNumber(value.subarray(0, bitLength / 8), { isNegative: isSigned })
                 : u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative: isSigned }).toString()
             : decodeAbstractInt(value, isSigned));
+        _AbstractInt_bitLength.set(this, void 0);
         this.registry = registry;
-        this.#bitLength = bitLength;
-        this.encodedLength = this.#bitLength / 8;
-        this.initialU8aLength = this.#bitLength / 8;
+        __classPrivateFieldSet(this, _AbstractInt_bitLength, bitLength, "f");
+        this.encodedLength = __classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8;
+        this.initialU8aLength = __classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8;
         this.isUnsigned = !isSigned;
         const isNegative = this.isNeg();
         const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
@@ -106,7 +102,7 @@ export class AbstractInt extends BN {
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return this.#bitLength;
+        return __classPrivateFieldGet(this, _AbstractInt_bitLength, "f");
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -132,7 +128,7 @@ export class AbstractInt extends BN {
      */
     isMax() {
         const u8a = this.toU8a().filter((b) => b === 0xff);
-        return u8a.length === (this.#bitLength / 8);
+        return u8a.length === (__classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8);
     }
     /**
      * @description Returns a BigInt representation of the number
@@ -226,4 +222,5 @@ export class AbstractInt extends BN {
             isNegative: !this.isUnsigned
         });
     }
-}
+}
+_AbstractInt_bitLength = new WeakMap();

package/abstract/Object.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, BareOpts, CodecObject, Inspect, IU8a, Registry, ToString } from '../types';
+import type { AnyJson, BareOpts, CodecObject, Inspect, IU8a, Registry, ToString } from '../types/index.js';
 /**
  * @name Object
  * @description A type extends the Base class, when it holds a value

package/abstract/Object.js

@@ -3,11 +3,6 @@
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractObject {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    $;
     constructor(registry, value, initialU8aLength) {
         this.$ = value;
         this.initialU8aLength = initialU8aLength;

package/abstract/index.d.ts

@@ -1,3 +1,3 @@
-export { AbstractArray } from './Array';
-export { AbstractBase } from './Base';
-export { AbstractInt } from './Int';
+export { AbstractArray } from './Array.js';
+export { AbstractBase } from './Base.js';
+export { AbstractInt } from './Int.js';

package/base/Compact.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, AnyNumber, CodecClass, ICompact, Inspect, INumber, IU8a, Registry } from '../types';
+import type { AnyJson, AnyNumber, CodecClass, ICompact, Inspect, INumber, IU8a, Registry } from '../types/index.js';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;

package/base/Compact.js

@@ -1,3 +1,5 @@
+var _Compact_Type, _Compact_raw;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { compactFromU8a, compactFromU8aLim, compactToU8a, isU8a } from '@polkadot/util';
 import { typeToConstructor } from '../utils/index.js';
 function noopSetDefinition(d) {
@@ -30,18 +32,14 @@ function decodeCompact(registry, Type, value) {
  * a number and making the compact representation thereof
  */
 export class Compact {
-    registry;
-    createdAtHash;
-    initialU8aLength;
-    isStorageFallback;
-    #Type;
-    #raw;
     constructor(registry, Type, value = 0, { definition, setDefinition = noopSetDefinition } = {}) {
+        _Compact_Type.set(this, void 0);
+        _Compact_raw.set(this, void 0);
         this.registry = registry;
-        this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-        const [raw, decodedLength] = decodeCompact(registry, this.#Type, value);
+        __classPrivateFieldSet(this, _Compact_Type, definition || setDefinition(typeToConstructor(registry, Type)), "f");
+        const [raw, decodedLength] = decodeCompact(registry, __classPrivateFieldGet(this, _Compact_Type, "f"), value);
         this.initialU8aLength = decodedLength;
-        this.#raw = raw;
+        __classPrivateFieldSet(this, _Compact_raw, raw, "f");
     }
     static with(Type) {
         let definition;
@@ -69,20 +67,20 @@ export class Compact {
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return this.#raw.isEmpty;
+        return __classPrivateFieldGet(this, _Compact_raw, "f").isEmpty;
     }
     /**
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return this.#raw.bitLength();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").bitLength();
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return this.#raw.eq(other instanceof Compact
-            ? other.#raw
+        return __classPrivateFieldGet(this, _Compact_raw, "f").eq(other instanceof Compact
+            ? __classPrivateFieldGet(other, _Compact_raw, "f")
             : other);
     }
     /**
@@ -97,55 +95,55 @@ export class Compact {
      * @description Returns a BigInt representation of the number
      */
     toBigInt() {
-        return this.#raw.toBigInt();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toBigInt();
     }
     /**
      * @description Returns the BN representation of the number
      */
     toBn() {
-        return this.#raw.toBn();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toBn();
     }
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
     toHex(isLe) {
-        return this.#raw.toHex(isLe);
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toHex(isLe);
     }
     /**
      * @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, _Compact_raw, "f").toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return this.#raw.toJSON();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toJSON();
     }
     /**
      * @description Returns the number representation for the value
      */
     toNumber() {
-        return this.#raw.toNumber();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toNumber();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return this.#raw.toPrimitive();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toPrimitive();
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `Compact<${this.registry.getClassName(this.#Type) || this.#raw.toRawType()}>`;
+        return `Compact<${this.registry.getClassName(__classPrivateFieldGet(this, _Compact_Type, "f")) || __classPrivateFieldGet(this, _Compact_raw, "f").toRawType()}>`;
     }
     /**
      * @description Returns the string representation of the value
      */
     toString() {
-        return this.#raw.toString();
+        return __classPrivateFieldGet(this, _Compact_raw, "f").toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
@@ -153,12 +151,13 @@ export class Compact {
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     toU8a(isBare) {
-        return compactToU8a(this.#raw.toBn());
+        return compactToU8a(__classPrivateFieldGet(this, _Compact_raw, "f").toBn());
     }
     /**
      * @description Returns the embedded [[UInt]] or [[Moment]] value
      */
     unwrap() {
-        return this.#raw;
+        return __classPrivateFieldGet(this, _Compact_raw, "f");
     }
-}
+}
+_Compact_Type = new WeakMap(), _Compact_raw = new WeakMap();

package/base/DoNotConstruct.d.ts

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

package/base/DoNotConstruct.js

@@ -1,17 +1,16 @@
+var _DoNotConstruct_neverError;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 /**
  * @name DoNotConstruct
  * @description
  * An unknown type that fails on construction with the type info
  */
 export class DoNotConstruct {
-    registry;
-    createdAtHash;
-    isStorageFallback;
-    #neverError;
     constructor(registry, typeName = 'DoNotConstruct') {
+        _DoNotConstruct_neverError.set(this, void 0);
         this.registry = registry;
-        this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
-        throw this.#neverError;
+        __classPrivateFieldSet(this, _DoNotConstruct_neverError, new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`), "f");
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     static with(typeName) {
         return class extends DoNotConstruct {
@@ -24,45 +23,46 @@ export class DoNotConstruct {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     /**
      * @description returns a hash of the contents
      */
     get hash() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     /**
      * @description Checks if the value is an empty value (always true)
      */
     get isEmpty() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     eq() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     inspect() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toHex() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toHuman() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toJSON() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toPrimitive() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toRawType() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toString() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
     toU8a() {
-        throw this.#neverError;
+        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
     }
-}
+}
+_DoNotConstruct_neverError = new WeakMap();

package/base/Enum.d.ts

@@ -1,5 +1,5 @@
 import type { HexString } from '@polkadot/util/types';
-import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from '../types';
+import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from '../types/index.js';
 export interface EnumCodecClass<T = Codec> {
     new (registry: Registry, value?: any, index?: number): T;
 }