@polkadot/types-create 6.12.2-3

package/bundle.cjs

@@ -0,0 +1,53 @@
+"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.cjs");
+
+var _types = require("./types.cjs");
+
+var _index = require("./create/index.cjs");
+
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index[key];
+    }
+  });
+});
+
+var _index2 = require("./util/index.cjs");
+
+Object.keys(_index2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index2[key];
+    }
+  });
+});

package/bundle.d.ts

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

package/bundle.js

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

package/create/class.cjs

@@ -0,0 +1,185 @@
+"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.cjs");
+
+var _getTypeDef = require("../util/getTypeDef.cjs");
+
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+function getTypeDefType(_ref) {
+  let {
+    lookupName,
+    type
+  } = _ref;
+  return lookupName || type;
+}
+
+function getSubDefArray(value) {
+  (0, _util.assert)(value.sub && Array.isArray(value.sub), () => `Expected subtype as TypeDef[] in ${(0, _util.stringify)(value)}`);
+  return value.sub;
+}
+
+function getSubDef(value) {
+  (0, _util.assert)(value.sub && !Array.isArray(value.sub), () => `Expected subtype as TypeDef in ${(0, _util.stringify)(value)}`);
+  return value.sub;
+}
+
+function getSubType(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;
+} // create an array of type string CodecClasss from the input
+
+
+function getTypeClassArray(value) {
+  return getSubDefArray(value).map(getTypeDefType);
+}
+
+function createInt(Clazz, _ref2) {
+  let {
+    displayName,
+    length
+  } = _ref2;
+  (0, _util.assert)((0, _util.isNumber)(length), () => `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 = {
+  [_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) => createWithSub(_typesCodec.Option, value),
+  [_types.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+  [_types.TypeDefInfo.Range]: (registry, value) => (value.type.includes('RangeInclusive') ? _typesCodec.RangeInclusive : _typesCodec.Range).with(getSubType(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;
+    (0, _util.assert)(sub && !Array.isArray(sub), '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;
+    (0, _util.assert)(sub && (0, _util.isNumber)(length) && !Array.isArray(sub), '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.WrapperOpaque]: (registry, value) => createWithSub(_typesCodec.WrapperOpaque, value)
+};
+
+function constructTypeClass(registry, typeDef) {
+  try {
+    const Type = infoMapping[typeDef.info](registry, typeDef);
+    (0, _util.assert)(Type, '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;
+  } catch (error) {
+    throw new Error(`Unable to construct class from ${(0, _util.stringify)(typeDef)}: ${error.message}`);
+  }
+} // Returns the type Class for construction
+
+
+function getTypeClass(registry, typeDef) {
+  return registry.getUnsafe(typeDef.type, false, typeDef);
+}
+
+function createClassUnsafe(registry, type) {
+  return getTypeClass(registry, registry.isLookupType(type) ? registry.lookup.getTypeDef(type) : (0, _getTypeDef.getTypeDef)(type));
+}

package/create/class.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass, CodecRegistry } from '@polkadot/types-codec/types';
+import type { TypeDef } from '../types';
+export declare function constructTypeClass<T extends Codec = Codec>(registry: CodecRegistry, typeDef: TypeDef): CodecClass<T>;
+export declare function getTypeClass<T extends Codec = Codec>(registry: CodecRegistry, typeDef: TypeDef): CodecClass<T>;
+export declare function createClassUnsafe<T extends Codec = Codec, K extends string = string>(registry: CodecRegistry, type: K): CodecClass<T>;

package/create/class.js

@@ -0,0 +1,160 @@
+// Copyright 2017-2021 @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, WrapperOpaque } from '@polkadot/types-codec';
+import { assert, isNumber, stringify } from '@polkadot/util';
+import { TypeDefInfo } from "../types.js";
+import { getTypeDef } from "../util/getTypeDef.js";
+
+function getTypeDefType({
+  lookupName,
+  type
+}) {
+  return lookupName || type;
+}
+
+function getSubDefArray(value) {
+  assert(value.sub && Array.isArray(value.sub), () => `Expected subtype as TypeDef[] in ${stringify(value)}`);
+  return value.sub;
+}
+
+function getSubDef(value) {
+  assert(value.sub && !Array.isArray(value.sub), () => `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
+
+
+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
+
+
+function getTypeClassArray(value) {
+  return getSubDefArray(value).map(getTypeDefType);
+}
+
+function createInt(Clazz, {
+  displayName,
+  length
+}) {
+  assert(isNumber(length), () => `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),
+  [TypeDefInfo.Compact]: (registry, value) => createWithSub(Compact, value),
+  [TypeDefInfo.DoNotConstruct]: (registry, value) => DoNotConstruct.with(value.displayName || value.type),
+  [TypeDefInfo.Enum]: (registry, value) => {
+    const subs = getSubDefArray(value);
+    return Enum.with(subs.every(({
+      type
+    }) => type === 'Null') ? subs.reduce((out, {
+      index,
+      name
+    }, count) => {
+      out[name] = index || count;
+      return out;
+    }, {}) : getTypeClassMap(value));
+  },
+  [TypeDefInfo.HashMap]: (registry, value) => createHashMap(HashMap, value),
+  [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 Clazz = 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
+  [TypeDefInfo.Null]: (registry, _) => Null,
+  [TypeDefInfo.Option]: (registry, value) => createWithSub(Option, value),
+  [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+  [TypeDefInfo.Range]: (registry, value) => (value.type.includes('RangeInclusive') ? RangeInclusive : Range).with(getSubType(value)),
+  [TypeDefInfo.Result]: (registry, value) => {
+    const [Ok, Err] = getTypeClassArray(value); // eslint-disable-next-line @typescript-eslint/no-use-before-define
+
+    return Result.with({
+      Err,
+      Ok
+    });
+  },
+  [TypeDefInfo.Set]: (registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, {
+    index,
+    name
+  }) => {
+    result[name] = index;
+    return result;
+  }, {}), value.length),
+  [TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
+  [TypeDefInfo.Struct]: (registry, value) => Struct.with(getTypeClassMap(value), value.alias),
+  [TypeDefInfo.Tuple]: (registry, value) => Tuple.with(getTypeClassArray(value)),
+  [TypeDefInfo.UInt]: (registry, value) => createInt(UInt, value),
+  [TypeDefInfo.Vec]: (registry, {
+    sub
+  }) => {
+    assert(sub && !Array.isArray(sub), 'Expected type information for vector');
+    return sub.type === 'u8' ? Bytes : Vec.with(getTypeDefType(sub));
+  },
+  [TypeDefInfo.VecFixed]: (registry, {
+    displayName,
+    length,
+    sub
+  }) => {
+    assert(sub && isNumber(length) && !Array.isArray(sub), 'Expected length & type information for fixed vector');
+    return sub.type === 'u8' ? U8aFixed.with(length * 8, displayName) : VecFixed.with(getTypeDefType(sub), length);
+  },
+  [TypeDefInfo.WrapperOpaque]: (registry, value) => createWithSub(WrapperOpaque, value)
+};
+export function constructTypeClass(registry, typeDef) {
+  try {
+    const Type = infoMapping[typeDef.info](registry, typeDef);
+    assert(Type, '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;
+  } catch (error) {
+    throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
+  }
+} // Returns the type Class for construction
+
+export function getTypeClass(registry, typeDef) {
+  return registry.getUnsafe(typeDef.type, false, typeDef);
+}
+export function createClassUnsafe(registry, type) {
+  return getTypeClass(registry, registry.isLookupType(type) ? registry.lookup.getTypeDef(type) : getTypeDef(type));
+}

package/create/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _class = require("./class.cjs");
+
+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.cjs");
+
+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];
+    }
+  });
+});

package/create/index.d.ts

@@ -0,0 +1,2 @@
+export * from './class';
+export * from './type';

package/create/index.js

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

package/create/type.cjs

@@ -0,0 +1,85 @@
+"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.cjs");
+
+// Copyright 2017-2021 @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
+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);
+  (0, _util.assert)(isOk, () => `${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)`);
+}
+
+function checkPedantic(created, _ref) {
+  let [value] = _ref;
+  let isPedantic = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+  if (isPedantic) {
+    if ((0, _util.isU8a)(value)) {
+      checkInstance(created, value);
+    } else if ((0, _util.isHex)(value)) {
+      checkInstance(created, (0, _util.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,
+    isOptional,
+    isPedantic
+  } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const created = new (isOptional ? _typesCodec.Option.with(Type) : Type)(registry, ...params);
+  checkPedantic(created, params, isPedantic);
+
+  if (blockHash) {
+    created.createdAtHash = createTypeUnsafe(registry, 'Hash', [blockHash]);
+  }
+
+  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) {
+    try {
+      Clazz = (0, _class.createClassUnsafe)(registry, Clazz.__fallbackType);
+      return initType(registry, Clazz, params, options);
+    } catch {// swallow, we will throw the first error again
+    }
+  }
+
+  throw firstError;
+}

package/create/type.d.ts

@@ -0,0 +1,3 @@
+import type { Codec, CodecRegistry } from '@polkadot/types-codec/types';
+import type { CreateOptions } from '../types';
+export declare function createTypeUnsafe<T extends Codec = Codec, K extends string = string>(registry: CodecRegistry, type: K, params?: unknown[], options?: CreateOptions): T;

package/create/type.js

@@ -0,0 +1,68 @@
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Option } from '@polkadot/types-codec';
+import { assert, 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
+
+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...
+  created.isEmpty && matcher.every(v => !v);
+  assert(isOk, () => `${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], isPedantic = false) {
+  if (isPedantic) {
+    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
+
+
+function initType(registry, Type, params = [], {
+  blockHash,
+  isOptional,
+  isPedantic
+} = {}) {
+  const created = new (isOptional ? Option.with(Type) : Type)(registry, ...params);
+  checkPedantic(created, params, isPedantic);
+
+  if (blockHash) {
+    created.createdAtHash = createTypeUnsafe(registry, 'Hash', [blockHash]);
+  }
+
+  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.
+
+
+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
+    }
+  }
+
+  throw firstError;
+}

package/detectPackage.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+var _typesCodec = require("@polkadot/types-codec");
+
+var _util = require("@polkadot/util");
+
+var _packageInfo = require("./packageInfo.cjs");
+
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+(0, _util.detectPackage)(_packageInfo.packageInfo, typeof __dirname !== 'undefined' && __dirname, [_typesCodec.packageInfo]);

package/detectPackage.d.ts

@@ -0,0 +1 @@
+export {};

package/detectPackage.js

@@ -0,0 +1,6 @@
+// Copyright 2017-2021 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { packageInfo as codecInfo } from '@polkadot/types-codec';
+import { detectPackage } from '@polkadot/util';
+import { packageInfo } from "./packageInfo.js";
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [codecInfo]);

package/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("./detectPackage.cjs");
+
+var _bundle = require("./bundle.cjs");
+
+Object.keys(_bundle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bundle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bundle[key];
+    }
+  });
+});

package/index.d.ts

@@ -0,0 +1,2 @@
+import './detectPackage';
+export * from './bundle';

package/index.js

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