@polkadot/types-create 9.14.2 → 10.1.1

package/bundle.d.ts

@@ -1,4 +1,4 @@
-export { packageInfo } from './packageInfo';
-export { TypeDefInfo } from './types';
-export * from './create';
-export * from './util';
+export { packageInfo } from './packageInfo.js';
+export { TypeDefInfo } from './types/index.js';
+export * from './create/index.js';
+export * from './util/index.js';

package/bundle.js

@@ -1,7 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { packageInfo } from "./packageInfo.js";
-export { TypeDefInfo } from "./types/index.js";
-export * from "./create/index.js";
-export * from "./util/index.js";
+export { packageInfo } from './packageInfo.js';
+export { TypeDefInfo } from './types/index.js';
+export * from './create/index.js';
+export * from './util/index.js';

package/cjs/bundle.js

@@ -1,47 +1,10 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  packageInfo: true,
-  TypeDefInfo: true
-};
-Object.defineProperty(exports, "TypeDefInfo", {
-  enumerable: true,
-  get: function () {
-    return _types.TypeDefInfo;
-  }
-});
-Object.defineProperty(exports, "packageInfo", {
-  enumerable: true,
-  get: function () {
-    return _packageInfo.packageInfo;
-  }
-});
-var _packageInfo = require("./packageInfo");
-var _types = require("./types");
-var _create = require("./create");
-Object.keys(_create).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _create[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _create[key];
-    }
-  });
-});
-var _util = require("./util");
-Object.keys(_util).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _util[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _util[key];
-    }
-  });
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeDefInfo = exports.packageInfo = void 0;
+const tslib_1 = require("tslib");
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+var index_js_1 = require("./types/index.js");
+Object.defineProperty(exports, "TypeDefInfo", { enumerable: true, get: function () { return index_js_1.TypeDefInfo; } });
+tslib_1.__exportStar(require("./create/index.js"), exports);
+tslib_1.__exportStar(require("./util/index.js"), exports);

package/cjs/create/class.js

@@ -1,200 +1,157 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.constructTypeClass = constructTypeClass;
-exports.createClassUnsafe = createClassUnsafe;
-exports.getTypeClass = getTypeClass;
-var _typesCodec = require("@polkadot/types-codec");
-var _util = require("@polkadot/util");
-var _types = require("../types");
-var _getTypeDef = require("../util/getTypeDef");
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-function getTypeDefType(_ref) {
-  let {
-    lookupName,
-    type
-  } = _ref;
-  return lookupName || type;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClassUnsafe = exports.getTypeClass = exports.constructTypeClass = void 0;
+const types_codec_1 = require("@polkadot/types-codec");
+const util_1 = require("@polkadot/util");
+const index_js_1 = require("../types/index.js");
+const getTypeDef_js_1 = require("../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 ${(0, _util.stringify)(value)}`);
-  }
-  return value.sub;
+    if (!Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef[] in ${(0, util_1.stringify)(value)}`);
+    }
+    return value.sub;
 }
 function getSubDef(value) {
-  if (!value.sub || Array.isArray(value.sub)) {
-    throw new Error(`Expected subtype as TypeDef in ${(0, _util.stringify)(value)}`);
-  }
-  return value.sub;
+    if (!value.sub || Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef in ${(0, util_1.stringify)(value)}`);
+    }
+    return value.sub;
 }
 function getSubType(value) {
-  return getTypeDefType(getSubDef(value));
+    return getTypeDefType(getSubDef(value));
 }
-
-// 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;
+    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
 function getTypeClassArray(value) {
-  return getSubDefArray(value).map(getTypeDefType);
+    return getSubDefArray(value).map(getTypeDefType);
 }
-function createInt(Clazz, _ref2) {
-  let {
-    displayName,
-    length
-  } = _ref2;
-  if (!(0, _util.isNumber)(length)) {
-    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
-  }
-  return Clazz.with(length, displayName);
+function createInt(Clazz, { displayName, length }) {
+    if (!(0, util_1.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);
+    const [keyType, valueType] = getTypeClassArray(value);
+    return Clazz.with(keyType, valueType);
 }
 function createWithSub(Clazz, value) {
-  return Clazz.with(getSubType(value));
+    return Clazz.with(getSubType(value));
 }
 const infoMapping = {
-  [_types.TypeDefInfo.BTreeMap]: (registry, value) => createHashMap(_typesCodec.BTreeMap, value),
-  [_types.TypeDefInfo.BTreeSet]: (registry, value) => createWithSub(_typesCodec.BTreeSet, value),
-  [_types.TypeDefInfo.Compact]: (registry, value) => createWithSub(_typesCodec.Compact, value),
-  [_types.TypeDefInfo.DoNotConstruct]: (registry, value) => _typesCodec.DoNotConstruct.with(value.displayName || value.type),
-  [_types.TypeDefInfo.Enum]: (registry, value) => {
-    const subs = getSubDefArray(value);
-    return _typesCodec.Enum.with(subs.every(_ref3 => {
-      let {
-        type
-      } = _ref3;
-      return type === 'Null';
-    }) ? subs.reduce((out, _ref4, count) => {
-      let {
-        index,
-        name
-      } = _ref4;
-      out[name] = index || count;
-      return out;
-    }, {}) : getTypeClassMap(value));
-  },
-  [_types.TypeDefInfo.HashMap]: (registry, value) => createHashMap(_typesCodec.HashMap, value),
-  [_types.TypeDefInfo.Int]: (registry, value) => createInt(_typesCodec.Int, value),
-  // We have circular deps between Linkage & Struct
-  [_types.TypeDefInfo.Linkage]: (registry, value) => {
-    const type = `Option<${getSubType(value)}>`;
-    // eslint-disable-next-line sort-keys
-    const Clazz = _typesCodec.Struct.with({
-      previous: type,
-      next: type
-    });
-
-    // 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
-  [_types.TypeDefInfo.Null]: (registry, _) => _typesCodec.Null,
-  [_types.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
-    // if (value.sub.type === 'bool') {
-    //   return OptionBool;
-    // }
-
-    return createWithSub(_typesCodec.Option, value);
-  },
-  [_types.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
-  [_types.TypeDefInfo.Range]: (registry, value) => createWithSub(_typesCodec.Range, value),
-  [_types.TypeDefInfo.RangeInclusive]: (registry, value) => createWithSub(_typesCodec.RangeInclusive, value),
-  [_types.TypeDefInfo.Result]: (registry, value) => {
-    const [Ok, Err] = getTypeClassArray(value);
-
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return _typesCodec.Result.with({
-      Err,
-      Ok
-    });
-  },
-  [_types.TypeDefInfo.Set]: (registry, value) => _typesCodec.CodecSet.with(getSubDefArray(value).reduce((result, _ref5) => {
-    let {
-      index,
-      name
-    } = _ref5;
-    result[name] = index;
-    return result;
-  }, {}), value.length),
-  [_types.TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
-  [_types.TypeDefInfo.Struct]: (registry, value) => _typesCodec.Struct.with(getTypeClassMap(value), value.alias),
-  [_types.TypeDefInfo.Tuple]: (registry, value) => _typesCodec.Tuple.with(getTypeClassArray(value)),
-  [_types.TypeDefInfo.UInt]: (registry, value) => createInt(_typesCodec.UInt, value),
-  [_types.TypeDefInfo.Vec]: (registry, _ref6) => {
-    let {
-      sub
-    } = _ref6;
-    if (!sub || Array.isArray(sub)) {
-      throw new Error('Expected type information for vector');
-    }
-    return sub.type === 'u8' ? _typesCodec.Bytes : _typesCodec.Vec.with(getTypeDefType(sub));
-  },
-  [_types.TypeDefInfo.VecFixed]: (registry, _ref7) => {
-    let {
-      displayName,
-      length,
-      sub
-    } = _ref7;
-    if (!(0, _util.isNumber)(length) || !sub || Array.isArray(sub)) {
-      throw new Error('Expected length & type information for fixed vector');
-    }
-    return sub.type === 'u8' ? _typesCodec.U8aFixed.with(length * 8, displayName) : _typesCodec.VecFixed.with(getTypeDefType(sub), length);
-  },
-  [_types.TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(_typesCodec.WrapperKeepOpaque, value),
-  [_types.TypeDefInfo.WrapperOpaque]: (registry, value) => createWithSub(_typesCodec.WrapperOpaque, value)
+    [index_js_1.TypeDefInfo.BTreeMap]: (registry, value) => createHashMap(types_codec_1.BTreeMap, value),
+    [index_js_1.TypeDefInfo.BTreeSet]: (registry, value) => createWithSub(types_codec_1.BTreeSet, value),
+    [index_js_1.TypeDefInfo.Compact]: (registry, value) => createWithSub(types_codec_1.Compact, value),
+    [index_js_1.TypeDefInfo.DoNotConstruct]: (registry, value) => types_codec_1.DoNotConstruct.with(value.displayName || value.type),
+    [index_js_1.TypeDefInfo.Enum]: (registry, value) => {
+        const subs = getSubDefArray(value);
+        return types_codec_1.Enum.with(subs.every(({ type }) => type === 'Null')
+            ? subs.reduce((out, { index, name }, count) => {
+                out[name] = index || count;
+                return out;
+            }, {})
+            : getTypeClassMap(value));
+    },
+    [index_js_1.TypeDefInfo.HashMap]: (registry, value) => createHashMap(types_codec_1.HashMap, value),
+    [index_js_1.TypeDefInfo.Int]: (registry, value) => createInt(types_codec_1.Int, value),
+    // We have circular deps between Linkage & Struct
+    [index_js_1.TypeDefInfo.Linkage]: (registry, value) => {
+        const type = `Option<${getSubType(value)}>`;
+        // eslint-disable-next-line sort-keys
+        const Clazz = types_codec_1.Struct.with({ previous: type, next: type });
+        // 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
+    [index_js_1.TypeDefInfo.Null]: (registry, _) => types_codec_1.Null,
+    [index_js_1.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
+        // if (value.sub.type === 'bool') {
+        //   return OptionBool;
+        // }
+        return createWithSub(types_codec_1.Option, value);
+    },
+    [index_js_1.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+    [index_js_1.TypeDefInfo.Range]: (registry, value) => createWithSub(types_codec_1.Range, value),
+    [index_js_1.TypeDefInfo.RangeInclusive]: (registry, value) => createWithSub(types_codec_1.RangeInclusive, value),
+    [index_js_1.TypeDefInfo.Result]: (registry, value) => {
+        const [Ok, Err] = getTypeClassArray(value);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return types_codec_1.Result.with({ Err, Ok });
+    },
+    [index_js_1.TypeDefInfo.Set]: (registry, value) => types_codec_1.CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
+        result[name] = index;
+        return result;
+    }, {}), value.length),
+    [index_js_1.TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
+    [index_js_1.TypeDefInfo.Struct]: (registry, value) => types_codec_1.Struct.with(getTypeClassMap(value), value.alias),
+    [index_js_1.TypeDefInfo.Tuple]: (registry, value) => types_codec_1.Tuple.with(getTypeClassArray(value)),
+    [index_js_1.TypeDefInfo.UInt]: (registry, value) => createInt(types_codec_1.UInt, value),
+    [index_js_1.TypeDefInfo.Vec]: (registry, { sub }) => {
+        if (!sub || Array.isArray(sub)) {
+            throw new Error('Expected type information for vector');
+        }
+        return (sub.type === 'u8'
+            ? types_codec_1.Bytes
+            : types_codec_1.Vec.with(getTypeDefType(sub)));
+    },
+    [index_js_1.TypeDefInfo.VecFixed]: (registry, { displayName, length, sub }) => {
+        if (!(0, util_1.isNumber)(length) || !sub || Array.isArray(sub)) {
+            throw new Error('Expected length & type information for fixed vector');
+        }
+        return (sub.type === 'u8'
+            ? types_codec_1.U8aFixed.with((length * 8), displayName)
+            : types_codec_1.VecFixed.with(getTypeDefType(sub), length));
+    },
+    [index_js_1.TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(types_codec_1.WrapperKeepOpaque, value),
+    [index_js_1.TypeDefInfo.WrapperOpaque]: (registry, value) => createWithSub(types_codec_1.WrapperOpaque, value)
 };
 function constructTypeClass(registry, typeDef) {
-  try {
-    const Type = infoMapping[typeDef.info](registry, typeDef);
-    if (!Type) {
-      throw new Error('No class created');
+    try {
+        const Type = infoMapping[typeDef.info](registry, typeDef);
+        if (!Type) {
+            throw new Error('No class created');
+        }
+        // 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;
     }
-
-    // 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;
+    catch (error) {
+        throw new Error(`Unable to construct class from ${(0, util_1.stringify)(typeDef)}: ${error.message}`);
     }
-    return Type;
-  } catch (error) {
-    throw new Error(`Unable to construct class from ${(0, _util.stringify)(typeDef)}: ${error.message}`);
-  }
 }
-
-// Returns the type Class for construction
+exports.constructTypeClass = constructTypeClass;
 function getTypeClass(registry, typeDef) {
-  return registry.getUnsafe(typeDef.type, false, typeDef);
+    return registry.getUnsafe(typeDef.type, false, typeDef);
 }
+exports.getTypeClass = getTypeClass;
 function createClassUnsafe(registry, type) {
-  return (
+    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) : (0, _getTypeDef.getTypeDef)(type))
-  );
-}
+        // we don't have an existing type, create the class via typeDef
+        getTypeClass(registry, registry.isLookupType(type)
+            ? registry.lookup.getTypeDef(type)
+            : (0, getTypeDef_js_1.getTypeDef)(type)));
+}
+exports.createClassUnsafe = createClassUnsafe;

package/cjs/create/index.js

@@ -1,27 +1,5 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _class = require("./class");
-Object.keys(_class).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _class[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _class[key];
-    }
-  });
-});
-var _type = require("./type");
-Object.keys(_type).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _type[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _type[key];
-    }
-  });
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./class.js"), exports);
+tslib_1.__exportStar(require("./type.js"), exports);

package/cjs/create/type.js

@@ -1,82 +1,67 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createTypeUnsafe = createTypeUnsafe;
-var _typesCodec = require("@polkadot/types-codec");
-var _util = require("@polkadot/util");
-var _class = require("./class");
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// With isPedantic, actually check that the encoding matches that supplied. This
-// is much slower, but verifies that we have the correct types defined
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeUnsafe = void 0;
+const types_codec_1 = require("@polkadot/types-codec");
+const util_1 = require("@polkadot/util");
+const class_js_1 = require("./class.js");
 function checkInstance(created, matcher) {
-  const u8a = created.toU8a();
-  const rawType = created.toRawType();
-  const isOk =
-  // full match, all ok
-  (0, _util.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 ${(0, _util.u8aToHex)(matcher, 512)} (${matcher.length} bytes), created ${(0, _util.u8aToHex)(u8a, 512)} (${u8a.length} bytes)`);
-  }
+    const u8a = created.toU8a();
+    const rawType = created.toRawType();
+    const isOk = (
+    // full match, all ok
+    (0, util_1.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 ${(0, util_1.u8aToHex)(matcher, 512)} (${matcher.length} bytes), created ${(0, util_1.u8aToHex)(u8a, 512)} (${u8a.length} bytes)`);
+    }
 }
-function checkPedantic(created, _ref) {
-  let [value] = _ref;
-  if ((0, _util.isU8a)(value)) {
-    checkInstance(created, value);
-  } else if ((0, _util.isHex)(value)) {
-    checkInstance(created, (0, _util.u8aToU8a)(value));
-  }
+function checkPedantic(created, [value]) {
+    if ((0, util_1.isU8a)(value)) {
+        checkInstance(created, value);
+    }
+    else if ((0, util_1.isHex)(value)) {
+        checkInstance(created, (0, util_1.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
-function initType(registry, Type) {
-  let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  let {
-    blockHash,
-    isFallback,
-    isOptional,
-    isPedantic
-  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  const created = new (isOptional ? _typesCodec.Option.with(Type) : Type)(registry, ...params);
-  isPedantic && checkPedantic(created, params);
-  if (blockHash) {
-    created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
-  }
-  if (isFallback) {
-    created.isStorageFallback = true;
-  }
-  return created;
+function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
+    const created = new (isOptional
+        ? types_codec_1.Option.with(Type)
+        : Type)(registry, ...params);
+    isPedantic && checkPedantic(created, params);
+    if (blockHash) {
+        created.createdAtHash = createTypeUnsafe(registry, 'BlockHash', [blockHash]);
+    }
+    if (isFallback) {
+        created.isStorageFallback = true;
+    }
+    return created;
 }
-
-// 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.
-function createTypeUnsafe(registry, type) {
-  let params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  let Clazz = null;
-  let firstError = null;
-  try {
-    Clazz = (0, _class.createClassUnsafe)(registry, type);
-    return initType(registry, Clazz, params, options);
-  } catch (error) {
-    firstError = new Error(`createType(${type}):: ${error.message}`);
-  }
-  if (Clazz && Clazz.__fallbackType) {
+function createTypeUnsafe(registry, type, params = [], options = {}) {
+    let Clazz = null;
+    let firstError = null;
     try {
-      Clazz = (0, _class.createClassUnsafe)(registry, Clazz.__fallbackType);
-      return initType(registry, Clazz, params, options);
-    } catch {
-      // swallow, we will throw the first error again
+        Clazz = (0, class_js_1.createClassUnsafe)(registry, type);
+        return initType(registry, Clazz, params, options);
+    }
+    catch (error) {
+        firstError = new Error(`createType(${type}):: ${error.message}`);
     }
-  }
-  throw firstError;
-}
+    if (Clazz && Clazz.__fallbackType) {
+        try {
+            Clazz = (0, class_js_1.createClassUnsafe)(registry, Clazz.__fallbackType);
+            return initType(registry, Clazz, params, options);
+        }
+        catch {
+            // swallow, we will throw the first error again
+        }
+    }
+    throw firstError;
+}
+exports.createTypeUnsafe = createTypeUnsafe;

package/cjs/detectOther.js

@@ -1,11 +1,4 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _packageInfo = require("@polkadot/types-codec/cjs/packageInfo");
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-var _default = [_packageInfo.packageInfo];
-exports.default = _default;
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@polkadot/types-codec/cjs/packageInfo");
+exports.default = [packageInfo_1.packageInfo];

package/cjs/detectPackage.js

@@ -1,12 +1,7 @@
 "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-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Do not edit, auto-generated by @polkadot/dev
-
-(0, _util.detectPackage)(_packageInfo.packageInfo, null, _detectOther.default);
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const util_1 = require("@polkadot/util");
+const detectOther_js_1 = tslib_1.__importDefault(require("./detectOther.js"));
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, detectOther_js_1.default);