@pezkuwi/types-create 16.5.20 → 16.5.21

package/build/cjs/util/encodeTypes.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paramsNotation = paramsNotation;
-exports.encodeTypeDef = encodeTypeDef;
-exports.withTypeString = withTypeString;
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../types/index.js");
-const stringIdentity = (value) => value.toString();
-const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
-function paramsNotation(outer, inner, transform = stringIdentity) {
-    return `${outer}${inner
-        ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
-        : ''}`;
-}
-function encodeWithParams(registry, typeDef, outer) {
-    const { info, sub } = typeDef;
-    switch (info) {
-        case index_js_1.TypeDefInfo.BTreeMap:
-        case index_js_1.TypeDefInfo.BTreeSet:
-        case index_js_1.TypeDefInfo.Compact:
-        case index_js_1.TypeDefInfo.HashMap:
-        case index_js_1.TypeDefInfo.Linkage:
-        case index_js_1.TypeDefInfo.Option:
-        case index_js_1.TypeDefInfo.Range:
-        case index_js_1.TypeDefInfo.RangeInclusive:
-        case index_js_1.TypeDefInfo.Result:
-        case index_js_1.TypeDefInfo.Vec:
-        case index_js_1.TypeDefInfo.WrapperKeepOpaque:
-        case index_js_1.TypeDefInfo.WrapperOpaque:
-            return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
-    }
-    throw new Error(`Unable to encode ${(0, util_1.stringify)(typeDef)} with params`);
-}
-function encodeSubTypes(registry, sub, asEnum, extra) {
-    const names = sub.map(({ name }) => name);
-    if (!names.every((n) => !!n)) {
-        throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
-    }
-    const inner = (0, util_1.objectSpread)({}, extra);
-    for (let i = 0, count = sub.length; i < count; i++) {
-        const def = sub[i];
-        if (!def.name) {
-            throw new Error(`No name found in ${(0, util_1.stringify)(def)}`);
-        }
-        inner[def.name] = encodeTypeDef(registry, def);
-    }
-    return (0, util_1.stringify)(asEnum
-        ? { _enum: inner }
-        : inner);
-}
-const encoders = {
-    [index_js_1.TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeMap'),
-    [index_js_1.TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeSet'),
-    [index_js_1.TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Compact'),
-    [index_js_1.TypeDefInfo.DoNotConstruct]: (registry, { displayName, lookupIndex, lookupName }) => `DoNotConstruct<${lookupName || displayName || ((0, util_1.isUndefined)(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
-    [index_js_1.TypeDefInfo.Enum]: (registry, { sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Enum type');
-        }
-        // c-like enums have all Null entries
-        // TODO We need to take the disciminant into account and auto-add empty entries
-        return sub.every(({ type }) => type === 'Null')
-            ? (0, util_1.stringify)({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
-            : encodeSubTypes(registry, sub, true);
-    },
-    [index_js_1.TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'HashMap'),
-    [index_js_1.TypeDefInfo.Int]: (_registry, { length = 32 }) => `Int<${length}>`,
-    [index_js_1.TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Linkage'),
-    [index_js_1.TypeDefInfo.Null]: (_registry, _typeDef) => 'Null',
-    [index_js_1.TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Option'),
-    [index_js_1.TypeDefInfo.Plain]: (_registry, { displayName, type }) => displayName || type,
-    [index_js_1.TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Range'),
-    [index_js_1.TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'RangeInclusive'),
-    [index_js_1.TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Result'),
-    [index_js_1.TypeDefInfo.Set]: (_registry, { length = 8, sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Set type');
-        }
-        return (0, util_1.stringify)({
-            _set: sub.reduce((all, { index, name }, count) => (0, util_1.objectSpread)(all, { [`${name || `Unknown${index || count}`}`]: index || count }), { _bitLength: length || 8 })
-        });
-    },
-    [index_js_1.TypeDefInfo.Si]: (_registry, { lookupName, type }) => lookupName || type,
-    [index_js_1.TypeDefInfo.Struct]: (registry, { alias, sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Struct type');
-        }
-        return encodeSubTypes(registry, sub, false, alias
-            ? {
-                _alias: [...alias.entries()].reduce((all, [k, v]) => (0, util_1.objectSpread)(all, { [k]: v }), {})
-            }
-            : {});
-    },
-    [index_js_1.TypeDefInfo.Tuple]: (registry, { sub }) => {
-        if (!Array.isArray(sub)) {
-            throw new Error('Unable to encode Tuple type');
-        }
-        return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
-    },
-    [index_js_1.TypeDefInfo.UInt]: (_registry, { length = 32 }) => `UInt<${length}>`,
-    [index_js_1.TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Vec'),
-    [index_js_1.TypeDefInfo.VecFixed]: (_registry, { length, sub }) => {
-        if (!(0, util_1.isNumber)(length) || !sub || Array.isArray(sub)) {
-            throw new Error('Unable to encode VecFixed type');
-        }
-        return `[${sub.type};${length}]`;
-    },
-    [index_js_1.TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
-    [index_js_1.TypeDefInfo.WrapperOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperOpaque')
-};
-function encodeType(registry, typeDef, withLookup = true) {
-    return withLookup && typeDef.lookupName
-        ? typeDef.lookupName
-        : encoders[typeDef.info](registry, typeDef);
-}
-function encodeTypeDef(registry, typeDef) {
-    // In the case of contracts we do have the unfortunate situation where the displayName would
-    // refer to "Option" when it is an option. For these, string it out, only using when actually
-    // not a top-level element to be used
-    return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
-        ? typeDef.displayName
-        : encodeType(registry, typeDef);
-}
-function withTypeString(registry, typeDef) {
-    return (0, util_1.objectSpread)({}, typeDef, {
-        type: encodeType(registry, typeDef, false)
-    });
-}

package/build/cjs/util/getTypeDef.js

@@ -1,195 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypeDef = getTypeDef;
-const types_codec_1 = require("@pezkuwi/types-codec");
-const util_1 = require("@pezkuwi/util");
-const index_js_1 = require("../types/index.js");
-const typeSplit_js_1 = require("./typeSplit.js");
-const KNOWN_INTERNALS = ['_alias', '_fallback'];
-function getTypeString(typeOrObj) {
-    return (0, util_1.isString)(typeOrObj)
-        ? typeOrObj.toString()
-        : (0, util_1.stringify)(typeOrObj);
-}
-function isRustEnum(details) {
-    const values = Object.values(details);
-    if (values.some((v) => (0, util_1.isNumber)(v))) {
-        if (!values.every((v) => (0, util_1.isNumber)(v) && v >= 0 && v <= 255)) {
-            throw new Error('Invalid number-indexed enum definition');
-        }
-        return false;
-    }
-    return true;
-}
-function _decodeEnum(value, details, count, fallbackType) {
-    value.info = index_js_1.TypeDefInfo.Enum;
-    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,
-            info: index_js_1.TypeDefInfo.Plain,
-            name,
-            type: 'Null'
-        }));
-    }
-    else if (isRustEnum(details)) {
-        value.sub = Object.entries(details).map(([name, typeOrObj], index) => (0, util_1.objectSpread)({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
-    }
-    else {
-        value.sub = Object.entries(details).map(([name, index]) => ({
-            index,
-            info: index_js_1.TypeDefInfo.Plain,
-            name,
-            type: 'Null'
-        }));
-    }
-    return value;
-}
-function _decodeSet(value, details, fallbackType) {
-    value.info = index_js_1.TypeDefInfo.Set;
-    value.fallbackType = fallbackType;
-    value.length = details._bitLength;
-    value.sub = Object
-        .entries(details)
-        .filter(([name]) => !name.startsWith('_'))
-        .map(([name, index]) => ({
-        index,
-        info: index_js_1.TypeDefInfo.Plain,
-        name,
-        type: 'Null'
-    }));
-    return value;
-}
-function _decodeStruct(value, type, _, count) {
-    const parsed = JSON.parse(type);
-    const keys = Object.keys(parsed);
-    if (parsed._enum) {
-        return _decodeEnum(value, parsed._enum, count, parsed._fallback);
-    }
-    else if (parsed._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;
-}
-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 ';': {
-                if (inner === 0) {
-                    index = i;
-                }
-                break;
-            }
-            case '[':
-            case '(':
-            case '<':
-                inner++;
-                break;
-            case ']':
-            case ')':
-            case '>':
-                inner--;
-                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;
-}
-function _decodeTuple(value, _, subType, count) {
-    value.sub = subType.length === 0
-        ? []
-        : (0, typeSplit_js_1.typeSplit)(subType).map((inner) => getTypeDef(inner, {}, count));
-    return value;
-}
-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');
-}
-function _decodeDoNotConstruct(value, type, _) {
-    const NAME_LENGTH = 'DoNotConstruct'.length;
-    value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
-    return value;
-}
-function hasWrapper(type, [start, end]) {
-    return (type.startsWith(start)) && (type.slice(-1 * end.length) === end);
-}
-const nestedExtraction = [
-    ['[', ']', index_js_1.TypeDefInfo.VecFixed, _decodeFixedVec],
-    ['{', '}', index_js_1.TypeDefInfo.Struct, _decodeStruct],
-    ['(', ')', index_js_1.TypeDefInfo.Tuple, _decodeTuple],
-    // the inner for these are the same as tuple, multiple values
-    ['BTreeMap<', '>', index_js_1.TypeDefInfo.BTreeMap, _decodeTuple],
-    ['HashMap<', '>', index_js_1.TypeDefInfo.HashMap, _decodeTuple],
-    ['Int<', '>', index_js_1.TypeDefInfo.Int, _decodeInt],
-    ['Result<', '>', index_js_1.TypeDefInfo.Result, _decodeTuple],
-    ['UInt<', '>', index_js_1.TypeDefInfo.UInt, _decodeUInt],
-    ['DoNotConstruct<', '>', index_js_1.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
-];
-const wrappedExtraction = [
-    ['BTreeSet<', '>', index_js_1.TypeDefInfo.BTreeSet],
-    ['Compact<', '>', index_js_1.TypeDefInfo.Compact],
-    ['Linkage<', '>', index_js_1.TypeDefInfo.Linkage],
-    ['Opaque<', '>', index_js_1.TypeDefInfo.WrapperOpaque],
-    ['Option<', '>', index_js_1.TypeDefInfo.Option],
-    ['Range<', '>', index_js_1.TypeDefInfo.Range],
-    ['RangeInclusive<', '>', index_js_1.TypeDefInfo.RangeInclusive],
-    ['Vec<', '>', index_js_1.TypeDefInfo.Vec],
-    ['WrapperKeepOpaque<', '>', index_js_1.TypeDefInfo.WrapperKeepOpaque],
-    ['WrapperOpaque<', '>', index_js_1.TypeDefInfo.WrapperOpaque]
-];
-function extractSubType(type, [start, end]) {
-    return type.substring(start.length, type.length - end.length);
-}
-function getTypeDef(_type, { displayName, name } = {}, count = 0) {
-    // create the type via Type, allowing types to be sanitized
-    const type = (0, types_codec_1.sanitize)(_type);
-    const value = { displayName, info: index_js_1.TypeDefInfo.Plain, 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/build/cjs/util/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./encodeTypes.js"), exports);
-tslib_1.__exportStar(require("./getTypeDef.js"), exports);
-tslib_1.__exportStar(require("./typeSplit.js"), exports);
-tslib_1.__exportStar(require("./xcm.js"), exports);

package/build/cjs/util/typeSplit.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeSplit = typeSplit;
-function typeSplit(type) {
-    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 start = 0;
-    for (let i = 0, count = type.length; i < count; i++) {
-        switch (type[i]) {
-            // if we are not nested, add the type
-            case ',': {
-                if (!(c || f || s || t)) {
-                    result.push(type.substring(start, i).trim());
-                    start = i + 1;
-                }
-                break;
-            }
-            // adjust compact/vec (and friends) depth
-            case '<':
-                c++;
-                break;
-            case '>':
-                c--;
-                break;
-            // adjust fixed vec depths
-            case '[':
-                f++;
-                break;
-            case ']':
-                f--;
-                break;
-            // adjust struct depth
-            case '{':
-                s++;
-                break;
-            case '}':
-                s--;
-                break;
-            // adjust tuple depth
-            case '(':
-                t++;
-                break;
-            case ')':
-                t--;
-                break;
-        }
-    }
-    // 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
-    result.push(type.substring(start, type.length).trim());
-    return result;
-}

package/build/cjs/util/xcm.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XCM_MAPPINGS = void 0;
-exports.mapXcmTypes = mapXcmTypes;
-const util_1 = require("@pezkuwi/util");
-exports.XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError'];
-function mapXcmTypes(version) {
-    return exports.XCM_MAPPINGS.reduce((all, key) => (0, util_1.objectSpread)(all, { [key]: `${key}${version}` }), {});
-}

package/build/create/class.d.ts

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

package/build/create/class.js

@@ -1,160 +0,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 '@pezkuwi/types-codec';
-import { isNumber, stringify } from '@pezkuwi/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));
-}
-function getTypeClassMap(value) {
-    const subs = getSubDefArray(value);
-    const map = {};
-    for (let i = 0, count = subs.length; i < count; i++) {
-        const sub = subs[i];
-        if (!sub.name) {
-            throw new Error(`No name found in definition ${stringify(sub)}`);
-        }
-        map[sub.name] = getTypeDefType(sub);
-    }
-    return map;
-}
-function getTypeClassArray(value) {
-    return getSubDefArray(value).map(getTypeDefType);
-}
-function createInt(Clazz, { displayName, length }) {
-    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),
-    [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) => {
-                if (!name) {
-                    throw new Error('No name found in sub definition');
-                }
-                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;
-    },
-    [TypeDefInfo.Null]: (_registry, _value) => Null,
-    [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(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
-        return Result.with({ Err, Ok });
-    },
-    [TypeDefInfo.Set]: (_registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
-        if (!name || !isNumber(index)) {
-            throw new Error('No name found in sub definition');
-        }
-        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 }) => {
-        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, { displayName, length, sub }) => {
-        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),
-    [TypeDefInfo.WrapperOpaque]: (_registry, value) => createWithSub(WrapperOpaque, value)
-};
-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
-        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}`);
-    }
-}
-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
-        getTypeClass(registry, registry.isLookupType(type)
-            ? registry.lookup.getTypeDef(type)
-            : getTypeDef(type)));
-}

package/build/create/index.d.ts

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

package/build/create/index.js

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

package/build/create/type.d.ts

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

package/build/create/type.js

@@ -1,63 +0,0 @@
-import { Option } from '@pezkuwi/types-codec';
-import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { createClassUnsafe } from './class.js';
-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)));
-    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));
-    }
-}
-function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
-    const created = new (isOptional
-        ? 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;
-}
-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?.__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/build/exports.d.ts

@@ -1,2 +0,0 @@
-export * from './create/index.js';
-export * from './util/index.js';

package/build/exports.js

@@ -1,2 +0,0 @@
-export * from './create/index.js';
-export * from './util/index.js';

package/build/index.d.ts

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

package/build/index.js

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