utilium 0.3.3 → 0.4.0

package/dist/internal/primitives.d.ts

@@ -0,0 +1,21 @@
+type BitsToBytes = {
+    '8': 1;
+    '16': 2;
+    '32': 4;
+    '64': 8;
+};
+export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? (bits extends keyof BitsToBytes ? BitsToBytes[bits] : never) : never;
+export type Type = `${'int' | 'uint'}${8 | 16 | 32 | 64}` | `float${32 | 64}`;
+export type Valid = Type | Capitalize<Type> | 'char';
+export declare const types: ("int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" | "float32" | "float64")[];
+export declare const valids: ("int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" | "float32" | "float64" | "Int8" | "Int16" | "Int32" | "Int64" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Float32" | "Float64" | "char")[];
+export declare const regex: RegExp;
+export type Normalize<T extends Valid> = T extends 'char' ? 'uint8' : Uncapitalize<T>;
+export declare function normalize<T extends Valid>(type: T): Normalize<T>;
+export declare function isType(type: {
+    toString(): string;
+}): type is Type;
+export declare function isValid(type: {
+    toString(): string;
+}): type is Valid;
+export {};

package/dist/internal/primitives.js

@@ -0,0 +1,13 @@
+import { capitalize } from '../string.js';
+export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'];
+export const valids = [...types, ...types.map(t => capitalize(t)), 'char'];
+export const regex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
+export function normalize(type) {
+    return (type == 'char' ? 'uint8' : type.toLowerCase());
+}
+export function isType(type) {
+    return regex.test(type.toString());
+}
+export function isValid(type) {
+    return type == 'char' || regex.test(type.toString().toLowerCase());
+}

package/dist/internal/struct.d.ts

@@ -0,0 +1,48 @@
+import { ClassLike } from '../types.js';
+import * as primitive from './primitives.js';
+export interface MemberInit {
+    name: string;
+    type: string | ClassLike;
+    length?: number;
+}
+export declare const init: unique symbol;
+export type init = typeof init;
+/**
+ * Options for struct initialization
+ */
+export interface Options {
+    align: number;
+    bigEndian: boolean;
+}
+export interface Member {
+    type: primitive.Type | Static;
+    offset: number;
+    length?: number;
+}
+export interface Metadata {
+    options: Partial<Options>;
+    members: Map<string, Member>;
+    size: number;
+}
+export declare const metadata: unique symbol;
+export type metadata = typeof metadata;
+export interface Static<T extends Metadata = Metadata> {
+    [metadata]: T;
+    new (): Instance;
+    prototype: Instance;
+}
+export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
+    [metadata]?: T;
+    [init]?: MemberInit[];
+}
+export declare function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T>;
+export interface Instance<T extends Metadata = Metadata> {
+    constructor: Static<T>;
+}
+export interface InstanceLike<T extends Metadata = Metadata> {
+    constructor: StaticLike<T>;
+}
+export declare function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T>;
+export declare function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T>;
+export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
+export type Size<T extends primitive.Valid | StaticLike | InstanceLike> = T extends primitive.Valid ? primitive.Size<T> : T extends Like<infer M> ? M['size'] : number;

package/dist/internal/struct.js

@@ -0,0 +1,11 @@
+export const init = Symbol('struct_init');
+export const metadata = Symbol('struct');
+export function isStatic(arg) {
+    return typeof arg == 'function' && metadata in arg;
+}
+export function isInstance(arg) {
+    return metadata in (arg?.constructor || {});
+}
+export function isStruct(arg) {
+    return isInstance(arg) || isStatic(arg);
+}

package/dist/objects.d.ts

@@ -1,11 +1,18 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as FS from 'fs';
+import { UnionToTuple } from './types.js';
 export declare function filterObject<O extends object, R extends object>(object: O, predicate: (key: keyof O, value: O[keyof O]) => boolean): R;
 export declare function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Pick<T, K>;
 export declare function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Pick<T, K>;
 export declare function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Omit<T, K>;
 export declare function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Omit<T, K>;
-export declare function assignWithDefaults<To extends object, From extends object>(to: To, from: From, defaults?: Partial<To>): void;
+export declare function assignWithDefaults<To extends Record<keyof any, any>, From extends Partial<To>>(to: To, from: From, defaults?: Partial<To>): void;
+/**
+ * Entries of T
+ */
+export type Entries<T extends object> = UnionToTuple<{
+    [K in keyof T]: [K, T[K]];
+}[keyof T]>;
 export declare function isJSON(str: string): boolean;
 export declare abstract class FileMap<V> implements Map<string, V> {
     protected readonly path: string;
@@ -19,7 +26,7 @@ export declare abstract class FileMap<V> implements Map<string, V> {
     abstract has(key: string): boolean;
     abstract set(key: string, value: V): this;
     get size(): number;
-    get [Symbol.iterator](): any;
+    get [Symbol.iterator](): () => IterableIterator<[string, V]>;
     get keys(): typeof this._map.keys;
     get values(): typeof this._map.values;
     get entries(): typeof this._map.entries;
@@ -59,7 +66,7 @@ export interface FolderMapOptions {
      * Suffix to append to keys to resolve file names
      */
     suffix: string;
-    fs?: typeof FS;
+    fs: typeof FS;
 }
 /**
  * A Map overlaying a folder
@@ -78,9 +85,3 @@ export declare class FolderMap extends FileMap<string> {
     set(key: string, value: string): this;
 }
 export declare function resolveConstructors(object: object): string[];
-/**
- * Gets a random int, r, with the probability P(r) = (base)**r
- * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
- * @param probability the probability
- */
-export declare function getRandomIntWithRecursiveProbability(probability?: number): number;

package/dist/objects.js

@@ -10,7 +10,7 @@ export function pick(object, ...keys) {
     return picked;
 }
 export function omit(object, ...keys) {
-    return filterObject(object, (key) => !keys.flat().includes(key));
+    return filterObject(object, key => !keys.flat().includes(key));
 }
 export function assignWithDefaults(to, from, defaults = to) {
     const keys = new Set([...Object.keys(to), ...Object.keys(from)]);
@@ -138,7 +138,7 @@ export class FolderMap extends FileMap {
     get _names() {
         return this.fs
             .readdirSync(this.path)
-            .filter(p => p.endsWith(this.options.suffix))
+            .filter(p => p.endsWith(this.options.suffix || ''))
             .map(p => p.slice(0, -this.options.suffix.length));
     }
     _join(path) {
@@ -165,9 +165,10 @@ export class FolderMap extends FileMap {
         return true;
     }
     get(key) {
-        if (this.has(key)) {
-            return this.fs.readFileSync(this._join(key), 'utf8');
+        if (!this.has(key)) {
+            throw new ReferenceError('Key not found');
         }
+        return this.fs.readFileSync(this._join(key), 'utf8');
     }
     has(key) {
         return this._names.includes(key);
@@ -186,11 +187,3 @@ export function resolveConstructors(object) {
     }
     return constructors;
 }
-/**
- * Gets a random int, r, with the probability P(r) = (base)**r
- * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
- * @param probability the probability
- */
-export function getRandomIntWithRecursiveProbability(probability = 0.5) {
-    return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
-}

package/dist/random.d.ts

@@ -3,3 +3,9 @@ export declare function randomHex(length?: number): string;
 export declare function randomBoolean(): boolean;
 export declare function randomBinaryString(length?: number): string;
 export declare function randomInt(min?: number, max?: number): number;
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export declare function getRandomIntWithRecursiveProbability(probability?: number): number;

package/dist/random.js

@@ -21,3 +21,11 @@ export function randomBinaryString(length = 1) {
 export function randomInt(min = 0, max = 1) {
     return Math.round(Math.random() * (max - min) + min);
 }
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export function getRandomIntWithRecursiveProbability(probability = 0.5) {
+    return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
+}

package/dist/string.d.ts

@@ -1,2 +1,6 @@
 export declare function capitalize<T extends string>(value: T): Capitalize<T>;
 export declare function uncapitalize<T extends string>(value: T): Uncapitalize<T>;
+export type ConcatString<T extends string[]> = T extends [infer F extends string, ...infer R extends string[]] ? `${F}${ConcatString<R>}` : '';
+export type Join<T extends string[], S extends string = ','> = T extends [infer F extends string, ...infer R extends string[]] ? `${F}${R extends [] ? '' : `${S}${Join<R, S>}`}` : '';
+export type Whitespace = ' ' | '\t';
+export type Trim<T extends string> = T extends `${Whitespace}${infer R extends string}` ? Trim<R> : T;

package/dist/struct.d.ts

@@ -1,17 +1,11 @@
+import * as Struct from './internal/struct.js';
 import { ClassLike } from './types.js';
-export type PrimitiveType = `${'int' | 'uint'}${8 | 16 | 32 | 64}` | `float${32 | 64}`;
-export type ValidPrimitiveType = PrimitiveType | Capitalize<PrimitiveType> | 'char';
-/**
- * Options for struct initialization
- */
-export interface StructOptions {
-    align: number;
-    bigEndian: boolean;
-}
+import * as primitive from './internal/primitives.js';
+export { Struct };
 /**
  * Gets the size in bytes of a type
  */
-export declare function sizeof(type: ValidPrimitiveType | ClassLike | object): number;
+export declare function sizeof<T extends primitive.Valid | Struct.StaticLike | Struct.InstanceLike>(type: T): Struct.Size<T>;
 /**
  * Aligns a number
  */
@@ -19,11 +13,11 @@ export declare function align(value: number, alignment: number): number;
 /**
  * Decorates a class as a struct
  */
-export declare function struct(options?: Partial<StructOptions>): (target: ClassLike, _?: ClassDecoratorContext) => void;
+export declare function struct(options?: Partial<Struct.Options>): (target: Struct.StaticLike, _?: ClassDecoratorContext) => void;
 /**
  * Decorates a class member to be serialized
  */
-export declare function member(type: ValidPrimitiveType | ClassLike, length?: number): (target: object, { name }: ClassMemberDecoratorContext) => void;
+export declare function member(type: primitive.Valid | ClassLike, length?: number): (target: object, context?: ClassMemberDecoratorContext | string | symbol) => void;
 /**
  * Serializes a struct into a Uint8Array
  */
@@ -32,6 +26,10 @@ export declare function serialize(instance: unknown): Uint8Array;
  * Deserializes a struct from a Uint8Array
  */
 export declare function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBufferView): void;
+/**
+ * Also can be a name when legacy decorators are used
+ */
+type Context = string | symbol | ClassMemberDecoratorContext;
 /**
  * Shortcut types
  *
@@ -39,87 +37,87 @@ export declare function deserialize(instance: unknown, _buffer: ArrayBuffer | Ar
  */
 export declare const types: {
     int8: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     int16: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     int32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     int64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     uint8: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     uint16: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     uint32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     uint64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     float32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     float64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Int8: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Int16: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Int32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Int64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Uint8: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Uint16: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Uint32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Uint64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Float32: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     Float64: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
     char: {
-        (length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-        (target: object, context: ClassMemberDecoratorContext): void;
+        (length: number): (target: object, context?: Context) => void;
+        (target: object, context?: Context): void;
     };
 };

package/dist/struct.js

@@ -1,42 +1,22 @@
+import * as Struct from './internal/struct.js';
 import { capitalize } from './string.js';
-const primitiveTypes = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'];
-const validPrimitiveTypes = [...primitiveTypes, ...primitiveTypes.map(t => capitalize(t)), 'char'];
-const numberRegex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
-function normalizePrimitive(type) {
-    return type == 'char' ? 'uint8' : type.toLowerCase();
-}
-function isPrimitiveType(type) {
-    return numberRegex.test(type.toString());
-}
-function isValidPrimitive(type) {
-    return type == 'char' || numberRegex.test(type.toString().toLowerCase());
-}
-const init = Symbol('struct_init');
-const metadata = Symbol('struct');
-function isStatic(arg) {
-    return typeof arg == 'function' && metadata in arg;
-}
-function isInstance(arg) {
-    return metadata in (arg?.constructor || {});
-}
-function isStruct(arg) {
-    return isInstance(arg) || isStatic(arg);
-}
+import * as primitive from './internal/primitives.js';
+export { Struct };
 /**
  * Gets the size in bytes of a type
  */
 export function sizeof(type) {
     // primitive
     if (typeof type == 'string') {
-        if (!isValidPrimitive(type)) {
+        if (!primitive.isValid(type)) {
             throw new TypeError('Invalid primitive type: ' + type);
         }
-        return +normalizePrimitive(type).match(numberRegex)[2] / 8;
+        return (+primitive.normalize(type).match(primitive.regex)[2] / 8);
     }
-    if (!isStruct(type)) {
+    if (!Struct.isStruct(type)) {
         throw new TypeError('Not a struct');
     }
-    const meta = metadata in type ? type[metadata] : type.constructor[metadata];
+    const meta = Struct.isStatic(type) ? type[Struct.metadata] : type.constructor[Struct.metadata];
     return meta.size;
 }
 /**
@@ -51,62 +31,67 @@ export function align(value, alignment) {
 export function struct(options = {}) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     return function (target, _) {
-        target[init] ||= [];
+        target[Struct.init] ||= [];
         let size = 0;
         const members = new Map();
-        for (const { name, type, length } of target[init]) {
-            if (!isValidPrimitive(type) && !isStatic(type)) {
+        for (const { name, type, length } of target[Struct.init]) {
+            if (!primitive.isValid(type) && !Struct.isStatic(type)) {
                 throw new TypeError('Not a valid type: ' + type);
             }
             members.set(name, {
                 offset: size,
-                type: isValidPrimitive(type) ? normalizePrimitive(type) : type,
+                type: primitive.isValid(type) ? primitive.normalize(type) : type,
                 length,
             });
             size += sizeof(type) * (length || 1);
             size = align(size, options.align || 1);
         }
-        target[metadata] = { options, members, size };
-        delete target[init];
+        target[Struct.metadata] = { options, members, size };
     };
 }
 /**
  * Decorates a class member to be serialized
  */
 export function member(type, length) {
-    return function (target, { name }) {
+    return function (target, context) {
+        let name = typeof context == 'object' ? context.name : context;
         if (typeof name == 'symbol') {
             console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
             name = name.toString();
         }
-        if (typeof target != 'object' || typeof target != 'function') {
+        if (!name) {
+            throw new ReferenceError('Invalid name for struct member');
+        }
+        if (typeof target != 'object') {
             throw new TypeError('Invalid member for struct field');
         }
         if (!('constructor' in target)) {
             throw new TypeError('Invalid member for struct field');
         }
-        target.constructor[init] ||= [];
-        target.constructor[init].push({ name, type, length });
+        const struct = target.constructor;
+        struct[Struct.init] ||= [];
+        struct[Struct.init].push({ name, type, length });
     };
 }
 /**
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance) {
-    if (!isInstance(instance)) {
+    if (!Struct.isInstance(instance)) {
         throw new TypeError('Can not serialize, not a struct instance');
     }
-    const { options, members } = instance.constructor[metadata];
+    const { options, members } = instance.constructor[Struct.metadata];
     const buffer = new Uint8Array(sizeof(instance));
     const view = new DataView(buffer.buffer);
     for (const [name, { type, length, offset }] of members) {
         for (let i = 0; i < (length || 1); i++) {
             const iOff = offset + sizeof(type) * i;
+            // @ts-expect-error 7053
             let value = length > 0 ? instance[name][i] : instance[name];
             if (typeof value == 'string') {
                 value = value.charCodeAt(0);
             }
-            if (!isPrimitiveType(type)) {
+            if (!primitive.isType(type)) {
                 buffer.set(value ? serialize(value) : new Uint8Array(sizeof(type)), iOff);
                 continue;
             }
@@ -129,21 +114,24 @@ export function serialize(instance) {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance, _buffer) {
-    if (!isInstance(instance)) {
+    if (!Struct.isInstance(instance)) {
         throw new TypeError('Can not deserialize, not a struct instance');
     }
-    const { options, members } = instance.constructor[metadata];
+    const { options, members } = instance.constructor[Struct.metadata];
     const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
     const view = new DataView(buffer.buffer);
     for (const [name, { type, offset, length }] of members) {
         for (let i = 0; i < (length || 1); i++) {
+            // @ts-expect-error 7053
             let object = length > 0 ? instance[name] : instance;
             const key = length > 0 ? i : name, iOff = offset + sizeof(type) * i;
+            // @ts-expect-error 7053
             if (typeof instance[name] == 'string') {
+                // @ts-expect-error 7053
                 instance[name] = instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
                 continue;
             }
-            if (!isPrimitiveType(type)) {
+            if (!primitive.isType(type)) {
                 if (object[key] === null || object[key] === undefined) {
                     continue;
                 }
@@ -168,17 +156,17 @@ export function deserialize(instance, _buffer) {
     }
 }
 function _member(type) {
-    function decorator(targetOrLength, context) {
+    function _(targetOrLength, context) {
         if (typeof targetOrLength == 'number') {
             return member(type, targetOrLength);
         }
         return member(type)(targetOrLength, context);
     }
-    return decorator;
+    return _;
 }
 /**
  * Shortcut types
  *
  * Instead of writing `@member(type)` you can write `@types.type`, or `@types.type(length)` for arrays
  */
-export const types = Object.fromEntries(validPrimitiveTypes.map(t => [t, _member(t)]));
+export const types = Object.fromEntries(primitive.valids.map(t => [t, _member(t)]));

package/dist/types.d.ts

@@ -71,54 +71,45 @@ export type Empty = [];
 /**
  * Removes the first element of T and shifts
  */
-export type Shift<T> = T extends unknown[] ? (((...x: T) => void) extends (h: any, ...t: infer I) => void ? I : []) : unknown;
+export type Shift<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest : never;
 /**
  * Gets the first element of T
  */
-export type First<T> = T extends unknown[] ? (((...x: T) => void) extends (h: infer I, ...t: any) => void ? I : []) : never;
+export type First<T extends unknown[]> = T extends [infer F, ...unknown[]] ? F : never;
 /**
- * Inserts A into T at the start of T
+ * Inserts V into T at the start of T
  */
-export type Unshift<T, A> = T extends unknown[] ? (((h: A, ...t: T) => void) extends (...i: infer I) => void ? I : unknown) : never;
+export type Unshift<T extends unknown[], V> = [V, ...T];
 /**
  * Removes the last element of T
  */
-export type Pop<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer I, any]) => void ? I : unknown) : never;
+export type Pop<T extends unknown[]> = T extends [...infer _, unknown] ? _ : never;
 /**
  * Gets the last element of T
  */
-export type Last<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer H, infer I]) => void ? I : unknown) : never;
+export type Last<T extends unknown[]> = T extends [...unknown[], infer Last] ? Last : never;
 /**
- * Appends A to T
+ * Appends V to T
  */
-export type Push<T, A> = T extends unknown[] ? (((...a: [...T, A]) => void) extends (...i: infer I) => void ? I : unknown) : never;
+export type Push<T extends unknown[], V> = [...T, V];
 /**
  * Concats A and B
  */
-export type Concat<A, B> = {
-    0: A;
-    1: Concat<Unshift<A, 0>, Shift<B>>;
-}[Empty extends B ? 0 : 1];
+export type Concat<A extends unknown[], B extends unknown[]> = Empty extends B ? A : Concat<Unshift<A, 0>, Shift<B>>;
 /**
  * Extracts from A what is not B
  *
  * @remarks
  * It does not remove duplicates (so Remove\<[0, 0, 0], [0, 0]\> yields [0]). This is intended and necessary behavior.
  */
-export type Remove<A, B> = {
-    0: A;
-    1: Remove<Shift<A>, Shift<B>>;
-}[Empty extends B ? 0 : 1];
+export type Remove<A extends unknown[], B extends unknown[]> = Empty extends B ? A : Remove<Shift<A>, Shift<B>>;
 /**
  * The length of T
  */
-export type Length<T> = T extends {
+export type Length<T extends {
     length: number;
-} ? T['length'] : never;
-type _FromLength<N extends number, R = Empty> = {
-    0: R;
-    1: _FromLength<N, Unshift<R, 0>>;
-}[Length<R> extends N ? 0 : 1];
+}> = T['length'];
+type _FromLength<N extends number, R extends unknown[] = Empty> = Length<R> extends N ? R : _FromLength<N, Unshift<R, 0>>;
 /**
  * Creates a tuple of length N
  */
@@ -175,4 +166,19 @@ export type OptionalTuple<T extends unknown[]> = T extends [infer Head, ...infer
  */
 export type MapKeys<T> = T extends Map<infer K, any> ? K : never;
 export type ClassLike<Instance = unknown> = abstract new (...args: unknown[]) => Instance;
+/**
+ * Converts a union to an intersection
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Gets the last element of a union
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+/**
+ * Converts a union to a tuple
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type UnionToTuple<T, L = LastOfUnion<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.3.3",
+	"version": "0.4.0",
 	"description": "Typescript utilies",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/internal/primitives.ts

@@ -0,0 +1,32 @@
+import { capitalize } from '../string.js';
+
+type BitsToBytes = {
+	'8': 1;
+	'16': 2;
+	'32': 4;
+	'64': 8;
+};
+
+export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? (bits extends keyof BitsToBytes ? BitsToBytes[bits] : never) : never;
+export type Type = `${'int' | 'uint'}${8 | 16 | 32 | 64}` | `float${32 | 64}`;
+export type Valid = Type | Capitalize<Type> | 'char';
+
+export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'] satisfies Type[];
+
+export const valids = [...types, ...types.map(t => capitalize(t)), 'char'] satisfies Valid[];
+
+export const regex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
+
+export type Normalize<T extends Valid> = T extends 'char' ? 'uint8' : Uncapitalize<T>;
+
+export function normalize<T extends Valid>(type: T): Normalize<T> {
+	return (type == 'char' ? 'uint8' : type.toLowerCase()) as Normalize<T>;
+}
+
+export function isType(type: { toString(): string }): type is Type {
+	return regex.test(type.toString());
+}
+
+export function isValid(type: { toString(): string }): type is Valid {
+	return type == 'char' || regex.test(type.toString().toLowerCase());
+}

package/src/internal/struct.ts

@@ -0,0 +1,71 @@
+import { ClassLike } from '../types.js';
+import * as primitive from './primitives.js';
+
+export interface MemberInit {
+	name: string;
+	type: string | ClassLike;
+	length?: number;
+}
+
+export const init = Symbol('struct_init');
+
+export type init = typeof init;
+
+/**
+ * Options for struct initialization
+ */
+export interface Options {
+	align: number;
+	bigEndian: boolean;
+}
+
+export interface Member {
+	type: primitive.Type | Static;
+	offset: number;
+	length?: number;
+}
+
+export interface Metadata {
+	options: Partial<Options>;
+	members: Map<string, Member>;
+	size: number;
+}
+
+export const metadata = Symbol('struct');
+
+export type metadata = typeof metadata;
+
+export interface Static<T extends Metadata = Metadata> {
+	[metadata]: T;
+	new (): Instance;
+	prototype: Instance;
+}
+
+export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
+	[metadata]?: T;
+	[init]?: MemberInit[];
+}
+
+export function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T> {
+	return typeof arg == 'function' && metadata in arg;
+}
+
+export interface Instance<T extends Metadata = Metadata> {
+	constructor: Static<T>;
+}
+
+export interface InstanceLike<T extends Metadata = Metadata> {
+	constructor: StaticLike<T>;
+}
+
+export function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> {
+	return metadata in (arg?.constructor || {});
+}
+
+export function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T> {
+	return isInstance(arg) || isStatic(arg);
+}
+
+export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
+
+export type Size<T extends primitive.Valid | StaticLike | InstanceLike> = T extends primitive.Valid ? primitive.Size<T> : T extends Like<infer M> ? M['size'] : number;

package/src/objects.ts

@@ -1,4 +1,5 @@
 import type * as FS from 'fs';
+import { UnionToTuple } from './types.js';
 
 export function filterObject<O extends object, R extends object>(object: O, predicate: (key: keyof O, value: O[keyof O]) => boolean): R {
 	const entries = <[keyof O, O[keyof O]][]>Object.entries(object);
@@ -18,11 +19,11 @@ export function pick<T extends object, K extends keyof T>(object: T, ...keys: re
 export function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Omit<T, K>;
 export function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Omit<T, K>;
 export function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly K[] | readonly (readonly K[])[]): Omit<T, K> {
-	return filterObject<T, Omit<T, K>>(object, (key: K) => !keys.flat().includes(key));
+	return filterObject<T, Omit<T, K>>(object, key => !keys.flat().includes(key as K));
 }
 
-export function assignWithDefaults<To extends object, From extends object>(to: To, from: From, defaults: Partial<To> = to): void {
-	const keys = new Set([...Object.keys(to), ...Object.keys(from)]);
+export function assignWithDefaults<To extends Record<keyof any, any>, From extends Partial<To>>(to: To, from: From, defaults: Partial<To> = to): void {
+	const keys = new Set<keyof To | keyof From>([...Object.keys(to), ...Object.keys(from)]);
 	for (const key of keys) {
 		try {
 			to[key] = from[key] ?? defaults[key] ?? to[key];
@@ -32,6 +33,11 @@ export function assignWithDefaults<To extends object, From extends object>(to: T
 	}
 }
 
+/**
+ * Entries of T
+ */
+export type Entries<T extends object> = UnionToTuple<{ [K in keyof T]: [K, T[K]] }[keyof T]>;
+
 export function isJSON(str: string) {
 	try {
 		JSON.parse(str);
@@ -184,7 +190,7 @@ export interface FolderMapOptions {
 	 */
 	suffix: string;
 
-	fs?: typeof FS;
+	fs: typeof FS;
 }
 
 /**
@@ -199,14 +205,14 @@ export class FolderMap extends FileMap<string> {
 		path: string,
 		public readonly options: Partial<FolderMapOptions>
 	) {
-		super(path, options.fs);
+		super(path, options.fs!);
 	}
 
 	protected get _names(): string[] {
 		return this.fs
 			.readdirSync(this.path)
-			.filter(p => p.endsWith(this.options.suffix))
-			.map(p => p.slice(0, -this.options.suffix.length));
+			.filter(p => p.endsWith(this.options.suffix || ''))
+			.map(p => p.slice(0, -this.options.suffix!.length));
 	}
 
 	protected _join(path: string): string {
@@ -214,7 +220,7 @@ export class FolderMap extends FileMap<string> {
 	}
 
 	protected get _map(): Map<string, string> {
-		const entries = [];
+		const entries: [string, string][] = [];
 		for (const name of this._names) {
 			const content = this.fs.readFileSync(this._join(name), 'utf8');
 			entries.push([name, content]);
@@ -238,9 +244,10 @@ export class FolderMap extends FileMap<string> {
 	}
 
 	public get(key: string): string {
-		if (this.has(key)) {
-			return this.fs.readFileSync(this._join(key), 'utf8');
+		if (!this.has(key)) {
+			throw new ReferenceError('Key not found');
 		}
+		return this.fs.readFileSync(this._join(key), 'utf8');
 	}
 
 	public has(key: string): boolean {
@@ -262,12 +269,3 @@ export function resolveConstructors(object: object): string[] {
 	}
 	return constructors;
 }
-
-/**
- * Gets a random int, r, with the probability P(r) = (base)**r
- * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
- * @param probability the probability
- */
-export function getRandomIntWithRecursiveProbability(probability = 0.5): number {
-	return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
-}

package/src/random.ts

@@ -25,3 +25,12 @@ export function randomBinaryString(length = 1): string {
 export function randomInt(min = 0, max = 1): number {
 	return Math.round(Math.random() * (max - min) + min);
 }
+
+/**
+ * Gets a random int, r, with the probability P(r) = (base)**r
+ * For example, with a probability of 1/2: P(1) = 1/2, P(2) = 1/4, etc.
+ * @param probability the probability
+ */
+export function getRandomIntWithRecursiveProbability(probability = 0.5): number {
+	return -Math.floor(Math.log(Math.random()) / Math.log(1 / probability));
+}

package/src/string.ts

@@ -1,7 +1,17 @@
 export function capitalize<T extends string>(value: T): Capitalize<T> {
-	return <Capitalize<T>>(value.at(0).toUpperCase() + value.slice(1));
+	return <Capitalize<T>>(value.at(0)!.toUpperCase() + value.slice(1));
 }
 
 export function uncapitalize<T extends string>(value: T): Uncapitalize<T> {
-	return <Uncapitalize<T>>(value.at(0).toLowerCase() + value.slice(1));
+	return <Uncapitalize<T>>(value.at(0)!.toLowerCase() + value.slice(1));
 }
+
+export type ConcatString<T extends string[]> = T extends [infer F extends string, ...infer R extends string[]] ? `${F}${ConcatString<R>}` : '';
+
+export type Join<T extends string[], S extends string = ','> = T extends [infer F extends string, ...infer R extends string[]]
+	? `${F}${R extends [] ? '' : `${S}${Join<R, S>}`}`
+	: '';
+
+export type Whitespace = ' ' | '\t';
+
+export type Trim<T extends string> = T extends `${Whitespace}${infer R extends string}` ? Trim<R> : T;

package/src/struct.ts

@@ -1,98 +1,29 @@
+import * as Struct from './internal/struct.js';
 import { capitalize } from './string.js';
 import { ClassLike } from './types.js';
-
-export type PrimitiveType = `${'int' | 'uint'}${8 | 16 | 32 | 64}` | `float${32 | 64}`;
-export type ValidPrimitiveType = PrimitiveType | Capitalize<PrimitiveType> | 'char';
-
-const primitiveTypes = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'] satisfies PrimitiveType[];
-
-const validPrimitiveTypes = [...primitiveTypes, ...primitiveTypes.map(t => capitalize(t)), 'char'] satisfies ValidPrimitiveType[];
-
-const numberRegex = /^(u?int)(8|16|32|64)|(float)(32|64)$/i;
-
-function normalizePrimitive(type: ValidPrimitiveType): PrimitiveType {
-	return type == 'char' ? 'uint8' : <PrimitiveType>type.toLowerCase();
-}
-
-function isPrimitiveType(type: unknown): type is PrimitiveType {
-	return numberRegex.test(type.toString());
-}
-
-function isValidPrimitive(type: unknown): type is ValidPrimitiveType {
-	return type == 'char' || numberRegex.test(type.toString().toLowerCase());
-}
-
-interface MemberInit {
-	name: string;
-	type: string | ClassLike;
-	length?: number;
-}
-
-const init = Symbol('struct_init');
-
-/**
- * Options for struct initialization
- */
-export interface StructOptions {
-	align: number;
-	bigEndian: boolean;
-}
-
-interface Member {
-	type: PrimitiveType | Static;
-	offset: number;
-	length?: number;
-}
-
-interface Metadata {
-	options: Partial<StructOptions>;
-	members: Map<string, Member>;
-	size: number;
-}
-
-const metadata = Symbol('struct');
-
-interface Static {
-	[metadata]?: Metadata;
-	new (): Instance;
-	prototype: Instance;
-}
-
-function isStatic(arg: unknown): arg is Static {
-	return typeof arg == 'function' && metadata in arg;
-}
-
-interface Instance {
-	constructor: Static;
-}
-
-function isInstance(arg: unknown): arg is Instance {
-	return metadata in (arg?.constructor || {});
-}
-
-function isStruct(arg: unknown): arg is Instance | Static {
-	return isInstance(arg) || isStatic(arg);
-}
+import * as primitive from './internal/primitives.js';
+export { Struct };
 
 /**
  * Gets the size in bytes of a type
  */
-export function sizeof(type: ValidPrimitiveType | ClassLike | object): number {
+export function sizeof<T extends primitive.Valid | Struct.StaticLike | Struct.InstanceLike>(type: T): Struct.Size<T> {
 	// primitive
 	if (typeof type == 'string') {
-		if (!isValidPrimitive(type)) {
+		if (!primitive.isValid(type)) {
 			throw new TypeError('Invalid primitive type: ' + type);
 		}
 
-		return +normalizePrimitive(type).match(numberRegex)[2] / 8;
+		return (+primitive.normalize(type).match(primitive.regex)![2] / 8) as Struct.Size<T>;
 	}
 
-	if (!isStruct(type)) {
+	if (!Struct.isStruct(type)) {
 		throw new TypeError('Not a struct');
 	}
 
-	const meta: Metadata = metadata in type ? type[metadata] : type.constructor[metadata];
-	return meta.size;
+	const meta: Struct.Metadata = Struct.isStatic(type) ? type[Struct.metadata] : type.constructor[Struct.metadata];
+
+	return meta.size as Struct.Size<T>;
 }
 
 /**
@@ -105,41 +36,45 @@ export function align(value: number, alignment: number): number {
 /**
  * Decorates a class as a struct
  */
-export function struct(options: Partial<StructOptions> = {}) {
+export function struct(options: Partial<Struct.Options> = {}) {
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	return function (target: ClassLike, _?: ClassDecoratorContext) {
-		target[init] ||= [];
+	return function (target: Struct.StaticLike, _?: ClassDecoratorContext) {
+		target[Struct.init] ||= [];
 		let size = 0;
 		const members = new Map();
-		for (const { name, type, length } of target[init] as MemberInit[]) {
-			if (!isValidPrimitive(type) && !isStatic(type)) {
+		for (const { name, type, length } of target[Struct.init]) {
+			if (!primitive.isValid(type) && !Struct.isStatic(type)) {
 				throw new TypeError('Not a valid type: ' + type);
 			}
 			members.set(name, {
 				offset: size,
-				type: isValidPrimitive(type) ? normalizePrimitive(type) : type,
+				type: primitive.isValid(type) ? primitive.normalize(type) : type,
 				length,
 			});
 			size += sizeof(type) * (length || 1);
 			size = align(size, options.align || 1);
 		}
 
-		target[metadata] = { options, members, size } satisfies Metadata;
-		delete target[init];
+		target[Struct.metadata] = { options, members, size } satisfies Struct.Metadata;
 	};
 }
 
 /**
  * Decorates a class member to be serialized
  */
-export function member(type: ValidPrimitiveType | ClassLike, length?: number) {
-	return function (target: object, { name }: ClassMemberDecoratorContext) {
+export function member(type: primitive.Valid | ClassLike, length?: number) {
+	return function (target: object, context?: ClassMemberDecoratorContext | string | symbol) {
+		let name = typeof context == 'object' ? context.name : context;
 		if (typeof name == 'symbol') {
 			console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
 			name = name.toString();
 		}
 
-		if (typeof target != 'object' || typeof target != 'function') {
+		if (!name) {
+			throw new ReferenceError('Invalid name for struct member');
+		}
+
+		if (typeof target != 'object') {
 			throw new TypeError('Invalid member for struct field');
 		}
 
@@ -147,8 +82,10 @@ export function member(type: ValidPrimitiveType | ClassLike, length?: number) {
 			throw new TypeError('Invalid member for struct field');
 		}
 
-		target.constructor[init] ||= [];
-		target.constructor[init].push({ name, type, length } satisfies MemberInit);
+		const struct = (target as Struct.InstanceLike).constructor;
+
+		struct[Struct.init] ||= [];
+		struct[Struct.init].push({ name, type, length } satisfies Struct.MemberInit);
 	};
 }
 
@@ -156,10 +93,10 @@ export function member(type: ValidPrimitiveType | ClassLike, length?: number) {
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance: unknown): Uint8Array {
-	if (!isInstance(instance)) {
+	if (!Struct.isInstance(instance)) {
 		throw new TypeError('Can not serialize, not a struct instance');
 	}
-	const { options, members } = instance.constructor[metadata];
+	const { options, members } = instance.constructor[Struct.metadata];
 
 	const buffer = new Uint8Array(sizeof(instance));
 	const view = new DataView(buffer.buffer);
@@ -168,12 +105,13 @@ export function serialize(instance: unknown): Uint8Array {
 		for (let i = 0; i < (length || 1); i++) {
 			const iOff = offset + sizeof(type) * i;
 
-			let value = length > 0 ? instance[name][i] : instance[name];
+			// @ts-expect-error 7053
+			let value = length! > 0 ? instance[name][i] : instance[name];
 			if (typeof value == 'string') {
 				value = value.charCodeAt(0);
 			}
 
-			if (!isPrimitiveType(type)) {
+			if (!primitive.isType(type)) {
 				buffer.set(value ? serialize(value) : new Uint8Array(sizeof(type)), iOff);
 				continue;
 			}
@@ -201,10 +139,10 @@ export function serialize(instance: unknown): Uint8Array {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBufferView) {
-	if (!isInstance(instance)) {
+	if (!Struct.isInstance(instance)) {
 		throw new TypeError('Can not deserialize, not a struct instance');
 	}
-	const { options, members } = instance.constructor[metadata];
+	const { options, members } = instance.constructor[Struct.metadata];
 
 	const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
 
@@ -212,16 +150,19 @@ export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBuffe
 
 	for (const [name, { type, offset, length }] of members) {
 		for (let i = 0; i < (length || 1); i++) {
-			let object = length > 0 ? instance[name] : instance;
-			const key = length > 0 ? i : name,
+			// @ts-expect-error 7053
+			let object = length! > 0 ? instance[name] : instance;
+			const key = length! > 0 ? i : name,
 				iOff = offset + sizeof(type) * i;
 
+			// @ts-expect-error 7053
 			if (typeof instance[name] == 'string') {
+				// @ts-expect-error 7053
 				instance[name] = instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
 				continue;
 			}
 
-			if (!isPrimitiveType(type)) {
+			if (!primitive.isType(type)) {
 				if (object[key] === null || object[key] === undefined) {
 					continue;
 				}
@@ -229,7 +170,7 @@ export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBuffe
 				continue;
 			}
 
-			if (length > 0) {
+			if (length! > 0) {
 				object ||= [];
 			}
 
@@ -250,17 +191,22 @@ export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBuffe
 	}
 }
 
-function _member<T extends ValidPrimitiveType>(type: T) {
-	function decorator(length?: number): (target: object, context: ClassMemberDecoratorContext) => void;
-	function decorator(target: object, context: ClassMemberDecoratorContext): void;
-	function decorator(targetOrLength: object | number, context?: ClassMemberDecoratorContext) {
+/**
+ * Also can be a name when legacy decorators are used
+ */
+type Context = string | symbol | ClassMemberDecoratorContext;
+
+function _member<T extends primitive.Valid>(type: T) {
+	function _(length: number): (target: object, context?: Context) => void;
+	function _(target: object, context?: Context): void;
+	function _(targetOrLength: object | number, context?: Context) {
 		if (typeof targetOrLength == 'number') {
 			return member(type, targetOrLength);
 		}
 
 		return member(type)(targetOrLength, context);
 	}
-	return decorator;
+	return _;
 }
 
 /**
@@ -268,4 +214,4 @@ function _member<T extends ValidPrimitiveType>(type: T) {
  *
  * Instead of writing `@member(type)` you can write `@types.type`, or `@types.type(length)` for arrays
  */
-export const types = Object.fromEntries(validPrimitiveTypes.map(t => [t, _member(t)])) as { [K in ValidPrimitiveType]: ReturnType<typeof _member<K>> };
+export const types = Object.fromEntries(primitive.valids.map(t => [t, _member(t)])) as { [K in primitive.Valid]: ReturnType<typeof _member<K>> };

package/src/types.ts

@@ -85,37 +85,37 @@ export type Empty = [];
 /**
  * Removes the first element of T and shifts
  */
-export type Shift<T> = T extends unknown[] ? (((...x: T) => void) extends (h: any, ...t: infer I) => void ? I : []) : unknown;
+export type Shift<T extends unknown[]> = T extends [unknown, ...infer Rest] ? Rest : never;
 
 /**
  * Gets the first element of T
  */
-export type First<T> = T extends unknown[] ? (((...x: T) => void) extends (h: infer I, ...t: any) => void ? I : []) : never;
+export type First<T extends unknown[]> = T extends [infer F, ...unknown[]] ? F : never;
 
 /**
- * Inserts A into T at the start of T
+ * Inserts V into T at the start of T
  */
-export type Unshift<T, A> = T extends unknown[] ? (((h: A, ...t: T) => void) extends (...i: infer I) => void ? I : unknown) : never;
+export type Unshift<T extends unknown[], V> = [V, ...T];
 
 /**
  * Removes the last element of T
  */
-export type Pop<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer I, any]) => void ? I : unknown) : never;
+export type Pop<T extends unknown[]> = T extends [...infer _, unknown] ? _ : never;
 
 /**
  * Gets the last element of T
  */
-export type Last<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer H, infer I]) => void ? I : unknown) : never;
+export type Last<T extends unknown[]> = T extends [...unknown[], infer Last] ? Last : never;
 
 /**
- * Appends A to T
+ * Appends V to T
  */
-export type Push<T, A> = T extends unknown[] ? (((...a: [...T, A]) => void) extends (...i: infer I) => void ? I : unknown) : never;
+export type Push<T extends unknown[], V> = [...T, V];
 
 /**
  * Concats A and B
  */
-export type Concat<A, B> = { 0: A; 1: Concat<Unshift<A, 0>, Shift<B>> }[Empty extends B ? 0 : 1];
+export type Concat<A extends unknown[], B extends unknown[]> = Empty extends B ? A : Concat<Unshift<A, 0>, Shift<B>>;
 
 /**
  * Extracts from A what is not B
@@ -123,14 +123,14 @@ export type Concat<A, B> = { 0: A; 1: Concat<Unshift<A, 0>, Shift<B>> }[Empty ex
  * @remarks
  * It does not remove duplicates (so Remove\<[0, 0, 0], [0, 0]\> yields [0]). This is intended and necessary behavior.
  */
-export type Remove<A, B> = { 0: A; 1: Remove<Shift<A>, Shift<B>> }[Empty extends B ? 0 : 1];
+export type Remove<A extends unknown[], B extends unknown[]> = Empty extends B ? A : Remove<Shift<A>, Shift<B>>;
 
 /**
  * The length of T
  */
-export type Length<T> = T extends { length: number } ? T['length'] : never;
+export type Length<T extends { length: number }> = T['length'];
 
-type _FromLength<N extends number, R = Empty> = { 0: R; 1: _FromLength<N, Unshift<R, 0>> }[Length<R> extends N ? 0 : 1];
+type _FromLength<N extends number, R extends unknown[] = Empty> = Length<R> extends N ? R : _FromLength<N, Unshift<R, 0>>;
 
 /**
  * Creates a tuple of length N
@@ -202,3 +202,21 @@ export type OptionalTuple<T extends unknown[]> = T extends [infer Head, ...infer
 export type MapKeys<T> = T extends Map<infer K, any> ? K : never;
 
 export type ClassLike<Instance = unknown> = abstract new (...args: unknown[]) => Instance;
+
+/**
+ * Converts a union to an intersection
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+/**
+ * Gets the last element of a union
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+
+/**
+ * Converts a union to a tuple
+ * @see https://stackoverflow.com/a/55128956/17637456
+ */
+export type UnionToTuple<T, L = LastOfUnion<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;