@polkadot/types-codec 9.5.2 → 9.6.2

package/cjs/base/VecFixed.js

@@ -4,30 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VecFixed = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Array = require("../abstract/Array");
-
 var _utils = require("../utils");
-
 var _Vec = require("./Vec");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function noopSetDefinition(d) {
   return d;
 }
+
 /**
  * @name VecFixed
  * @description
  * This manages codec arrays of a fixed length
  */
-
-
 class VecFixed extends _Array.AbstractArray {
   #Type;
-
   constructor(registry, Type, length) {
     let value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
     let {
@@ -38,12 +32,11 @@ class VecFixed extends _Array.AbstractArray {
     this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     this.initialU8aLength = ((0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, this, value, 0, this.#Type) : (0, _Vec.decodeVec)(registry, this, value, 0, this.#Type))[1];
   }
-
   static with(Type, length) {
-    let definition; // eslint-disable-next-line no-return-assign
+    let definition;
 
+    // eslint-disable-next-line no-return-assign
     const setDefinition = d => definition = d;
-
     return class extends VecFixed {
       constructor(registry, value) {
         super(registry, Type, length, value, {
@@ -51,57 +44,47 @@ class VecFixed extends _Array.AbstractArray {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The type for the items
    */
-
-
   get Type() {
     return new this.#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++) {
       total += this[i].encodedLength;
     }
-
     return total;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       inner: this.inspectInner()
     };
   }
-
   toU8a() {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
     const encoded = this.toU8aInner();
     return encoded.length ? (0, _util.u8aConcatStrict)(encoded) : new Uint8Array([]);
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `[${this.Type};${this.length}]`;
   }
-
 }
-
 exports.VecFixed = VecFixed;

package/cjs/base/index.js

@@ -75,27 +75,15 @@ Object.defineProperty(exports, "VecFixed", {
     return _VecFixed.VecFixed;
   }
 });
-
 var _Compact = require("./Compact");
-
 var _DoNotConstruct = require("./DoNotConstruct");
-
 var _Enum = require("./Enum");
-
 var _Int = require("./Int");
-
 var _Null = require("./Null");
-
 var _Option = require("./Option");
-
 var _Result = require("./Result");
-
 var _Tuple = require("./Tuple");
-
 var _UInt = require("./UInt");
-
 var _Vec = require("./Vec");
-
 var _VecAny = require("./VecAny");
-
 var _VecFixed = require("./VecFixed");

package/cjs/bundle.js

@@ -12,11 +12,8 @@ Object.defineProperty(exports, "packageInfo", {
     return _packageInfo.packageInfo;
   }
 });
-
 var _packageInfo = require("./packageInfo");
-
 var _abstract = require("./abstract");
-
 Object.keys(_abstract).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -28,9 +25,7 @@ Object.keys(_abstract).forEach(function (key) {
     }
   });
 });
-
 var _base = require("./base");
-
 Object.keys(_base).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -42,9 +37,7 @@ Object.keys(_base).forEach(function (key) {
     }
   });
 });
-
 var _extended = require("./extended");
-
 Object.keys(_extended).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -56,9 +49,7 @@ Object.keys(_extended).forEach(function (key) {
     }
   });
 });
-
 var _native = require("./native");
-
 Object.keys(_native).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -70,9 +61,7 @@ Object.keys(_native).forEach(function (key) {
     }
   });
 });
-
 var _primitive = require("./primitive");
-
 Object.keys(_primitive).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -84,9 +73,7 @@ Object.keys(_primitive).forEach(function (key) {
     }
   });
 });
-
 var _utils = require("./utils");
-
 Object.keys(_utils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;

package/cjs/detectPackage.js

@@ -1,14 +1,12 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 var _util = require("@polkadot/util");
-
 var _detectOther = _interopRequireDefault(require("./detectOther"));
-
 var _packageInfo = require("./packageInfo");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Do not edit, auto-generated by @polkadot/dev
+
 (0, _util.detectPackage)(_packageInfo.packageInfo, null, _detectOther.default);

package/cjs/extended/BTreeMap.js

@@ -4,21 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BTreeMap = void 0;
-
 var _Map = require("./Map");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 class BTreeMap extends _Map.CodecMap {
   static with(keyType, valType) {
     return class extends BTreeMap {
       constructor(registry, value) {
         super(registry, keyType, valType, value, 'BTreeMap');
       }
-
     };
   }
-
 }
-
 exports.BTreeMap = BTreeMap;

package/cjs/extended/BTreeSet.js

@@ -4,31 +4,26 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BTreeSet = void 0;
-
 var _util = require("@polkadot/util");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const l = (0, _util.logger)('BTreeSet');
-/** @internal */
 
+/** @internal */
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, count] = (0, _util.compactFromU8aLim)(u8a);
   const result = new Array(count);
   const [decodedLength] = (0, _utils.decodeU8aVec)(registry, result, u8a, offset, ValClass);
-
   for (let i = 0; i < count; i++) {
     output.add(result[i]);
   }
-
   return [ValClass, output, decodedLength];
 }
-/** @internal */
-
 
+/** @internal */
 function decodeSetFromSet(registry, ValClass, value) {
   const output = new Set();
   value.forEach(val => {
@@ -41,6 +36,7 @@ function decodeSetFromSet(registry, ValClass, value) {
   });
   return [ValClass, output, 0];
 }
+
 /**
  * Decode input to pass into constructor.
  *
@@ -55,11 +51,8 @@ function decodeSetFromSet(registry, ValClass, value) {
  * @param jsonSet
  * @internal
  */
-
-
 function decodeSet(registry, valType, value) {
   const ValClass = (0, _utils.typeToConstructor)(registry, valType);
-
   if (!value) {
     return [ValClass, new Set(), 0];
   } else if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
@@ -67,13 +60,10 @@ function decodeSet(registry, valType, value) {
   } else if (Array.isArray(value) || value instanceof Set) {
     return decodeSetFromSet(registry, ValClass, value);
   }
-
   throw new Error('BTreeSet: cannot decode type');
 }
-
 class BTreeSet extends Set {
   #ValClass;
-
   constructor(registry, valType, rawValue) {
     const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
     super((0, _utils.sortSet)(values));
@@ -81,164 +71,134 @@ class BTreeSet extends Set {
     this.initialU8aLength = decodedLength;
     this.#ValClass = ValClass;
   }
-
   static with(valType) {
     return class extends BTreeSet {
       constructor(registry, value) {
         super(registry, valType, value);
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     let len = (0, _util.compactToU8a)(this.size).length;
-
     for (const v of this.values()) {
       len += v.encodedLength;
     }
-
     return len;
   }
+
   /**
    * @description Returns a hash of the value
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.size === 0;
   }
+
   /**
    * @description The actual set values as a string[]
    */
-
-
   get strings() {
     return [...super.values()].map(v => v.toString());
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return (0, _utils.compareSet)(this, other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     const inner = new Array();
-
     for (const v of this.values()) {
       inner.push(v.inspect());
     }
-
     return {
       inner,
       outer: [(0, _util.compactToU8a)(this.size)]
     };
   }
+
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */
-
-
   toHex() {
     return (0, _util.u8aToHex)(this.toU8a());
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-
-
   toHuman(isExtended) {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toHuman(isExtended));
     }
-
     return json;
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toJSON());
     }
-
     return json;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `BTreeSet<${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     const json = [];
-
     for (const v of this.values()) {
       json.push(v.toPrimitive());
     }
-
     return json;
   }
+
   /**
    * @description Returns the string representation of the value
    */
-
-
   toString() {
     return (0, _util.stringify)(this.toJSON());
   }
+
   /**
    * @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) {
     const encoded = new Array();
-
     if (!isBare) {
       encoded.push((0, _util.compactToU8a)(this.size));
     }
-
     for (const v of this.values()) {
       encoded.push(v.toU8a(isBare));
     }
-
     return (0, _util.u8aConcatStrict)(encoded);
   }
-
 }
-
 exports.BTreeSet = BTreeSet;

package/cjs/extended/BitVec.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BitVec = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Raw = require("../native/Raw");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -16,43 +13,39 @@ var _Raw = require("../native/Raw");
 function decodeBitVecU8a(value) {
   if (!value || !value.length) {
     return [0, new Uint8Array()];
-  } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
-
+  }
 
+  // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
   const [offset, length] = (0, _util.compactFromU8aLim)(value);
   const total = offset + Math.ceil(length / 8);
-
   if (total > value.length) {
     throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
   }
-
   return [length, value.subarray(offset, total)];
 }
-/** @internal */
-
 
+/** @internal */
 function decodeBitVec(value) {
   if (Array.isArray(value) || (0, _util.isString)(value)) {
     const u8a = (0, _util.u8aToU8a)(value);
     return [u8a.length / 8, u8a];
   }
-
   return decodeBitVecU8a(value);
 }
+
 /**
  * @name BitVec
  * @description
  * A BitVec that represents an array of bits. The bits are however stored encoded. The difference between this
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
-
-
 class BitVec extends _Raw.Raw {
   #decodedLength;
-  #isMsb; // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
+  #isMsb;
+
+  // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
   // we are dealing with Lsb, which is the default (as of writing) BitVec format used
   // in the Polkadot code (this only affects the toHuman displays)
-
   constructor(registry, value) {
     let isMsb = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     const [decodedLength, u8a] = decodeBitVec(value);
@@ -60,47 +53,40 @@ class BitVec extends _Raw.Raw {
     this.#decodedLength = decodedLength;
     this.#isMsb = isMsb;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.length + (0, _util.compactToU8a)(this.#decodedLength).length;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       outer: [(0, _util.compactToU8a)(this.#decodedLength), super.toU8a()]
     };
   }
-
   toHuman() {
     return `0b${[...this.toU8a(true)].map(d => `00000000${d.toString(2)}`.slice(-8)).map(s => this.#isMsb ? s : s.split('').reverse().join('')).join('_')}`;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'BitVec';
   }
+
   /**
    * @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) {
     const bitVec = super.toU8a();
     return isBare ? bitVec : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.#decodedLength), bitVec]);
   }
-
 }
-
 exports.BitVec = BitVec;

package/cjs/extended/Bytes.js

@@ -4,34 +4,31 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Bytes = void 0;
-
 var _util = require("@polkadot/util");
-
 var _Raw = require("../native/Raw");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Bytes are used for things like on-chain code, so it has a healthy limit
 const MAX_LENGTH = 10 * 1024 * 1024;
-/** @internal */
 
+/** @internal */
 function decodeBytesU8a(value) {
   if (!value.length) {
     return [new Uint8Array(), 0];
-  } // handle all other Uint8Array inputs, these do have a length prefix
-
+  }
 
+  // handle all other Uint8Array inputs, these do have a length prefix
   const [offset, length] = (0, _util.compactFromU8aLim)(value);
   const total = offset + length;
-
   if (length > MAX_LENGTH) {
     throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
   } else if (total > value.length) {
     throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
   }
-
   return [value.subarray(offset, total), total];
 }
+
 /**
  * @name Bytes
  * @description
@@ -39,50 +36,42 @@ function decodeBytesU8a(value) {
  * is that this version allows for length-encoding. (i.e. it is a variable-item codec, the same
  * as what is found in [[Text]] and [[Vec]])
  */
-
-
 class Bytes extends _Raw.Raw {
   constructor(registry, value) {
     const [u8a, decodedLength] = (0, _util.isU8a)(value) && !(value instanceof _Raw.Raw) ? decodeBytesU8a(value) : Array.isArray(value) || (0, _util.isString)(value) ? [(0, _util.u8aToU8a)(value), 0] : [value, 0];
     super(registry, u8a, decodedLength);
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.length + (0, _util.compactToU8a)(this.length).length;
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect(isBare) {
     const clength = (0, _util.compactToU8a)(this.length);
     return {
       outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
     };
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Bytes';
   }
+
   /**
    * @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 isBare ? super.toU8a(isBare) : (0, _util.compactAddLength)(this);
   }
-
 }
-
 exports.Bytes = Bytes;