@polkadot/types-codec 9.14.2 → 10.1.1

package/utils/index.js

@@ -1,12 +1,9 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { compareArray } from "./compareArray.js";
-export { compareMap } from "./compareMap.js";
-export { compareSet } from "./compareSet.js";
-export { decodeU8a, decodeU8aStruct, decodeU8aVec } from "./decodeU8a.js";
-export { mapToTypeMap } from "./mapToTypeMap.js";
-export { typeToConstructor } from "./typeToConstructor.js";
-export { sanitize } from "./sanitize.js";
-export { sortAsc, sortSet, sortMap } from "./sortValues.js";
-export { typesToMap } from "./typesToMap.js";
+export { compareArray } from './compareArray.js';
+export { compareMap } from './compareMap.js';
+export { compareSet } from './compareSet.js';
+export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
+export { mapToTypeMap } from './mapToTypeMap.js';
+export { typeToConstructor } from './typeToConstructor.js';
+export { sanitize } from './sanitize.js';
+export { sortAsc, sortSet, sortMap } from './sortValues.js';
+export { typesToMap } from './typesToMap.js';

package/utils/mapToTypeMap.d.ts

@@ -1,4 +1,4 @@
-import type { CodecClass, Registry } from '../types';
+import type { CodecClass, Registry } from '../types/index.js';
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */

package/utils/mapToTypeMap.js

@@ -1,18 +1,14 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { typeToConstructor } from "./typeToConstructor.js";
-
+import { typeToConstructor } from './typeToConstructor.js';
 /**
  * @description takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
  */
 export function mapToTypeMap(registry, input) {
-  const entries = Object.entries(input);
-  const count = entries.length;
-  const output = [new Array(count), new Array(count)];
-  for (let i = 0; i < count; i++) {
-    output[1][i] = entries[i][0];
-    output[0][i] = typeToConstructor(registry, entries[i][1]);
-  }
-  return output;
+    const entries = Object.entries(input);
+    const count = entries.length;
+    const output = [new Array(count), new Array(count)];
+    for (let i = 0; i < count; i++) {
+        output[1][i] = entries[i][0];
+        output[0][i] = typeToConstructor(registry, entries[i][1]);
+    }
+    return output;
 }

package/utils/sanitize.d.ts

@@ -1,4 +1,4 @@
-import { AnyString } from '../types';
+import { AnyString } from '../types/index.js';
 type Mapper = (value: string) => string;
 export declare function trim(): Mapper;
 export declare function findClosing(value: string, start: number): number;

package/utils/sanitize.js

@@ -1,222 +1,219 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
 const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
 const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
-
 const mappings = [
-// alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false), alias('VecDeque<', 'Vec<', false),
-// <T::Balance as HasCompact>
-cleanupCompact(),
-// Change BoundedVec<Type, Size> to Vec<Type>
-removeExtensions('Bounded', true),
-// Change WeakVec<Type> to Vec<Type>
-removeExtensions('Weak', false),
-// Remove all the trait prefixes
-removeTraits(),
-// remove PairOf<T> -> (T, T)
-removePairOf(),
-// remove boxing, `Box<Proposal>` -> `Proposal`
-removeWrap('Box<'),
-// remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-removeGenerics(),
-// alias String -> Text (compat with jsonrpc methods)
-alias('String', 'Text'),
-// alias Vec<u8> -> Bytes
-alias('Vec<u8>', 'Bytes'), alias('&\\[u8\\]', 'Bytes'), alias("&'static\\[u8\\]", 'Bytes'),
-// alias RawAddress -> Address
-alias('RawAddress', 'Address'),
-// lookups, mapped to Address/AccountId as appropriate in runtime
-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(),
-// remove all trailing spaces - this should always be the last
-trim()];
-
-// given a string, trim it
+    // alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
+    alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
+    alias('VecDeque<', 'Vec<', false),
+    // <T::Balance as HasCompact>
+    cleanupCompact(),
+    // Change BoundedVec<Type, Size> to Vec<Type>
+    removeExtensions('Bounded', true),
+    // Change WeakVec<Type> to Vec<Type>
+    removeExtensions('Weak', false),
+    // Remove all the trait prefixes
+    removeTraits(),
+    // remove PairOf<T> -> (T, T)
+    removePairOf(),
+    // remove boxing, `Box<Proposal>` -> `Proposal`
+    removeWrap('Box<'),
+    // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
+    removeGenerics(),
+    // alias String -> Text (compat with jsonrpc methods)
+    alias('String', 'Text'),
+    // alias Vec<u8> -> Bytes
+    alias('Vec<u8>', 'Bytes'),
+    alias('&\\[u8\\]', 'Bytes'),
+    alias("&'static\\[u8\\]", 'Bytes'),
+    // alias RawAddress -> Address
+    alias('RawAddress', 'Address'),
+    // lookups, mapped to Address/AccountId as appropriate in runtime
+    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(),
+    // remove all trailing spaces - this should always be the last
+    trim()
+];
 export function trim() {
-  return value => value.trim();
+    return (value) => value.trim();
 }
-
-// given a starting index, find the closing >
 export function findClosing(value, start) {
-  let depth = 0;
-  for (let index = start; index < value.length; index++) {
-    if (value[index] === '>') {
-      if (!depth) {
-        return index;
-      }
-      depth--;
-    } else if (value[index] === '<') {
-      depth++;
+    let depth = 0;
+    for (let index = start; index < value.length; index++) {
+        if (value[index] === '>') {
+            if (!depth) {
+                return index;
+            }
+            depth--;
+        }
+        else if (value[index] === '<') {
+            depth++;
+        }
     }
-  }
-  throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
+    throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
 }
 export function alias(src, dest, withChecks = true) {
-  const from = new RegExp(`(^${src}|${BOX_PRECEDING.map(box => `\\${box}${src}`).join('|')})`, 'g');
-  const to = src => {
-    from.lastIndex = 0;
-    return withChecks && BOX_PRECEDING.includes(src[0]) ? `${src[0]}${dest}` : dest;
-  };
-  return value => value.replace(from, to);
+    const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join('|')})`, 'g');
+    const to = (src) => {
+        from.lastIndex = 0;
+        return withChecks && BOX_PRECEDING.includes(src[0])
+            ? `${src[0]}${dest}`
+            : dest;
+    };
+    return (value) => value.replace(from, to);
 }
 export function cleanupCompact() {
-  return value => {
-    if (value.includes(' as HasCompact')) {
-      for (let index = 0; index < value.length; index++) {
-        if (value[index] === '<') {
-          const end = findClosing(value, index + 1) - 14;
-          if (value.substring(end, end + 14) === ' as HasCompact') {
-            value = `Compact<${value.substring(index + 1, end)}>`;
-          }
+    return (value) => {
+        if (value.includes(' as HasCompact')) {
+            for (let index = 0; index < value.length; index++) {
+                if (value[index] === '<') {
+                    const end = findClosing(value, index + 1) - 14;
+                    if (value.substring(end, end + 14) === ' as HasCompact') {
+                        value = `Compact<${value.substring(index + 1, end)}>`;
+                    }
+                }
+            }
         }
-      }
-    }
-    return value;
-  };
+        return value;
+    };
 }
 export function flattenSingleTuple() {
-  const from1 = /,\)/g;
-  const from2 = /\(([^,]+)\)/;
-  return value => {
-    from1.lastIndex = 0;
-    return value
-    // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-    .replace(from1, ')')
-    // change (u32) -> u32
-    .replace(from2, '$1');
-  };
+    const from1 = /,\)/g;
+    const from2 = /\(([^,]+)\)/;
+    return (value) => {
+        from1.lastIndex = 0;
+        return value
+            // tuples may have trailing commas, e.g. (u32, BlockNumber, )
+            .replace(from1, ')')
+            // change (u32) -> u32
+            .replace(from2, '$1');
+    };
 }
 function replaceTagWith(value, matcher, replacer) {
-  let index = -1;
-  while (true) {
-    index = value.indexOf(matcher, index + 1);
-    if (index === -1) {
-      return value;
+    let index = -1;
+    while (true) {
+        index = value.indexOf(matcher, index + 1);
+        if (index === -1) {
+            return value;
+        }
+        const start = index + matcher.length;
+        const end = findClosing(value, start);
+        value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
     }
-    const start = index + matcher.length;
-    const end = findClosing(value, start);
-    value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
-  }
 }
-
-// remove the Bounded* or Weak* wrappers
 export function removeExtensions(type, isSized) {
-  return value => {
-    for (let i = 0; i < BOUNDED.length; i++) {
-      const tag = BOUNDED[i];
-      value = replaceTagWith(value, `${type}${tag}<`, v => {
-        const parts = v.split(',').map(s => s.trim()).filter(s => s);
-        if (isSized) {
-          parts.pop();
+    return (value) => {
+        for (let i = 0; i < BOUNDED.length; i++) {
+            const tag = BOUNDED[i];
+            value = replaceTagWith(value, `${type}${tag}<`, (v) => {
+                const parts = v
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter((s) => s);
+                if (isSized) {
+                    parts.pop();
+                }
+                return `${tag}<${parts.join(',')}>`;
+            });
         }
-        return `${tag}<${parts.join(',')}>`;
-      });
-    }
-    return value;
-  };
+        return value;
+    };
 }
 export function removeColons() {
-  return value => {
-    let index = 0;
-    while (index !== -1) {
-      index = value.indexOf('::');
-      if (index === 0) {
-        value = value.substring(2);
-      } else if (index !== -1) {
-        let start = index;
-        while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
-          start--;
+    return (value) => {
+        let index = 0;
+        while (index !== -1) {
+            index = value.indexOf('::');
+            if (index === 0) {
+                value = value.substring(2);
+            }
+            else if (index !== -1) {
+                let start = index;
+                while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
+                    start--;
+                }
+                value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
+            }
         }
-        value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
-      }
-    }
-    return value;
-  };
+        return value;
+    };
 }
 export function removeGenerics() {
-  return value => {
-    for (let index = 0; index < value.length; index++) {
-      if (value[index] === '<') {
-        // check against the allowed wrappers, be it Vec<..>, Option<...> ...
-        const box = ALLOWED_BOXES.find(box => {
-          const start = index - box.length;
-          return start >= 0 && value.substring(start, index) === box && (
-          // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
-          start === 0 || BOX_PRECEDING.includes(value[start - 1]));
-        });
-
-        // we have not found anything, unwrap generic innards
-        if (!box) {
-          const end = findClosing(value, index + 1);
-          value = `${value.substring(0, index)}${value.substring(end + 1)}`;
+    return (value) => {
+        for (let index = 0; index < value.length; index++) {
+            if (value[index] === '<') {
+                // check against the allowed wrappers, be it Vec<..>, Option<...> ...
+                const box = ALLOWED_BOXES.find((box) => {
+                    const start = index - box.length;
+                    return ((start >= 0 &&
+                        value.substring(start, index) === box) && (
+                    // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+                    start === 0 ||
+                        BOX_PRECEDING.includes(value[start - 1])));
+                });
+                // we have not found anything, unwrap generic innards
+                if (!box) {
+                    const end = findClosing(value, index + 1);
+                    value = `${value.substring(0, index)}${value.substring(end + 1)}`;
+                }
+            }
         }
-      }
-    }
-    return value;
-  };
+        return value;
+    };
 }
-
-// remove the PairOf wrappers
 export function removePairOf() {
-  const replacer = v => `(${v},${v})`;
-  return value => replaceTagWith(value, 'PairOf<', replacer);
+    const replacer = (v) => `(${v},${v})`;
+    return (value) => replaceTagWith(value, 'PairOf<', replacer);
 }
-
-// remove the type traits
 export function removeTraits() {
-  const from1 = /\s/g;
-  const from2 = /(T|Self)::/g;
-  const from3 = /<(T|Self)asTrait>::/g;
-  const from4 = /<Tas[a-z]+::Trait>::/g;
-  const from5 = /<LookupasStaticLookup>/g;
-  const from6 = /::Type/g;
-  return value => {
-    from1.lastIndex = 0;
-    from2.lastIndex = 0;
-    from3.lastIndex = 0;
-    from4.lastIndex = 0;
-    from5.lastIndex = 0;
-    from6.lastIndex = 0;
-    return value
-    // remove all whitespaces
-    .replace(from1, '')
-    // anything `T::<type>` to end up as `<type>`
-    .replace(from2, '')
-    // replace `<T as Trait>::` (whitespaces were removed above)
-    .replace(from3, '')
-    // replace `<T as something::Trait>::` (whitespaces were removed above)
-    .replace(from4, '')
-    // replace <Lookup as StaticLookup>
-    .replace(from5, 'Lookup')
-    // replace `<...>::Type`
-    .replace(from6, '');
-  };
+    const from1 = /\s/g;
+    const from2 = /(T|Self)::/g;
+    const from3 = /<(T|Self)asTrait>::/g;
+    const from4 = /<Tas[a-z]+::Trait>::/g;
+    const from5 = /<LookupasStaticLookup>/g;
+    const from6 = /::Type/g;
+    return (value) => {
+        from1.lastIndex = 0;
+        from2.lastIndex = 0;
+        from3.lastIndex = 0;
+        from4.lastIndex = 0;
+        from5.lastIndex = 0;
+        from6.lastIndex = 0;
+        return value
+            // remove all whitespaces
+            .replace(from1, '')
+            // anything `T::<type>` to end up as `<type>`
+            .replace(from2, '')
+            // replace `<T as Trait>::` (whitespaces were removed above)
+            .replace(from3, '')
+            // replace `<T as something::Trait>::` (whitespaces were removed above)
+            .replace(from4, '')
+            // replace <Lookup as StaticLookup>
+            .replace(from5, 'Lookup')
+            // replace `<...>::Type`
+            .replace(from6, '');
+    };
 }
-
-// remove wrapping values, i.e. Box<Proposal> -> Proposal
 export function removeWrap(check) {
-  const replacer = v => v;
-  return value => replaceTagWith(value, check, replacer);
+    const replacer = (v) => v;
+    return (value) => replaceTagWith(value, check, replacer);
 }
 const sanitizeMap = new Map();
 export function sanitize(value) {
-  const startValue = value.toString();
-  const memoized = sanitizeMap.get(startValue);
-  if (memoized) {
-    return memoized;
-  }
-  let result = startValue;
-  for (let i = 0; i < mappings.length; i++) {
-    result = mappings[i](result);
-  }
-  sanitizeMap.set(startValue, result);
-  return result;
+    const startValue = value.toString();
+    const memoized = sanitizeMap.get(startValue);
+    if (memoized) {
+        return memoized;
+    }
+    let result = startValue;
+    for (let i = 0; i < mappings.length; i++) {
+        result = mappings[i](result);
+    }
+    sanitizeMap.set(startValue, result);
+    return result;
 }

package/utils/sortValues.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import type { BN } from '@polkadot/util';
-import type { Codec } from '../types';
+import type { Codec } from '../types/index.js';
 type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
 /**
 * Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap

package/utils/sortValues.js

@@ -1,64 +1,60 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { bnToBn, isBigInt, isBn, isFunction, isNumber, stringify } from '@polkadot/util';
 /** @internal **/
 function isArrayLike(arg) {
-  return arg instanceof Uint8Array || Array.isArray(arg);
+    return arg instanceof Uint8Array || Array.isArray(arg);
 }
-
 /** @internal **/
 function isCodec(arg) {
-  return isFunction(arg && arg.toU8a);
+    return isFunction(arg && arg.toU8a);
 }
-
 /** @internal **/
 function isEnum(arg) {
-  return isCodec(arg) && isNumber(arg.index) && isCodec(arg.value);
+    return isCodec(arg) && isNumber(arg.index) && isCodec(arg.value);
 }
-
 /** @internal */
 function isNumberLike(arg) {
-  return isNumber(arg) || isBn(arg) || isBigInt(arg);
+    return isNumber(arg) || isBn(arg) || isBigInt(arg);
 }
-
 /** @internal */
 function sortArray(a, b) {
-  // Vec, Tuple, Bytes etc.
-  let sortRes = 0;
-  const minLen = Math.min(a.length, b.length);
-  for (let i = 0; i < minLen; ++i) {
-    sortRes = sortAsc(a[i], b[i]);
-    if (sortRes !== 0) {
-      return sortRes;
+    // Vec, Tuple, Bytes etc.
+    let sortRes = 0;
+    const minLen = Math.min(a.length, b.length);
+    for (let i = 0; i < minLen; ++i) {
+        sortRes = sortAsc(a[i], b[i]);
+        if (sortRes !== 0) {
+            return sortRes;
+        }
     }
-  }
-  return a.length - b.length;
+    return a.length - b.length;
 }
-
 /**
 * Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
 * (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
 */
 export function sortAsc(a, b) {
-  if (isNumberLike(a) && isNumberLike(b)) {
-    return bnToBn(a).cmp(bnToBn(b));
-  } else if (a instanceof Map && b instanceof Map) {
-    return sortAsc(Array.from(a.values()), Array.from(b.values()));
-  } else if (isEnum(a) && isEnum(b)) {
-    return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
-  } else if (isArrayLike(a) && isArrayLike(b)) {
-    return sortArray(a, b);
-  } else if (isCodec(a) && isCodec(b)) {
-    // Text, Bool etc.
-    return sortAsc(a.toU8a(true), b.toU8a(true));
-  }
-  throw new Error(`Attempting to sort unrecognized values: ${stringify(a)} (typeof ${typeof a}) <-> ${stringify(b)} (typeof ${typeof b})`);
+    if (isNumberLike(a) && isNumberLike(b)) {
+        return bnToBn(a).cmp(bnToBn(b));
+    }
+    else if (a instanceof Map && b instanceof Map) {
+        return sortAsc(Array.from(a.values()), Array.from(b.values()));
+    }
+    else if (isEnum(a) && isEnum(b)) {
+        return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
+    }
+    else if (isArrayLike(a) && isArrayLike(b)) {
+        return sortArray(a, b);
+    }
+    else if (isCodec(a) && isCodec(b)) {
+        // Text, Bool etc.
+        return sortAsc(a.toU8a(true), b.toU8a(true));
+    }
+    throw new Error(`Attempting to sort unrecognized values: ${stringify(a)} (typeof ${typeof a}) <-> ${stringify(b)} (typeof ${typeof b})`);
 }
 export function sortSet(set) {
-  return new Set(Array.from(set).sort(sortAsc));
+    return new Set(Array.from(set).sort(sortAsc));
 }
 export function sortMap(map) {
-  return new Map(Array.from(map.entries()).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
+    return new Map(Array.from(map.entries()).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
 }

package/utils/typeToConstructor.d.ts

@@ -1,2 +1,2 @@
-import type { Codec, CodecClass, Registry } from '../types';
+import type { Codec, CodecClass, Registry } from '../types/index.js';
 export declare function typeToConstructor<T extends Codec = Codec>(registry: Registry, type: string | CodecClass<T>): CodecClass<T>;

package/utils/typeToConstructor.js

@@ -1,7 +1,6 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isString } from '@polkadot/util';
 export function typeToConstructor(registry, type) {
-  return isString(type) ? registry.createClassUnsafe(type) : type;
+    return (isString(type)
+        ? registry.createClassUnsafe(type)
+        : type);
 }

package/utils/typesToMap.d.ts

@@ -1,2 +1,2 @@
-import type { CodecClass, Registry } from '../types';
+import type { CodecClass, Registry } from '../types/index.js';
 export declare function typesToMap(registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string>;

package/utils/typesToMap.js

@@ -1,10 +1,7 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export function typesToMap(registry, [Types, keys]) {
-  const result = {};
-  for (let i = 0; i < keys.length; i++) {
-    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
-  }
-  return result;
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
+    }
+    return result;
 }

package/utils/util.js

@@ -1,7 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isFunction } from '@polkadot/util';
 export function hasEq(o) {
-  return isFunction(o.eq);
+    return isFunction(o.eq);
 }