@polkadot/types-create 9.5.1 → 9.6.1

package/cjs/util/getTypeDef.js

@@ -4,45 +4,37 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getTypeDef = getTypeDef;
-
 var _typesCodec = require("@polkadot/types-codec");
-
 var _util = require("@polkadot/util");
-
 var _types = require("../types");
-
 var _typeSplit = require("./typeSplit");
-
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
 function getTypeString(typeOrObj) {
   return (0, _util.isString)(typeOrObj) ? typeOrObj.toString() : JSON.stringify(typeOrObj);
 }
-
 function isRustEnum(details) {
   const values = Object.values(details);
-
   if (values.some(v => (0, _util.isNumber)(v))) {
     if (!values.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255)) {
       throw new Error('Invalid number-indexed enum definition');
     }
-
     return false;
   }
-
   return true;
-} // decode an enum of either of the following forms
+}
+
+// decode an enum of either of the following forms
 //  { _enum: ['A', 'B', 'C'] }
 //  { _enum: { A: AccountId, B: Balance, C: u32 } }
 //  { _enum: { A: 1, B: 2 } }
-
-
 function _decodeEnum(value, details, count, fallbackType) {
   value.info = _types.TypeDefInfo.Enum;
-  value.fallbackType = fallbackType; // not as pretty, but remain compatible with oo7 for both struct and Array types
+  value.fallbackType = fallbackType;
 
+  // not as pretty, but remain compatible with oo7 for both struct and Array types
   if (Array.isArray(details)) {
     value.sub = details.map((name, index) => ({
       index,
@@ -70,12 +62,11 @@ function _decodeEnum(value, details, count, fallbackType) {
       };
     });
   }
-
   return value;
-} // decode a set of the form
-//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
-
+}
 
+// decode a set of the form
+//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
 function _decodeSet(value, details, fallbackType) {
   value.info = _types.TypeDefInfo.Set;
   value.fallbackType = fallbackType;
@@ -93,35 +84,32 @@ function _decodeSet(value, details, fallbackType) {
     };
   });
   return value;
-} // decode a struct, set or enum
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
+}
 
+// decode a struct, set or enum
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeStruct(value, type, _, count) {
   const parsed = JSON.parse(type);
   const keys = Object.keys(parsed);
-
   if (keys.includes('_enum')) {
     return _decodeEnum(value, parsed._enum, count, parsed._fallback);
   } else if (keys.includes('_set')) {
     return _decodeSet(value, parsed._set, parsed._fallback);
   }
-
   value.alias = parsed._alias ? new Map(Object.entries(parsed._alias)) : undefined;
   value.fallbackType = parsed._fallback;
   value.sub = keys.filter(name => !KNOWN_INTERNALS.includes(name)).map(name => getTypeDef(getTypeString(parsed[name]), {
     name
   }, count));
   return value;
-} // decode a fixed vector, e.g. [u8;32]
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
+}
 
+// decode a fixed vector, e.g. [u8;32]
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeFixedVec(value, type, _, count) {
   const max = type.length - 1;
   let index = -1;
   let inner = 0;
-
   for (let i = 1; i < max && index === -1; i++) {
     switch (type[i]) {
       case ';':
@@ -129,16 +117,13 @@ function _decodeFixedVec(value, type, _, count) {
           if (inner === 0) {
             index = i;
           }
-
           break;
         }
-
       case '[':
       case '(':
       case '<':
         inner++;
         break;
-
       case ']':
       case ')':
       case '>':
@@ -146,75 +131,64 @@ function _decodeFixedVec(value, type, _, count) {
         break;
     }
   }
-
   if (index === -1) {
     throw new Error(`${type}: Unable to extract location of ';'`);
   }
-
   const vecType = type.substring(1, index);
   const [strLength, displayName] = type.substring(index + 1, max).split(';');
   const length = parseInt(strLength.trim(), 10);
-
   if (length > 2048) {
     throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
   }
-
   value.displayName = displayName;
   value.length = length;
   value.sub = getTypeDef(vecType, {}, count);
   return value;
-} // decode a tuple
-
+}
 
+// decode a tuple
 function _decodeTuple(value, _, subType, count) {
   value.sub = subType.length === 0 ? [] : (0, _typeSplit.typeSplit)(subType).map(inner => getTypeDef(inner, {}, count));
   return value;
-} // decode a Int/UInt<bitLength[, name]>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
+}
 
+// decode a Int/UInt<bitLength[, name]>
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeAnyInt(value, type, _, clazz) {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
   const length = parseInt(strLength.trim(), 10);
-
   if (length > 8192 || length % 8) {
     throw new Error(`${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
   }
-
   value.displayName = displayName;
   value.length = length;
   return value;
 }
-
 function _decodeInt(value, type, subType) {
   return _decodeAnyInt(value, type, subType, 'Int');
 }
-
 function _decodeUInt(value, type, subType) {
   return _decodeAnyInt(value, type, subType, 'UInt');
-} // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
+}
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeDoNotConstruct(value, type, _) {
   const NAME_LENGTH = 'DoNotConstruct'.length;
   value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
   return value;
 }
-
 function hasWrapper(type, _ref5) {
   let [start, end] = _ref5;
   return type.substring(0, start.length) === start && type.slice(-1 * end.length) === end;
 }
-
-const nestedExtraction = [['[', ']', _types.TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', _types.TypeDefInfo.Struct, _decodeStruct], ['(', ')', _types.TypeDefInfo.Tuple, _decodeTuple], // the inner for these are the same as tuple, multiple values
+const nestedExtraction = [['[', ']', _types.TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', _types.TypeDefInfo.Struct, _decodeStruct], ['(', ')', _types.TypeDefInfo.Tuple, _decodeTuple],
+// the inner for these are the same as tuple, multiple values
 ['BTreeMap<', '>', _types.TypeDefInfo.BTreeMap, _decodeTuple], ['HashMap<', '>', _types.TypeDefInfo.HashMap, _decodeTuple], ['Int<', '>', _types.TypeDefInfo.Int, _decodeInt], ['Result<', '>', _types.TypeDefInfo.Result, _decodeTuple], ['UInt<', '>', _types.TypeDefInfo.UInt, _decodeUInt], ['DoNotConstruct<', '>', _types.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]];
 const wrappedExtraction = [['BTreeSet<', '>', _types.TypeDefInfo.BTreeSet], ['Compact<', '>', _types.TypeDefInfo.Compact], ['Linkage<', '>', _types.TypeDefInfo.Linkage], ['Opaque<', '>', _types.TypeDefInfo.WrapperOpaque], ['Option<', '>', _types.TypeDefInfo.Option], ['Range<', '>', _types.TypeDefInfo.Range], ['RangeInclusive<', '>', _types.TypeDefInfo.RangeInclusive], ['Vec<', '>', _types.TypeDefInfo.Vec], ['WrapperKeepOpaque<', '>', _types.TypeDefInfo.WrapperKeepOpaque], ['WrapperOpaque<', '>', _types.TypeDefInfo.WrapperOpaque]];
-
 function extractSubType(type, _ref6) {
   let [start, end] = _ref6;
   return type.substring(start.length, type.length - end.length);
 }
-
 function getTypeDef(_type) {
   let {
     displayName,
@@ -229,24 +203,18 @@ function getTypeDef(_type) {
     name,
     type
   };
-
   if (++count > 64) {
     throw new Error('getTypeDef: Maximum nested limit reached');
   }
-
   const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
-
   if (nested) {
     value.info = nested[2];
     return nested[3](value, type, extractSubType(type, nested), count);
   }
-
   const wrapped = wrappedExtraction.find(wrapped => hasWrapper(type, wrapped));
-
   if (wrapped) {
     value.info = wrapped[2];
     value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
   }
-
   return value;
 }

package/cjs/util/index.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
 var _encodeTypes = require("./encodeTypes");
-
 Object.keys(_encodeTypes).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _encodeTypes[key]) return;
@@ -16,9 +14,7 @@ Object.keys(_encodeTypes).forEach(function (key) {
     }
   });
 });
-
 var _getTypeDef = require("./getTypeDef");
-
 Object.keys(_getTypeDef).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _getTypeDef[key]) return;
@@ -29,9 +25,7 @@ Object.keys(_getTypeDef).forEach(function (key) {
     }
   });
 });
-
 var _typeSplit = require("./typeSplit");
-
 Object.keys(_typeSplit).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _typeSplit[key]) return;
@@ -42,9 +36,7 @@ Object.keys(_typeSplit).forEach(function (key) {
     }
   });
 });
-
 var _xcm = require("./xcm");
-
 Object.keys(_xcm).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _xcm[key]) return;

package/cjs/util/typeSplit.js

@@ -4,20 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.typeSplit = typeSplit;
-
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // safely split a string on ', ' while taking care of any nested occurences
 function typeSplit(type) {
-  const result = []; // these are the depths of the various tokens: <, [, {, (
+  const result = [];
 
+  // these are the depths of the various tokens: <, [, {, (
   let c = 0;
   let f = 0;
   let s = 0;
-  let t = 0; // current start position
+  let t = 0;
 
+  // current start position
   let start = 0;
-
   for (let i = 0; i < type.length; i++) {
     switch (type[i]) {
       // if we are not nested, add the type
@@ -27,54 +28,49 @@ function typeSplit(type) {
             result.push(type.substring(start, i).trim());
             start = i + 1;
           }
-
           break;
         }
-      // adjust compact/vec (and friends) depth
 
+      // adjust compact/vec (and friends) depth
       case '<':
         c++;
         break;
-
       case '>':
         c--;
         break;
-      // adjust fixed vec depths
 
+      // adjust fixed vec depths
       case '[':
         f++;
         break;
-
       case ']':
         f--;
         break;
-      // adjust struct depth
 
+      // adjust struct depth
       case '{':
         s++;
         break;
-
       case '}':
         s--;
         break;
-      // adjust tuple depth
 
+      // adjust tuple depth
       case '(':
         t++;
         break;
-
       case ')':
         t--;
         break;
     }
-  } // ensure we have all the terminators taken care of
-
+  }
 
+  // ensure we have all the terminators taken care of
   if (c || f || s || t) {
     throw new Error(`Invalid definition (missing terminators) found in ${type}`);
-  } // the final leg of the journey
-
+  }
 
+  // the final leg of the journey
   result.push(type.substring(start, type.length).trim());
   return result;
 }

package/cjs/util/xcm.js

@@ -5,14 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.XCM_MAPPINGS = void 0;
 exports.mapXcmTypes = mapXcmTypes;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError', 'XcmOrder'];
 exports.XCM_MAPPINGS = XCM_MAPPINGS;
-
 function mapXcmTypes(version) {
   return XCM_MAPPINGS.reduce((all, key) => (0, _util.objectSpread)(all, {
     [key]: `${key}${version}`

package/create/class.js

@@ -1,54 +1,46 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@polkadot/types-codec';
 import { isNumber, stringify } from '@polkadot/util';
 import { TypeDefInfo } from "../types/index.js";
 import { getTypeDef } from "../util/getTypeDef.js";
-
 function getTypeDefType({
   lookupName,
   type
 }) {
   return lookupName || type;
 }
-
 function getSubDefArray(value) {
   if (!Array.isArray(value.sub)) {
     throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
   }
-
   return value.sub;
 }
-
 function getSubDef(value) {
   if (!value.sub || Array.isArray(value.sub)) {
     throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
   }
-
   return value.sub;
 }
-
 function getSubType(value) {
   return getTypeDefType(getSubDef(value));
-} // create a maps of type string CodecClasss from the input
-
+}
 
+// create a maps of type string CodecClasss from the input
 function getTypeClassMap(value) {
   const subs = getSubDefArray(value);
   const map = {};
-
   for (let i = 0; i < subs.length; i++) {
     map[subs[i].name] = getTypeDefType(subs[i]);
   }
-
   return map;
-} // create an array of type string CodecClasss from the input
-
+}
 
+// create an array of type string CodecClasss from the input
 function getTypeClassArray(value) {
   return getSubDefArray(value).map(getTypeDefType);
 }
-
 function createInt(Clazz, {
   displayName,
   length
@@ -56,19 +48,15 @@ function createInt(Clazz, {
   if (!isNumber(length)) {
     throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
   }
-
   return Clazz.with(length, displayName);
 }
-
 function createHashMap(Clazz, value) {
   const [keyType, valueType] = getTypeClassArray(value);
   return Clazz.with(keyType, valueType);
 }
-
 function createWithSub(Clazz, value) {
   return Clazz.with(getSubType(value));
 }
-
 const infoMapping = {
   [TypeDefInfo.BTreeMap]: (registry, value) => createHashMap(BTreeMap, value),
   [TypeDefInfo.BTreeSet]: (registry, value) => createWithSub(BTreeSet, value),
@@ -90,18 +78,18 @@ const infoMapping = {
   [TypeDefInfo.Int]: (registry, value) => createInt(Int, value),
   // We have circular deps between Linkage & Struct
   [TypeDefInfo.Linkage]: (registry, value) => {
-    const type = `Option<${getSubType(value)}>`; // eslint-disable-next-line sort-keys
-
+    const type = `Option<${getSubType(value)}>`;
+    // eslint-disable-next-line sort-keys
     const Clazz = Struct.with({
       previous: type,
       next: type
-    }); // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    });
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     Clazz.prototype.toRawType = function () {
       // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
       return `Linkage<${this.next.toRawType(true)}>`;
     };
-
     return Clazz;
   },
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -109,20 +97,22 @@ const infoMapping = {
   [TypeDefInfo.Option]: (registry, value) => {
     if (!value.sub || Array.isArray(value.sub)) {
       throw new Error('Expected type information for Option');
-    } // NOTE This is opt-in (unhandled), not by default
+    }
+
+    // NOTE This is opt-in (unhandled), not by default
     // if (value.sub.type === 'bool') {
     //   return OptionBool;
     // }
 
-
     return createWithSub(Option, value);
   },
   [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
   [TypeDefInfo.Range]: (registry, value) => createWithSub(Range, value),
   [TypeDefInfo.RangeInclusive]: (registry, value) => createWithSub(RangeInclusive, value),
   [TypeDefInfo.Result]: (registry, value) => {
-    const [Ok, Err] = getTypeClassArray(value); // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    const [Ok, Err] = getTypeClassArray(value);
 
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     return Result.with({
       Err,
       Ok
@@ -145,7 +135,6 @@ const infoMapping = {
     if (!sub || Array.isArray(sub)) {
       throw new Error('Expected type information for vector');
     }
-
     return sub.type === 'u8' ? Bytes : Vec.with(getTypeDefType(sub));
   },
   [TypeDefInfo.VecFixed]: (registry, {
@@ -156,7 +145,6 @@ const infoMapping = {
     if (!isNumber(length) || !sub || Array.isArray(sub)) {
       throw new Error('Expected length & type information for fixed vector');
     }
-
     return sub.type === 'u8' ? U8aFixed.with(length * 8, displayName) : VecFixed.with(getTypeDefType(sub), length);
   },
   [TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(WrapperKeepOpaque, value),
@@ -165,30 +153,31 @@ const infoMapping = {
 export function constructTypeClass(registry, typeDef) {
   try {
     const Type = infoMapping[typeDef.info](registry, typeDef);
-
     if (!Type) {
       throw new Error('No class created');
-    } // don't clobber any existing
-
+    }
 
+    // don't clobber any existing
     if (!Type.__fallbackType && typeDef.fallbackType) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore ...this is the only place we we actually assign this...
       Type.__fallbackType = typeDef.fallbackType;
     }
-
     return Type;
   } catch (error) {
     throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
   }
-} // Returns the type Class for construction
+}
 
+// Returns the type Class for construction
 export function getTypeClass(registry, typeDef) {
   return registry.getUnsafe(typeDef.type, false, typeDef);
 }
 export function createClassUnsafe(registry, type) {
-  return (// just retrieve via name, no creation via typeDef
-    registry.getUnsafe(type) || // we don't have an existing type, create the class via typeDef
+  return (
+    // just retrieve via name, no creation via typeDef
+    registry.getUnsafe(type) ||
+    // we don't have an existing type, create the class via typeDef
     getTypeClass(registry, registry.isLookupType(type) ? registry.lookup.getTypeDef(type) : getTypeDef(type))
   );
 }

package/create/index.js

@@ -1,4 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 export * from "./class.js";
 export * from "./type.js";

package/create/type.js

@@ -1,33 +1,36 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { Option } from '@polkadot/types-codec';
 import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { createClassUnsafe } from "./class.js"; // With isPedantic, actually check that the encoding matches that supplied. This
-// is much slower, but verifies that we have the correct types defined
+import { createClassUnsafe } from "./class.js";
 
+// With isPedantic, actually check that the encoding matches that supplied. This
+// is much slower, but verifies that we have the correct types defined
 function checkInstance(created, matcher) {
   const u8a = created.toU8a();
   const rawType = created.toRawType();
-  const isOk = // full match, all ok
-  u8aEq(u8a, matcher) || // on a length-prefixed type, just check the actual length
-  ['Bytes', 'Text', 'Type'].includes(rawType) && matcher.length === created.length || // when the created is empty and matcher is also empty, let it slide...
+  const isOk =
+  // full match, all ok
+  u8aEq(u8a, matcher) ||
+  // on a length-prefixed type, just check the actual length
+  ['Bytes', 'Text', 'Type'].includes(rawType) && matcher.length === created.length ||
+  // when the created is empty and matcher is also empty, let it slide...
   created.isEmpty && matcher.every(v => !v);
-
   if (!isOk) {
     throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
   }
 }
-
 function checkPedantic(created, [value]) {
   if (isU8a(value)) {
     checkInstance(created, value);
   } else if (isHex(value)) {
     checkInstance(created, u8aToU8a(value));
   }
-} // Initializes a type with a value. This also checks for fallbacks and in the cases
-// where isPedantic is specified (storage decoding), also check the format/structure
-
+}
 
+// Initializes a type with a value. This also checks for fallbacks and in the cases
+// where isPedantic is specified (storage decoding), also check the format/structure
 function initType(registry, Type, params = [], {
   blockHash,
   isOptional,
@@ -35,35 +38,31 @@ function initType(registry, Type, params = [], {
 } = {}) {
   const created = new (isOptional ? Option.with(Type) : Type)(registry, ...params);
   isPedantic && checkPedantic(created, params);
-
   if (blockHash) {
     created.createdAtHash = createTypeUnsafe(registry, 'Hash', [blockHash]);
   }
-
   return created;
-} // An unsafe version of the `createType` below. It's unsafe because the `type`
+}
+
+// An unsafe version of the `createType` below. It's unsafe because the `type`
 // argument here can be any string, which, when it cannot parse, will yield a
 // runtime error.
-
-
 export function createTypeUnsafe(registry, type, params = [], options = {}) {
   let Clazz = null;
   let firstError = null;
-
   try {
     Clazz = createClassUnsafe(registry, type);
     return initType(registry, Clazz, params, options);
   } catch (error) {
     firstError = new Error(`createType(${type}):: ${error.message}`);
   }
-
   if (Clazz && Clazz.__fallbackType) {
     try {
       Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
       return initType(registry, Clazz, params, options);
-    } catch {// swallow, we will throw the first error again
+    } catch {
+      // swallow, we will throw the first error again
     }
   }
-
   throw firstError;
 }

package/detectOther.js

@@ -1,4 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { packageInfo as codecInfo } from '@polkadot/types-codec/packageInfo';
 export default [codecInfo];

package/detectPackage.js

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 // Do not edit, auto-generated by @polkadot/dev
+
 import { detectPackage } from '@polkadot/util';
 import others from "./detectOther.js";
 import { packageInfo } from "./packageInfo.js";

package/index.js

@@ -1,4 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import "./detectPackage.js";
 export * from "./bundle.js";