@pezkuwi/types-create 16.5.17 → 16.5.19

package/build/util/getTypeDef.js

@@ -0,0 +1,192 @@
+import { sanitize } from '@pezkuwi/types-codec';
+import { isNumber, isString, objectSpread, stringify } from '@pezkuwi/util';
+import { TypeDefInfo } from '../types/index.js';
+import { typeSplit } from './typeSplit.js';
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
+function getTypeString(typeOrObj) {
+    return isString(typeOrObj)
+        ? typeOrObj.toString()
+        : stringify(typeOrObj);
+}
+function isRustEnum(details) {
+    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, details, count, fallbackType) {
+    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) => ({
+            index,
+            info: TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    else if (isRustEnum(details)) {
+        value.sub = Object.entries(details).map(([name, typeOrObj], index) => objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
+    }
+    else {
+        value.sub = Object.entries(details).map(([name, index]) => ({
+            index,
+            info: TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    return value;
+}
+function _decodeSet(value, details, fallbackType) {
+    value.info = TypeDefInfo.Set;
+    value.fallbackType = fallbackType;
+    value.length = details._bitLength;
+    value.sub = Object
+        .entries(details)
+        .filter(([name]) => !name.startsWith('_'))
+        .map(([name, index]) => ({
+        index,
+        info: 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
+        ? []
+        : 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 = [
+    ['[', ']', 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 = [
+    ['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, [start, end]) {
+    return type.substring(start.length, type.length - end.length);
+}
+export function getTypeDef(_type, { displayName, name } = {}, count = 0) {
+    // create the type via Type, allowing types to be sanitized
+    const type = sanitize(_type);
+    const value = { 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/util/index.d.ts

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

package/build/util/index.js

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

package/build/util/typeSplit.d.ts

@@ -0,0 +1 @@
+export declare function typeSplit(type: string): string[];

package/build/util/typeSplit.js

@@ -0,0 +1,57 @@
+export 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/util/xcm.d.ts

@@ -0,0 +1,2 @@
+export declare const XCM_MAPPINGS: string[];
+export declare function mapXcmTypes(version: 'V0' | 'V1' | 'V2' | 'V3' | 'V4' | 'V5'): Record<string, string>;

package/build/util/xcm.js

@@ -0,0 +1,5 @@
+import { objectSpread } from '@pezkuwi/util';
+export const XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError'];
+export function mapXcmTypes(version) {
+    return XCM_MAPPINGS.reduce((all, key) => objectSpread(all, { [key]: `${key}${version}` }), {});
+}

package/build-deno/README.md

@@ -0,0 +1,3 @@
+# @pezkuwi/types-create
+
+Base type-creation functionality.

package/build-deno/bundle.ts

@@ -0,0 +1,5 @@
+
+export { packageInfo } from './packageInfo.ts';
+export { TypeDefInfo } from './types/index.ts';
+
+export * from './exports.ts';

package/build-deno/create/class.ts

@@ -0,0 +1,252 @@
+
+import type { Codec, CodecClass, LookupString, Registry, U8aBitLength, UIntBitLength } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { TypeDef } from '../types/index.ts';
+
+import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import { isNumber, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { TypeDefInfo } from '../types/index.ts';
+import { getTypeDef } from '../util/getTypeDef.ts';
+
+function getTypeDefType ({ lookupName, type }: TypeDef): string {
+  return lookupName || type;
+}
+
+function getSubDefArray (value: TypeDef): TypeDef[] {
+  if (!Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
+  }
+
+  return value.sub;
+}
+
+function getSubDef (value: TypeDef): TypeDef {
+  if (!value.sub || Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
+  }
+
+  return value.sub;
+}
+
+function getSubType (value: TypeDef): string {
+  return getTypeDefType(getSubDef(value));
+}
+
+function getTypeClassMap (value: TypeDef): Record<string, string> {
+  const subs = getSubDefArray(value);
+  const map: Record<string, string> = {};
+
+  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: TypeDef): string[] {
+  return getSubDefArray(value).map(getTypeDefType);
+}
+
+function createInt (Clazz: typeof Int | typeof UInt, { displayName, length }: TypeDef): CodecClass<Codec> {
+  if (!isNumber(length)) {
+    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+  }
+
+  return Clazz.with(length as UIntBitLength, displayName);
+}
+
+function createHashMap (Clazz: typeof BTreeMap | typeof HashMap, value: TypeDef): CodecClass<Codec> {
+  const [keyType, valueType] = getTypeClassArray(value);
+
+  return Clazz.with(keyType, valueType);
+}
+
+function createWithSub (Clazz: { with: (t: string) => CodecClass<Codec> }, value: TypeDef): CodecClass<Codec> {
+  return Clazz.with(getSubType(value));
+}
+
+const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => CodecClass<Codec>> = {
+  [TypeDefInfo.BTreeMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createHashMap(BTreeMap, value),
+
+  [TypeDefInfo.BTreeSet]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(BTreeSet, value),
+
+  [TypeDefInfo.Compact]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(Compact, value),
+
+  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    DoNotConstruct.with(value.displayName || value.type),
+
+  [TypeDefInfo.Enum]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const subs = getSubDefArray(value);
+
+    return Enum.with(
+      subs.every(({ type }) => type === 'Null')
+        ? subs.reduce<Record<string, number>>((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: Registry, value: TypeDef): CodecClass<Codec> =>
+    createHashMap(HashMap, value),
+
+  [TypeDefInfo.Int]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createInt(Int, value),
+
+  // We have circular deps between Linkage & Struct
+  [TypeDefInfo.Linkage]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const type = `Option<${getSubType(value)}>`;
+    // eslint-disable-next-line sort-keys
+    const Clazz = Struct.with({ previous: type, next: type } as any);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    Clazz.prototype.toRawType = function (): string {
+      // 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: Registry, _value: TypeDef): CodecClass<Codec> =>
+    Null,
+
+  [TypeDefInfo.Option]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    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: Registry, value: TypeDef): CodecClass<Codec> =>
+    registry.getOrUnknown(value.type),
+
+  [TypeDefInfo.Range]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(Range, value),
+
+  [TypeDefInfo.RangeInclusive]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(RangeInclusive, value),
+
+  [TypeDefInfo.Result]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
+    const [Ok, Err] = getTypeClassArray(value);
+
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    return Result.with({ Err, Ok });
+  },
+
+  [TypeDefInfo.Set]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    CodecSet.with(
+      getSubDefArray(value).reduce<Record<string, number>>((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: Registry, value: TypeDef): CodecClass<Codec> =>
+    getTypeClass(registry, registry.lookup.getTypeDef(value.type as LookupString)),
+
+  [TypeDefInfo.Struct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    Struct.with(getTypeClassMap(value), value.alias),
+
+  [TypeDefInfo.Tuple]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    Tuple.with(getTypeClassArray(value)),
+
+  [TypeDefInfo.UInt]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createInt(UInt, value),
+
+  [TypeDefInfo.Vec]: (_registry: Registry, { sub }: TypeDef): CodecClass<Codec> => {
+    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: Registry, { displayName, length, sub }: TypeDef): CodecClass<Codec> => {
+    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) as U8aBitLength, displayName)
+        : VecFixed.with(getTypeDefType(sub), length)
+    );
+  },
+
+  [TypeDefInfo.WrapperKeepOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(WrapperKeepOpaque, value),
+
+  [TypeDefInfo.WrapperOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
+    createWithSub(WrapperOpaque, value)
+};
+
+export function constructTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
+  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 as CodecClass<T>;
+  } catch (error) {
+    throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${(error as Error).message}`);
+  }
+}
+
+export function getTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
+  return registry.getUnsafe(typeDef.type, false, typeDef) as unknown as CodecClass<T>;
+}
+
+export function createClassUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K): CodecClass<T> {
+  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-deno/create/index.ts

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

package/build-deno/create/type.ts

@@ -0,0 +1,85 @@
+
+import type { Bytes } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import type { Codec, CodecClass, IU8a, Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { CreateOptions } from '../types/index.ts';
+
+import { Option } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
+import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { createClassUnsafe } from './class.ts';
+
+function checkInstance (created: Codec, matcher: Uint8Array): void {
+  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 as unknown as Bytes).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: Codec, [value]: unknown[]): void {
+  if (isU8a(value)) {
+    checkInstance(created, value);
+  } else if (isHex(value)) {
+    checkInstance(created, u8aToU8a(value));
+  }
+}
+
+function initType<T extends Codec> (registry: Registry, Type: CodecClass, params: unknown[] = [], { blockHash, isFallback, isOptional, isPedantic }: CreateOptions = {}): T {
+  const created = new (
+    isOptional
+      ? Option.with(Type)
+      : Type
+  )(registry, ...params);
+
+  isPedantic && checkPedantic(created, params);
+
+  if (blockHash) {
+    created.createdAtHash = createTypeUnsafe<IU8a>(registry, 'BlockHash', [blockHash]);
+  }
+
+  if (isFallback) {
+    created.isStorageFallback = true;
+  }
+
+  return created as T;
+}
+
+export function createTypeUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K, params: unknown[] = [], options: CreateOptions = {}): T {
+  let Clazz: CodecClass | null = null;
+  let firstError: Error | null = null;
+
+  try {
+    Clazz = createClassUnsafe(registry, type);
+
+    return initType(registry, Clazz, params, options);
+  } catch (error) {
+    firstError = new Error(`createType(${type}):: ${(error as Error).message}`);
+  }
+
+  if (Clazz?.__fallbackType) {
+    try {
+      Clazz = createClassUnsafe(registry, Clazz.__fallbackType as unknown as K);
+
+      return initType(registry, Clazz, params, options);
+    } catch {
+      // swallow, we will throw the first error again
+    }
+  }
+
+  throw firstError;
+}

package/build-deno/exports.ts

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

package/build-deno/index.ts

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

package/build-deno/mod.ts

@@ -0,0 +1,2 @@
+
+export * from './index.ts';

package/build-deno/packageDetect.ts

@@ -0,0 +1,8 @@
+
+
+import { packageInfo as codecInfo } from 'https://deno.land/x/pezkuwi/types-codec/packageInfo.ts';
+import { detectPackage } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { packageInfo } from './packageInfo.ts';
+
+detectPackage(packageInfo, null, [codecInfo]);

package/build-deno/packageInfo.ts

@@ -0,0 +1,3 @@
+
+
+export const packageInfo = { name: '@pezkuwi/types-create', path: new URL(import.meta.url).pathname, type: 'deno', version: '16.5.18' };

package/build-deno/types/augmentRegistry.ts

@@ -0,0 +1,15 @@
+
+import 'https://deno.land/x/pezkuwi/types-codec/types/registry.ts';
+
+import type { Codec, CodecClass, ICompact, INumber, LookupString } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { ILookup, TypeDef } from 'https://deno.land/x/pezkuwi/types-create/types/index.ts';
+
+declare module 'https://deno.land/x/pezkuwi/types-codec/types/registry.ts' {
+  interface Registry {
+    readonly lookup: ILookup;
+
+    createLookupType (lookupId: ICompact<INumber> | number): LookupString;
+    getUnsafe <T extends Codec = Codec, K extends string = string> (name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    setLookup (lookup: ILookup): void;
+  }
+}

package/build-deno/types/index.ts

@@ -0,0 +1,7 @@
+
+import './augmentRegistry.ts';
+
+export type { CodecCreateOptions as CreateOptions } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+
+export * from './lookup.ts';
+export * from './types.ts';