@pezkuwi/types-create 16.5.16 → 16.5.18

package/build-deno/types/lookup.ts

@@ -0,0 +1,16 @@
+
+import type { Option, Text } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { ICompact, INumber, LookupString } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { TypeDef } from './types.ts';
+
+interface SiTypeBase {
+  def: {
+    asTuple: ICompact<INumber>[]
+  }
+}
+
+export interface ILookup {
+  getSiType (lookupId: ICompact<INumber> | LookupString | number): SiTypeBase;
+  getTypeDef (lookupId: ICompact<INumber> | LookupString | number): TypeDef;
+  sanitizeField (name: Option<Text>): [string | null, string | null];
+}

package/build-deno/types/types.ts

@@ -0,0 +1,45 @@
+
+export enum TypeDefInfo {
+  BTreeMap,
+  BTreeSet,
+  Compact,
+  DoNotConstruct,
+  Enum,
+  HashMap,
+  Int,
+  Linkage,
+  Null,
+  Option,
+  Plain,
+  Range,
+  RangeInclusive,
+  Result,
+  Set,
+  Si,
+  Struct,
+  Tuple,
+  UInt,
+  Vec,
+  VecFixed,
+  WrapperKeepOpaque,
+  WrapperOpaque
+}
+
+export interface TypeDef {
+  alias?: Map<string, string> | undefined;
+  displayName?: string | undefined;
+  docs?: string[] | undefined;
+  fallbackType?: string | undefined;
+  info: TypeDefInfo;
+  index?: number;
+  isFromSi?: boolean;
+  length?: number;
+  lookupIndex?: number;
+  lookupName?: string | undefined;
+  lookupNameRoot?: string | undefined;
+  name?: string | undefined;
+  namespace?: string | undefined;
+  sub?: TypeDef | TypeDef[];
+  type: string;
+  typeName?: string | undefined;
+}

package/build-deno/util/encodeTypes.ts

@@ -0,0 +1,201 @@
+
+import type { Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { TypeDef } from 'https://deno.land/x/pezkuwi/types-create/types/index.ts';
+
+import { isNumber, isUndefined, objectSpread, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { TypeDefInfo } from '../types/index.ts';
+
+interface ToString { toString: () => string }
+
+const stringIdentity = <T extends ToString> (value: T): string => value.toString();
+
+const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
+
+export function paramsNotation <T extends ToString> (outer: string, inner?: T | T[], transform: (_: T) => string = stringIdentity): string {
+  return `${outer}${
+    inner
+      ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
+      : ''
+  }`;
+}
+
+function encodeWithParams (registry: Registry, typeDef: TypeDef, outer: string): string {
+  const { info, sub } = typeDef;
+
+  switch (info) {
+    case TypeDefInfo.BTreeMap:
+    case TypeDefInfo.BTreeSet:
+    case TypeDefInfo.Compact:
+    case TypeDefInfo.HashMap:
+    case TypeDefInfo.Linkage:
+    case TypeDefInfo.Option:
+    case TypeDefInfo.Range:
+    case TypeDefInfo.RangeInclusive:
+    case TypeDefInfo.Result:
+    case TypeDefInfo.Vec:
+    case TypeDefInfo.WrapperKeepOpaque:
+    case TypeDefInfo.WrapperOpaque:
+      return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
+  }
+
+  throw new Error(`Unable to encode ${stringify(typeDef)} with params`);
+}
+
+function encodeSubTypes (registry: Registry, sub: TypeDef[], asEnum?: boolean, extra?: Record<string, unknown>): string {
+  const names = sub.map(({ name }) => name);
+
+  if (!names.every((n) => !!n)) {
+    throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
+  }
+
+  const inner: Record<string, string> = 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 ${stringify(def)}`);
+    }
+
+    inner[def.name] = encodeTypeDef(registry, def);
+  }
+
+  return stringify(
+    asEnum
+      ? { _enum: inner }
+      : inner
+  );
+}
+
+const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => string> = {
+  [TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'BTreeMap'),
+
+  [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'BTreeSet'),
+
+  [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Compact'),
+
+  [TypeDefInfo.DoNotConstruct]: (registry: Registry, { displayName, lookupIndex, lookupName }: TypeDef) =>
+    `DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
+
+  [TypeDefInfo.Enum]: (registry: Registry, { sub }: TypeDef): string => {
+    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')
+      ? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
+      : encodeSubTypes(registry, sub, true);
+  },
+
+  [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'HashMap'),
+
+  [TypeDefInfo.Int]: (_registry: Registry, { length = 32 }: TypeDef) =>
+    `Int<${length}>`,
+
+  [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Linkage'),
+
+  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef) =>
+    'Null',
+
+  [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Option'),
+
+  [TypeDefInfo.Plain]: (_registry: Registry, { displayName, type }: TypeDef) =>
+    displayName || type,
+
+  [TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Range'),
+
+  [TypeDefInfo.RangeInclusive]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'RangeInclusive'),
+
+  [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Result'),
+
+  [TypeDefInfo.Set]: (_registry: Registry, { length = 8, sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Set type');
+    }
+
+    return stringify({
+      _set: sub.reduce((all, { index, name }, count) =>
+        objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }),
+      { _bitLength: length || 8 })
+    });
+  },
+
+  [TypeDefInfo.Si]: (_registry: Registry, { lookupName, type }: TypeDef) =>
+    lookupName || type,
+
+  [TypeDefInfo.Struct]: (registry: Registry, { alias, sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Struct type');
+    }
+
+    return encodeSubTypes(registry, sub, false, alias
+      ? {
+        _alias: [...alias.entries()].reduce<Record<string, string>>((all, [k, v]) =>
+          objectSpread(all, { [k]: v }), {}
+        )
+      }
+      : {}
+    );
+  },
+
+  [TypeDefInfo.Tuple]: (registry: Registry, { sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Tuple type');
+    }
+
+    return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
+  },
+
+  [TypeDefInfo.UInt]: (_registry: Registry, { length = 32 }: TypeDef) =>
+    `UInt<${length}>`,
+
+  [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Vec'),
+
+  [TypeDefInfo.VecFixed]: (_registry: Registry, { length, sub }: TypeDef): string => {
+    if (!isNumber(length) || !sub || Array.isArray(sub)) {
+      throw new Error('Unable to encode VecFixed type');
+    }
+
+    return `[${sub.type};${length}]`;
+  },
+
+  [TypeDefInfo.WrapperKeepOpaque]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
+
+  [TypeDefInfo.WrapperOpaque]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'WrapperOpaque')
+};
+
+function encodeType (registry: Registry, typeDef: TypeDef, withLookup = true): string {
+  return withLookup && typeDef.lookupName
+    ? typeDef.lookupName
+    : encoders[typeDef.info](registry, typeDef);
+}
+
+export function encodeTypeDef (registry: Registry, typeDef: TypeDef): string {
+  // 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);
+}
+
+export function withTypeString (registry: Registry, typeDef: Omit<TypeDef, 'type'> & { type?: string }): TypeDef {
+  return objectSpread({}, typeDef, {
+    type: encodeType(registry, typeDef as TypeDef, false)
+  });
+}

package/build-deno/util/getTypeDef.ts

@@ -0,0 +1,267 @@
+
+import type { AnyString } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { TypeDef } from 'https://deno.land/x/pezkuwi/types-create/types/index.ts';
+
+import { sanitize } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import { isNumber, isString, objectSpread, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { TypeDefInfo } from '../types/index.ts';
+import { typeSplit } from './typeSplit.ts';
+
+interface TypeDefOptions {
+  name?: string;
+  displayName?: string;
+}
+
+interface SetDetails {
+  _bitLength: number;
+  index: number;
+
+  [key: string]: number;
+}
+
+interface ParsedDef {
+  _alias: string;
+  _enum?: string[];
+  _fallback?: string;
+  _set?: SetDetails;
+
+  [key: string]: unknown;
+}
+
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
+
+function getTypeString (typeOrObj: any): string {
+  return isString(typeOrObj)
+    ? typeOrObj.toString()
+    : stringify(typeOrObj);
+}
+
+function isRustEnum (details: Record<string, string> | Record<string, number>): details is Record<string, string> {
+  const values = Object.values(details);
+
+  if (values.some((v) => isNumber(v))) {
+    if (!values.every((v) => isNumber(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
+    return false;
+  }
+
+  return true;
+}
+
+function _decodeEnum (value: TypeDef, details: string[] | Record<string, string> | Record<string, number>, count: number, fallbackType?: string): TypeDef {
+  value.info = 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): TypeDef => ({
+      index,
+      info: TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+  } else if (isRustEnum(details)) {
+    value.sub = Object.entries(details).map(([name, typeOrObj], index): TypeDef =>
+      objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index })
+    );
+  } else {
+    value.sub = Object.entries(details).map(([name, index]): TypeDef => ({
+      index,
+      info: TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+  }
+
+  return value;
+}
+
+function _decodeSet (value: TypeDef, details: SetDetails, fallbackType: string | undefined): TypeDef {
+  value.info = TypeDefInfo.Set;
+  value.fallbackType = fallbackType;
+  value.length = details._bitLength;
+  value.sub = Object
+    .entries(details)
+    .filter(([name]): boolean => !name.startsWith('_'))
+    .map(([name, index]): TypeDef => ({
+      index,
+      info: TypeDefInfo.Plain,
+      name,
+      type: 'Null'
+    }));
+
+  return value;
+}
+
+function _decodeStruct (value: TypeDef, type: string, _: string, count: number): TypeDef {
+  const parsed = JSON.parse(type) as ParsedDef;
+  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: TypeDef, type: string, _: string, count: number): TypeDef {
+  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: TypeDef, _: string, subType: string, count: number): TypeDef {
+  value.sub = subType.length === 0
+    ? []
+    : typeSplit(subType).map((inner) => getTypeDef(inner, {}, count));
+
+  return value;
+}
+
+function _decodeAnyInt (value: TypeDef, type: string, _: string, clazz: 'Int' | 'UInt'): TypeDef {
+  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: TypeDef, type: string, subType: string): TypeDef {
+  return _decodeAnyInt(value, type, subType, 'Int');
+}
+
+function _decodeUInt (value: TypeDef, type: string, subType: string): TypeDef {
+  return _decodeAnyInt(value, type, subType, 'UInt');
+}
+
+function _decodeDoNotConstruct (value: TypeDef, type: string, _: string): TypeDef {
+  const NAME_LENGTH = 'DoNotConstruct'.length;
+
+  value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
+
+  return value;
+}
+
+function hasWrapper (type: string, [start, end]: [string, string, TypeDefInfo, any?]): boolean {
+  return (type.startsWith(start)) && (type.slice(-1 * end.length) === end);
+}
+
+const nestedExtraction: [string, string, TypeDefInfo, (value: TypeDef, type: string, subType: string, count: number) => TypeDef][] = [
+  ['[', ']', TypeDefInfo.VecFixed, _decodeFixedVec],
+  ['{', '}', TypeDefInfo.Struct, _decodeStruct],
+  ['(', ')', TypeDefInfo.Tuple, _decodeTuple],
+  // the inner for these are the same as tuple, multiple values
+  ['BTreeMap<', '>', TypeDefInfo.BTreeMap, _decodeTuple],
+  ['HashMap<', '>', TypeDefInfo.HashMap, _decodeTuple],
+  ['Int<', '>', TypeDefInfo.Int, _decodeInt],
+  ['Result<', '>', TypeDefInfo.Result, _decodeTuple],
+  ['UInt<', '>', TypeDefInfo.UInt, _decodeUInt],
+  ['DoNotConstruct<', '>', TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
+];
+
+const wrappedExtraction: [string, string, TypeDefInfo][] = [
+  ['BTreeSet<', '>', TypeDefInfo.BTreeSet],
+  ['Compact<', '>', TypeDefInfo.Compact],
+  ['Linkage<', '>', TypeDefInfo.Linkage],
+  ['Opaque<', '>', TypeDefInfo.WrapperOpaque],
+  ['Option<', '>', TypeDefInfo.Option],
+  ['Range<', '>', TypeDefInfo.Range],
+  ['RangeInclusive<', '>', TypeDefInfo.RangeInclusive],
+  ['Vec<', '>', TypeDefInfo.Vec],
+  ['WrapperKeepOpaque<', '>', TypeDefInfo.WrapperKeepOpaque],
+  ['WrapperOpaque<', '>', TypeDefInfo.WrapperOpaque]
+];
+
+function extractSubType (type: string, [start, end]: [string, string, TypeDefInfo, any?]): string {
+  return type.substring(start.length, type.length - end.length);
+}
+
+export function getTypeDef (_type: AnyString, { displayName, name }: TypeDefOptions = {}, count = 0): TypeDef {
+  // create the type via Type, allowing types to be sanitized
+  const type = sanitize(_type);
+  const value: TypeDef = { displayName, info: 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-deno/util/index.ts

@@ -0,0 +1,5 @@
+
+export * from './encodeTypes.ts';
+export * from './getTypeDef.ts';
+export * from './typeSplit.ts';
+export * from './xcm.ts';

package/build-deno/util/typeSplit.ts

@@ -0,0 +1,53 @@
+
+export function typeSplit (type: string): string[] {
+  const result: string[] = [];
+
+  // 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-deno/util/xcm.ts

@@ -0,0 +1,10 @@
+
+import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError'];
+
+export function mapXcmTypes (version: 'V0' | 'V1' | 'V2' | 'V3' | 'V4' | 'V5'): Record<string, string> {
+  return XCM_MAPPINGS.reduce<Record<string, string>>((all, key) =>
+    objectSpread(all, { [key]: `${key}${version}` }), {}
+  );
+}

package/build-tsc-cjs/packageDetect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/types-codec/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo]);

package/{cjs → build-tsc-cjs}/packageInfo.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/types-create', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.16' };
+exports.packageInfo = { name: '@pezkuwi/types-create', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.18' };

package/{packageInfo.js → build-tsc-esm/packageInfo.js}

@@ -1 +1 @@
-export const packageInfo = { name: '@pezkuwi/types-create', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.16' };
+export const packageInfo = { name: '@pezkuwi/types-create', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '16.5.18' };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "author": "Dijital Kurdistan Tech Institute <dev@pezkuwichain.io>",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
   "description": "Type creator helpers",
   "engines": {
@@ -18,13 +18,11 @@
     "./cjs/packageDetect.js"
   ],
   "type": "module",
-  "version": "16.5.16",
+  "types": "./index.d.ts",
+  "version": "16.5.18",
   "main": "./cjs/index.js",
-  "module": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
+  "module": "./index.js",
   "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
     ".": {
       "module": {
         "types": "./index.d.ts",
@@ -53,6 +51,8 @@
         "default": "./bundle.js"
       }
     },
+    "./cjs/*": "./cjs/*.js",
+    "./cjs/package.json": "./cjs/package.json",
     "./create": {
       "module": {
         "types": "./create/index.d.ts",
@@ -127,7 +127,7 @@
         "default": "./packageDetect.js"
       }
     },
-    "./packageInfo.js": {
+    "./packageInfo": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -141,7 +141,7 @@
         "default": "./packageInfo.js"
       }
     },
-    "./packageInfo": {
+    "./packageInfo.js": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -283,9 +283,9 @@
     }
   },
   "dependencies": {
-    "@pezkuwi/types": "16.5.15",
-    "@pezkuwi/types-codec": "16.5.15",
-    "@pezkuwi/util": "14.0.12",
+    "@pezkuwi/types": "16.5.9",
+    "@pezkuwi/types-codec": "16.5.9",
+    "@pezkuwi/util": "14.0.11",
     "tslib": "^2.8.1"
   }
 }