@polkadot/types-codec 8.5.2-1 → 8.5.2-12

package/cjs/extended/index.js

@@ -51,6 +51,12 @@ Object.defineProperty(exports, "Map", {
     return _Map.CodecMap;
   }
 });
+Object.defineProperty(exports, "OptionBool", {
+  enumerable: true,
+  get: function () {
+    return _OptionBool.OptionBool;
+  }
+});
 Object.defineProperty(exports, "Range", {
   enumerable: true,
   get: function () {
@@ -102,6 +108,8 @@ var _Linkage = require("./Linkage");
 
 var _Map = require("./Map");
 
+var _OptionBool = require("./OptionBool");
+
 var _Range = require("./Range");
 
 var _RangeInclusive = require("./RangeInclusive");

package/cjs/native/Struct.js

@@ -11,21 +11,25 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
-function decodeStructFromObject(registry, Types, value, jsonMap) {
+
+
+function decodeStructFromObject(registry, _ref, value, jsonMap) {
+  let [Types, keys] = _ref;
   let jsonObj;
-  const inputKeys = Object.keys(Types);
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
   (0, _util.assert)(typeofArray || typeofMap || (0, _util.isObject)(value), () => `Struct: Cannot decode value ${(0, _util.stringify)(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  (0, _util.assert)(!typeofArray || value.length === inputKeys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${inputKeys.join(', ')}`);
-  const raw = new Array(inputKeys.length);
+  (0, _util.assert)(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${keys.join(', ')}`);
+  const raw = new Array(keys.length);
 
-  for (let i = 0; i < inputKeys.length; i++) {
-    const key = inputKeys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const jsonKey = jsonMap.get(key) || key;
-    const Type = Types[key];
+    const Type = Types[i];
     let assign;
 
     try {
@@ -84,8 +88,12 @@ class Struct extends Map {
 
   constructor(registry, Types, value) {
     let jsonMap = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
-    const typeMap = (0, _utils.mapToTypeMap)(registry, Types);
-    const [decoded, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, typeMap, true) : (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    const typeMap = definition || setDefinition((0, _utils.mapToTypeMap)(registry, Types));
+    const [decoded, decodedLength] = (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, new Array(typeMap[0].length), (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
     this.#registry = registry;
     this.initialU8aLength = decodedLength;
@@ -95,9 +103,16 @@ class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         (0, _util.objectProperties)(this, keys, k => this.get(k));
       }
 
@@ -109,7 +124,7 @@ class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -136,11 +151,10 @@ class Struct extends Map {
 
   get Type() {
     const result = {};
-    const defs = Object.entries(this.#Types);
+    const [Types, keys] = this.#Types;
 
-    for (let i = 0; i < defs.length; i++) {
-      const [key, Type] = defs[i];
-      result[key] = new Type(this.registry).toRawType();
+    for (let i = 0; i < keys.length; i++) {
+      result[keys[i]] = new Types[i](this.registry).toRawType();
     }
 
     return result;
@@ -201,11 +215,11 @@ class Struct extends Map {
    */
 
 
-  inspect() {
+  inspect(isBare) {
     const inner = new Array();
 
     for (const [k, v] of this.entries()) {
-      inner.push({ ...v.inspect(),
+      inner.push({ ...v.inspect(!isBare || (0, _util.isBoolean)(isBare) ? isBare : isBare[k]),
         name: (0, _util.stringCamelCase)(k)
       });
     }
@@ -290,7 +304,7 @@ class Struct extends Map {
       }
     }
 
-    return (0, _util.u8aConcat)(...encoded);
+    return (0, _util.u8aConcatStrict)(encoded);
   }
 
 }

package/cjs/native/Text.js

@@ -26,9 +26,9 @@ function decodeText(value) {
       return [(0, _util.u8aToString)(value), 0];
     }
 
-    const [offset, length] = (0, _util.compactFromU8a)(value);
-    const total = offset + length.toNumber();
-    (0, _util.assert)(length.lten(MAX_LENGTH), () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    const [offset, length] = (0, _util.compactFromU8aLim)(value);
+    const total = offset + length;
+    (0, _util.assert)(length <= MAX_LENGTH, () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
     (0, _util.assert)(total <= value.length, () => `Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
     return [(0, _util.u8aToString)(value.subarray(offset, total)), total];
   } else if ((0, _util.isHex)(value)) {

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-codec',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.5.2-1'
+  version: '8.5.2-12'
 };
 exports.packageInfo = packageInfo;

package/cjs/utils/decodeU8a.js

@@ -31,12 +31,12 @@ function getRawType(registry, Type) {
  */
 
 
-function decodeU8a(registry, u8a, types, withZip) {
-  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
-  const result = new Array(Types.length);
+function decodeU8a(registry, result, u8a, _ref, withZip) {
+  let [Types, keys] = _ref;
+  const count = result.length;
   let offset = 0;
 
-  for (let i = 0; i < Types.length; i++) {
+  for (let i = 0; i < count; i++) {
     try {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
@@ -51,9 +51,9 @@ function decodeU8a(registry, u8a, types, withZip) {
 // since we have to do less checks (and these are intensive anyway), much faster
 
 
-function decodeU8aVec(registry, u8a, start, Type, count) {
-  const result = new Array(count);
-  let offset = start;
+function decodeU8aVec(registry, result, u8a, startAt, Type) {
+  const count = result.length;
+  let offset = startAt;
 
   for (let i = 0; i < count; i++) {
     try {
@@ -65,5 +65,5 @@ function decodeU8aVec(registry, u8a, start, Type, count) {
     }
   }
 
-  return [result, offset, offset - start];
+  return [offset, offset - startAt];
 }

package/cjs/utils/mapToTypeMap.js

@@ -15,10 +15,12 @@ var _typeToConstructor = require("./typeToConstructor");
  */
 function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
-  const output = {};
+  const count = entries.length;
+  const output = [new Array(count), new Array(count)];
 
   for (let i = 0; i < entries.length; i++) {
-    output[entries[i][0]] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
+    output[1][i] = entries[i][0];
+    output[0][i] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
   }
 
   return output;

package/cjs/utils/sanitize.js

@@ -14,6 +14,7 @@ exports.removePairOf = removePairOf;
 exports.removeTraits = removeTraits;
 exports.removeWrap = removeWrap;
 exports.sanitize = sanitize;
+exports.trim = trim;
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
@@ -35,7 +36,13 @@ alias('RawAddress', 'Address'), // lookups, mapped to Address/AccountId as appro
 alias('Lookup::Source', 'LookupSource'), alias('Lookup::Target', 'LookupTarget'), // HACK duplication between contracts & primitives, however contracts prefixed with exec
 alias('exec::StorageKey', 'ContractStorageKey'), // flattens tuples with one value, `(AccountId)` -> `AccountId`
 flattenSingleTuple(), // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-removeColons()]; // given a starting index, find the closing >
+removeColons(), // remove all trailing spaces - this should always be the last
+trim()]; // given a string, trim it
+
+function trim() {
+  return value => value.trim();
+} // given a starting index, find the closing >
+
 
 function findClosing(value, start) {
   let depth = 0;
@@ -218,10 +225,11 @@ function removeWrap(check) {
 const sanitizeMap = new Map(); // eslint-disable-next-line @typescript-eslint/ban-types
 
 function sanitize(value, options) {
-  let result = value.toString();
+  const startValue = value.toString();
+  let result = startValue;
 
   if (!options) {
-    const memoized = sanitizeMap.get(result);
+    const memoized = sanitizeMap.get(startValue);
 
     if (memoized) {
       return memoized;
@@ -232,10 +240,8 @@ function sanitize(value, options) {
     result = mappings[i](result, options);
   }
 
-  result = result.trim();
-
   if (!options) {
-    sanitizeMap.set(value.toString(), result);
+    sanitizeMap.set(startValue, result);
   }
 
   return result;

package/cjs/utils/typesToMap.js

@@ -7,13 +7,12 @@ exports.typesToMap = typesToMap;
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function typesToMap(registry, Types) {
-  const entries = Object.entries(Types);
+function typesToMap(registry, _ref) {
+  let [Types, keys] = _ref;
   const result = {};
 
-  for (let i = 0; i < entries.length; i++) {
-    const [key, Type] = entries[i];
-    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
 
   return result;

package/extended/BTreeSet.js

@@ -1,17 +1,18 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { compactFromU8a, compactToU8a, isHex, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, compactToU8a, isHex, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareSet, decodeU8aVec, sortSet, typeToConstructor } from "../utils/index.js";
 const l = logger('BTreeSet');
 /** @internal */
 
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
-  const [offset, length] = compactFromU8a(u8a);
-  const [values, decodedLength] = decodeU8aVec(registry, u8a, offset, ValClass, length.toNumber());
+  const [offset, count] = compactFromU8aLim(u8a);
+  const result = new Array(count);
+  const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];
@@ -212,7 +213,7 @@ export class BTreeSet extends Set {
       encoded.push(v.toU8a(isBare));
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/extended/BitVec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8a, compactToU8a, isString, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { assert, compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 /** @internal */
 
@@ -10,10 +10,10 @@ function decodeBitVecU8a(value) {
   } // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
 
 
-  const [offset, length] = compactFromU8a(value);
-  const total = offset + Math.ceil(length.toNumber() / 8);
+  const [offset, length] = compactFromU8aLim(value);
+  const total = offset + Math.ceil(length / 8);
   assert(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
-  return [length.toNumber(), value.subarray(offset, total)];
+  return [length, value.subarray(offset, total)];
 }
 /** @internal */
 
@@ -84,7 +84,7 @@ export class BitVec extends Raw {
 
   toU8a(isBare) {
     const bitVec = super.toU8a();
-    return isBare ? bitVec : u8aConcat(compactToU8a(this.#decodedLength), bitVec);
+    return isBare ? bitVec : u8aConcatStrict([compactToU8a(this.#decodedLength), bitVec]);
   }
 
 }

package/extended/Bytes.d.ts

@@ -16,7 +16,7 @@ export declare class Bytes extends Raw {
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
-    inspect(): Inspect;
+    inspect(isBare?: boolean): Inspect;
     /**
      * @description Returns the base runtime type name for this instance
      */

package/extended/Bytes.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8a, compactToU8a, isCodec, isString, isU8a, u8aToU8a } from '@polkadot/util';
+import { assert, compactAddLength, compactFromU8aLim, compactToU8a, isCodec, isString, isU8a, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js"; // Bytes are used for things like on-chain code, so it has a healthy limit
 
 const MAX_LENGTH = 10 * 1024 * 1024;
@@ -12,9 +12,9 @@ function decodeBytesU8a(value) {
   } // handle all other Uint8Array inputs, these do have a length prefix
 
 
-  const [offset, length] = compactFromU8a(value);
-  const total = offset + length.toNumber();
-  assert(length.lten(MAX_LENGTH), () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  const [offset, length] = compactFromU8aLim(value);
+  const total = offset + length;
+  assert(length <= MAX_LENGTH, () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
   assert(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
   return [value.subarray(offset, total), total];
 }
@@ -45,10 +45,10 @@ export class Bytes extends Raw {
    */
 
 
-  inspect() {
+  inspect(isBare) {
     const clength = compactToU8a(this.length);
     return {
-      outer: this.length ? [clength, super.toU8a()] : [clength]
+      outer: isBare ? [super.toU8a()] : this.length ? [clength, super.toU8a()] : [clength]
     };
   }
   /**

package/extended/Map.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { compactFromU8a, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { Enum } from "../base/Enum.js";
 import { Struct } from "../native/Struct.js";
@@ -10,15 +10,14 @@ const l = logger('Map');
 
 function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
   const output = new Map();
-  const [offset, length] = compactFromU8a(u8a);
-  const count = length.toNumber();
+  const [offset, count] = compactFromU8aLim(u8a);
   const types = [];
 
   for (let i = 0; i < count; i++) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = decodeU8a(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = decodeU8a(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);
@@ -218,7 +217,7 @@ export class CodecMap extends Map {
       encoded.push(k.toU8a(isBare), v.toU8a(isBare));
     }
 
-    return u8aConcat(...encoded);
+    return u8aConcatStrict(encoded);
   }
 
 }

package/extended/OptionBool.d.ts

@@ -0,0 +1,40 @@
+import type { HexString } from '@polkadot/util/types';
+import type { AnyBool, Inspect, Registry } from '../types';
+import { Option } from '../base/Option';
+import { bool as Bool } from '../native/Bool';
+/**
+ * @name OptionBool
+ * @description A specific implementation of Option<bool> than allows for single-byte encoding
+ */
+export declare class OptionBool extends Option<Bool> {
+    constructor(registry: Registry, value?: Option<Bool> | AnyBool | Uint8Array | HexString | null);
+    /**
+     * @description The length of the value when encoded as a Uint8Array
+     */
+    get encodedLength(): number;
+    /**
+     * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+     */
+    get initialU8aLength(): number;
+    /**
+     * @description Checks if the value is an empty value (always false)
+     */
+    get isFalse(): boolean;
+    /**
+     * @description Checks if the value is an empty value (always false)
+     */
+    get isTrue(): boolean;
+    /**
+     * @description Returns a breakdown of the hex encoding for this Codec
+     */
+    inspect(): Inspect;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(isBare?: boolean): string;
+    /**
+     * @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?: boolean): Uint8Array;
+}

package/extended/OptionBool.js

@@ -0,0 +1,88 @@
+// Copyright 2017-2022 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isHex, isU8a, u8aToU8a } from '@polkadot/util';
+import { Option } from "../base/Option.js";
+import { bool as Bool } from "../native/Bool.js";
+
+function decodeU8a(registry, value) {
+  // Encoded as -
+  //  - 0 = None
+  //  - 1 = True
+  //  - 2 = False
+  return value[0] === 0 ? null : new Bool(registry, value[0] === 1);
+}
+/**
+ * @name OptionBool
+ * @description A specific implementation of Option<bool> than allows for single-byte encoding
+ */
+
+
+export class OptionBool extends Option {
+  constructor(registry, value) {
+    super(registry, Bool, isU8a(value) || isHex(value) ? decodeU8a(registry, u8aToU8a(value)) : value);
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+
+
+  get encodedLength() {
+    return 1;
+  }
+  /**
+   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
+   */
+
+
+  get initialU8aLength() {
+    return 1;
+  }
+  /**
+   * @description Checks if the value is an empty value (always false)
+   */
+
+
+  get isFalse() {
+    return this.isSome ? !this.value.valueOf() : false;
+  }
+  /**
+   * @description Checks if the value is an empty value (always false)
+   */
+
+
+  get isTrue() {
+    return this.isSome ? this.value.valueOf() : false;
+  }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+
+
+  inspect() {
+    return {
+      outer: [this.toU8a()]
+    };
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+
+
+  toRawType(isBare) {
+    return isBare ? 'bool' : 'Option<bool>';
+  }
+  /**
+   * @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) {
+    if (isBare) {
+      return super.toU8a(true);
+    }
+
+    return this.isSome ? new Uint8Array([this.isTrue ? 1 : 2]) : new Uint8Array([0]);
+  }
+
+}

package/extended/index.d.ts

@@ -5,6 +5,7 @@ export { Bytes } from './Bytes';
 export { HashMap } from './HashMap';
 export { Linkage } from './Linkage';
 export { CodecMap, CodecMap as Map } from './Map';
+export { OptionBool } from './OptionBool';
 export { Range } from './Range';
 export { RangeInclusive } from './RangeInclusive';
 export { Type } from './Type';

package/extended/index.js

@@ -7,6 +7,7 @@ export { Bytes } from "./Bytes.js";
 export { HashMap } from "./HashMap.js";
 export { Linkage } from "./Linkage.js";
 export { CodecMap, CodecMap as Map } from "./Map.js";
+export { OptionBool } from "./OptionBool.js";
 export { Range } from "./Range.js";
 export { RangeInclusive } from "./RangeInclusive.js";
 export { Type } from "./Type.js";

package/native/Struct.d.ts

@@ -1,6 +1,11 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, BareOpts, Codec, CodecClass, Inspect, IStruct, IU8a, Registry } from '../types';
 declare type TypesDef<T = Codec> = Record<string, string | CodecClass<T>>;
+declare type Definition = [CodecClass[], string[]];
+interface Options {
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Struct
  * @description
@@ -23,7 +28,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>);
+    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>, { definition, setDefinition }?: Options);
     static with<S extends TypesDef>(Types: S, jsonMap?: Map<string, string>): CodecClass<Struct<S>>;
     /**
      * @description The available keys for this struct
@@ -63,7 +68,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
-    inspect(): Inspect;
+    inspect(isBare?: BareOpts): Inspect;
     /**
      * @description Converts the Object to an standard JavaScript Array
      */