utilium 1.3.1 → 1.3.3

package/dist/buffer.js

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unused-expressions */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
 /**
  * Grows a buffer if it isn't large enough
  * @returns The original buffer if resized successfully, or a newly created buffer

package/dist/debugging.js

@@ -15,7 +15,9 @@ function defaultStringify(value) {
             if (value === null)
                 return 'null';
             if (ArrayBuffer.isView(value)) {
-                const length = 'length' in value ? value.length : value.byteLength / value.constructor.BYTES_PER_ELEMENT;
+                const length = 'length' in value
+                    ? value.length
+                    : value.byteLength / value.constructor.BYTES_PER_ELEMENT;
                 return `${value.constructor.name.replaceAll('Array', '').toLowerCase()}[${length}]`;
             }
             if (Array.isArray(value))
@@ -33,7 +35,7 @@ function defaultStringify(value) {
  * Create a function that can be used to decorate classes and non-field members.
  */
 export function createLogDecorator(options) {
-    const { output = console.log, separator = '#', returnValue = false, stringify = defaultStringify, className = true } = options;
+    const { output = console.log, separator = '#', returnValue = false, stringify = defaultStringify, className = true, } = options;
     return function log(value, context) {
         if (context.kind == 'class') {
             return function (...args) {

package/dist/internal/primitives.d.ts

@@ -5,7 +5,7 @@ type BitsToBytes = {
     '64': 8;
     '128': 16;
 };
-export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? (bits extends keyof BitsToBytes ? BitsToBytes[bits] : never) : never;
+export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? bits extends keyof BitsToBytes ? BitsToBytes[bits] : never : never;
 export declare const types: readonly ["int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "int128", "uint128", "float32", "float64", "float128"];
 export type Type = (typeof types)[number];
 export type Valid = Type | Capitalize<Type> | 'char';

package/dist/internal/primitives.js

@@ -1,5 +1,19 @@
 import { capitalize } from '../string.js';
-export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'int128', 'uint128', 'float32', 'float64', 'float128'];
+export const types = [
+    'int8',
+    'uint8',
+    'int16',
+    'uint16',
+    'int32',
+    'uint32',
+    'int64',
+    'uint64',
+    'int128',
+    'uint128',
+    'float32',
+    'float64',
+    'float128',
+];
 export const valids = [...types, ...types.map(t => capitalize(t)), 'char'];
 export const regex = /^(u?int|float)(8|16|32|64|128)$/i;
 export function normalize(type) {

package/dist/internal/struct.d.ts

@@ -71,7 +71,7 @@ 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 checkInstance<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T>;
+export declare function checkInstance<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> & Record<keyof any, any>;
 export declare function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T>;
 export declare function checkStruct<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> | Static<T>;
 export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;

package/dist/internal/struct.js

@@ -44,14 +44,17 @@ export function symbol_metadata(arg) {
     return symbol_metadata;
 }
 export function isStatic(arg) {
-    return typeof arg == 'function' && symbol_metadata(arg) in arg && isValidMetadata(arg[symbol_metadata(arg)]);
+    return (typeof arg == 'function'
+        && symbol_metadata(arg) in arg
+        && isValidMetadata(arg[symbol_metadata(arg)]));
 }
 export function isInstance(arg) {
     return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
 export function checkInstance(arg) {
     if (!isInstance(arg)) {
-        throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg) + ' is not a struct instance');
+        throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
+            + ' is not a struct instance');
     }
 }
 export function isStruct(arg) {
@@ -59,6 +62,7 @@ export function isStruct(arg) {
 }
 export function checkStruct(arg) {
     if (!isStruct(arg)) {
-        throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg) + ' is not a struct');
+        throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
+            + ' is not a struct');
     }
 }

package/dist/objects.d.ts

@@ -19,6 +19,7 @@ export type Entries<T extends object> = ({
 }[keyof T] & unknown[])[];
 export declare function isJSON(str: string): boolean;
 export declare function resolveConstructors(object: object): string[];
+export declare function getAllPrototypes(object: object): IterableIterator<object>;
 /**
  * Allows you to convert an object with specific member types into a Map that will give you the correct type for the correct member
  */
@@ -32,3 +33,5 @@ export interface ConstMap<T extends Partial<Record<keyof any, any>>, K extends k
 export declare function map<const T extends Partial<Record<any, any>>>(items: T): Map<keyof T, T[keyof T]>;
 export declare function getByString(object: Record<string, any>, path: string, separator?: RegExp): Record<string, any>;
 export declare function setByString(object: Record<string, any>, path: string, value: unknown, separator?: RegExp): Record<string, any>;
+/** Binds a class member to the instance */
+export declare function bound(value: unknown, { name, addInitializer }: ClassMethodDecoratorContext): void;

package/dist/objects.js

@@ -18,7 +18,7 @@ export function assignWithDefaults(to, from, defaults = to) {
         try {
             to[key] = from[key] ?? defaults[key] ?? to[key];
         }
-        catch (e) {
+        catch {
             // Do nothing
         }
     }
@@ -28,19 +28,22 @@ export function isJSON(str) {
         JSON.parse(str);
         return true;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
 export function resolveConstructors(object) {
     const constructors = [];
-    let prototype = object;
-    while (prototype && !['Function', 'Object'].includes(prototype.constructor.name)) {
-        prototype = Object.getPrototypeOf(prototype);
+    for (let prototype = object; prototype && !['Function', 'Object'].includes(prototype.constructor.name); prototype = Object.getPrototypeOf(prototype)) {
         constructors.push(prototype.constructor.name);
     }
     return constructors;
 }
+export function* getAllPrototypes(object) {
+    for (let prototype = object; prototype; prototype = Object.getPrototypeOf(prototype)) {
+        yield prototype;
+    }
+}
 export function map(items) {
     return new Map(Object.entries(items));
 }
@@ -56,3 +59,11 @@ export function setByString(object, path, value, separator = /[.[\]'"]/) {
         .filter(p => p)
         .reduce((o, p, i) => (o[p] = path.split(separator).filter(p => p).length === ++i ? value : o[p] || {}), object);
 }
+/** Binds a class member to the instance */
+// eslint-disable-next-line @typescript-eslint/unbound-method
+export function bound(value, { name, addInitializer }) {
+    addInitializer(function () {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        this[name] = this[name].bind(this);
+    });
+}

package/dist/requests.js

@@ -42,7 +42,10 @@ export async function get(url, options, init = {}) {
         const { headers } = await fetch(req, { method: 'HEAD' });
         const size = parseInt(headers.get('Content-Length') ?? '');
         if (typeof size != 'number')
-            throw { tag: 'size', message: 'Response is missing content-length header and no size was provided' };
+            throw {
+                tag: 'size',
+                message: 'Response is missing content-length header and no size was provided',
+            };
         options.size = size;
     }
     const { size, start, end } = options;

package/dist/string.d.ts

@@ -1,6 +1,9 @@
 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 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.js

@@ -91,7 +91,6 @@ export function serialize(instance) {
     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);
@@ -139,13 +138,11 @@ export function deserialize(instance, _buffer) {
     const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     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);
+                instance[name] =
+                    instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
                 continue;
             }
             if (!primitive.isType(type)) {
@@ -169,14 +166,14 @@ export function deserialize(instance, _buffer) {
             }
             if (fn == 'getInt128') {
                 object[key] =
-                    (view.getBigInt64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64)) |
-                        view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+                    (view.getBigInt64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
+                        | view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
                 continue;
             }
             if (fn == 'getUint128') {
                 object[key] =
-                    (view.getBigUint64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64)) |
-                        view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+                    (view.getBigUint64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
+                        | view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
                 continue;
             }
             if (fn == 'getFloat128') {

package/dist/types.d.ts

@@ -147,7 +147,7 @@ export type IsTuple<T> = T extends [] ? false : T extends [infer _Head, ...infer
 /**
  * Flattens a tuple
  */
-export type FlattenTuple<A extends unknown[]> = A extends [infer U, ...infer Rest] ? (U extends unknown[] ? [...U, ...FlattenTuple<Rest>] : [U, ...FlattenTuple<Rest>]) : [];
+export type FlattenTuple<A extends unknown[]> = A extends [infer U, ...infer Rest] ? U extends unknown[] ? [...U, ...FlattenTuple<Rest>] : [U, ...FlattenTuple<Rest>] : [];
 /**
  * Flattens an array or tuple
  */

package/dist/version.d.ts

@@ -2,7 +2,7 @@ export type Sep = '_' | '-';
 export type Part = `${number}.${number}.${number}`;
 export type WithPre = `${Part}${Sep}${string}${Sep | '.'}${Part | number}`;
 export type Full = Part | WithPre;
-type Type<S extends string, Acc extends string = ''> = S extends `${infer First}${infer Rest}` ? (First extends Sep | '.' ? Acc : Type<Rest, `${Acc}${First}`>) : Acc;
+type Type<S extends string, Acc extends string = ''> = S extends `${infer First}${infer Rest}` ? First extends Sep | '.' ? Acc : Type<Rest, `${Acc}${First}`> : Acc;
 export type Parse<T extends Full, StripCore extends boolean> = T extends `${infer Core}${Sep}${infer Rest}` ? Rest extends `${infer U}` ? {
     full: T;
     core: Core;

package/dist/version.js

@@ -2,6 +2,8 @@ import { capitalize } from './string.js';
 export const regex = /^(?<core>\d+\.\d+\.\d+)(?:[-_](?<type>[^-_.]+)[-_.](?<pre>\d*(?:\.\d+)*))?/;
 export function parse(full, stripCore) {
     const { type, pre, core } = regex.exec(full).groups;
-    const display = type ? `${stripCore && core == '1.0.0' ? '' : core + ' '}${capitalize(type)}${pre ? ` ${pre}` : ''}` : core;
+    const display = type
+        ? `${stripCore && core == '1.0.0' ? '' : core + ' '}${capitalize(type)}${pre ? ` ${pre}` : ''}`
+        : core;
     return { full, core, pre, type, display };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "1.3.1",
+	"version": "1.3.3",
 	"description": "Typescript utilities",
 	"funding": {
 		"type": "individual",

package/src/buffer.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unused-expressions */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
 
 /**
  * A generic ArrayBufferView (typed array) constructor
@@ -7,7 +7,11 @@ export interface ArrayBufferViewConstructor {
 	readonly prototype: ArrayBufferView<ArrayBufferLike>;
 	new (length: number): ArrayBufferView<ArrayBuffer>;
 	new (array: ArrayLike<number>): ArrayBufferView<ArrayBuffer>;
-	new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): ArrayBufferView<TArrayBuffer>;
+	new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(
+		buffer: TArrayBuffer,
+		byteOffset?: number,
+		length?: number
+	): ArrayBufferView<TArrayBuffer>;
 	new (array: ArrayLike<number> | ArrayBuffer): ArrayBufferView<ArrayBuffer>;
 }
 

package/src/debugging.ts

@@ -40,7 +40,10 @@ function defaultStringify(value: unknown): string {
 		case 'object':
 			if (value === null) return 'null';
 			if (ArrayBuffer.isView(value)) {
-				const length = 'length' in value ? (value.length as number) : value.byteLength / (value.constructor as any).BYTES_PER_ELEMENT;
+				const length =
+					'length' in value
+						? (value.length as number)
+						: value.byteLength / (value.constructor as any).BYTES_PER_ELEMENT;
 				return `${value.constructor.name.replaceAll('Array', '').toLowerCase()}[${length}]`;
 			}
 			if (Array.isArray(value)) return `unknown[${value.length}]`;
@@ -60,7 +63,13 @@ type LoggableDecoratorContext = Exclude<DecoratorContext, ClassFieldDecoratorCon
  * Create a function that can be used to decorate classes and non-field members.
  */
 export function createLogDecorator(options: CreateLoggerOptions) {
-	const { output = console.log, separator = '#', returnValue = false, stringify = defaultStringify, className = true } = options;
+	const {
+		output = console.log,
+		separator = '#',
+		returnValue = false,
+		stringify = defaultStringify,
+		className = true,
+	} = options;
 
 	return function log<T extends (...args: any[]) => any>(value: T, context: LoggableDecoratorContext): T {
 		if (context.kind == 'class') {

package/src/fs.ts

@@ -51,7 +51,12 @@ export abstract class FileMap<V> implements Map<string, V> {
 
 export type JSONObject<Key extends string | number | symbol = string> = { [K in Key]: JSONValue };
 
-export type JSONValue<Key extends string | number | symbol = string> = string | number | boolean | JSONObject<Key> | Array<JSONValue>;
+export type JSONValue<Key extends string | number | symbol = string> =
+	| string
+	| number
+	| boolean
+	| JSONObject<Key>
+	| Array<JSONValue>;
 
 export interface JSONFileMapOptions {
 	/**

package/src/internal/primitives.ts

@@ -8,9 +8,27 @@ type BitsToBytes = {
 	'128': 16;
 };
 
-export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? (bits extends keyof BitsToBytes ? BitsToBytes[bits] : never) : never;
-
-export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'int128', 'uint128', 'float32', 'float64', 'float128'] as const;
+export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}`
+	? bits extends keyof BitsToBytes
+		? BitsToBytes[bits]
+		: never
+	: never;
+
+export const types = [
+	'int8',
+	'uint8',
+	'int16',
+	'uint16',
+	'int32',
+	'uint32',
+	'int64',
+	'uint64',
+	'int128',
+	'uint128',
+	'float32',
+	'float64',
+	'float128',
+] as const;
 
 export type Type = (typeof types)[number];
 

package/src/internal/struct.ts

@@ -107,7 +107,8 @@ export function _polyfill_contextMetadata(target: object): void {
  * Gets a reference to Symbol.metadata, even on platforms that do not expose it globally (like Node)
  */
 export function symbol_metadata(arg: ClassLike): typeof Symbol.metadata {
-	const symbol_metadata = Symbol.metadata || Object.getOwnPropertySymbols(arg).find(s => s.description == 'Symbol.metadata');
+	const symbol_metadata =
+		Symbol.metadata || Object.getOwnPropertySymbols(arg).find(s => s.description == 'Symbol.metadata');
 	_polyfill_contextMetadata(arg);
 	if (!symbol_metadata) {
 		throw new ReferenceError('Could not get a reference to Symbol.metadata');
@@ -117,7 +118,11 @@ export function symbol_metadata(arg: ClassLike): typeof Symbol.metadata {
 }
 
 export function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T> {
-	return typeof arg == 'function' && symbol_metadata(arg as ClassLike) in arg && isValidMetadata(arg[symbol_metadata(arg as ClassLike)]);
+	return (
+		typeof arg == 'function'
+		&& symbol_metadata(arg as ClassLike) in arg
+		&& isValidMetadata(arg[symbol_metadata(arg as ClassLike)])
+	);
 }
 
 export interface Instance<T extends Metadata = Metadata> {
@@ -132,9 +137,14 @@ export function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is
 	return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
 
-export function checkInstance<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> {
+export function checkInstance<T extends Metadata = Metadata>(
+	arg: unknown
+): asserts arg is Instance<T> & Record<keyof any, any> {
 	if (!isInstance(arg)) {
-		throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg) + ' is not a struct instance');
+		throw new TypeError(
+			(typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
+				+ ' is not a struct instance'
+		);
 	}
 }
 
@@ -144,10 +154,17 @@ export function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is In
 
 export function checkStruct<T extends Metadata = Metadata>(arg: unknown): asserts arg is Instance<T> | Static<T> {
 	if (!isStruct(arg)) {
-		throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg) + ' is not a struct');
+		throw new TypeError(
+			(typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
+				+ ' is not a struct'
+		);
 	}
 }
 
 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;
+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,13 +1,19 @@
 import type { 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 {
+export function filterObject<O extends object, R extends object>(
+	object: O,
+	predicate: (key: keyof O, value: O[keyof O]) => boolean
+): R {
 	const entries = Object.entries(object) as [keyof O, O[keyof O]][];
 	return Object.fromEntries(entries.filter(([key, value]) => predicate(key, value))) as R;
 }
 
 export function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Pick<T, K>;
 export function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Pick<T, K>;
-export function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly K[] | readonly (readonly K[])[]): Pick<T, K> {
+export function pick<T extends object, K extends keyof T>(
+	object: T,
+	...keys: readonly K[] | readonly (readonly K[])[]
+): Pick<T, K> {
 	const picked = {} as Pick<T, K>;
 	for (const key of keys.flat() as K[]) {
 		picked[key] = object[key];
@@ -17,16 +23,23 @@ 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> {
+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 => !keys.flat().includes(key as K));
 }
 
-export function assignWithDefaults<To extends Record<keyof any, any>, From extends Partial<To>>(to: To, from: From, defaults: Partial<To> = to): void {
+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];
-		} catch (e) {
+		} catch {
 			// Do nothing
 		}
 	}
@@ -35,7 +48,8 @@ export function assignWithDefaults<To extends Record<keyof any, any>, From exten
 /**
  * Entries of T
  */
-export type EntriesTuple<T extends object> = UnionToTuple<{ [K in keyof T]: [K, T[K]] }[keyof T]> & [unknown, unknown][];
+export type EntriesTuple<T extends object> = UnionToTuple<{ [K in keyof T]: [K, T[K]] }[keyof T]>
+	& [unknown, unknown][];
 
 /**
  * Entries of T
@@ -46,25 +60,34 @@ export function isJSON(str: string) {
 	try {
 		JSON.parse(str);
 		return true;
-	} catch (e) {
+	} catch {
 		return false;
 	}
 }
 
 export function resolveConstructors(object: object): string[] {
 	const constructors = [];
-	let prototype = object;
-	while (prototype && !['Function', 'Object'].includes(prototype.constructor.name)) {
-		prototype = Object.getPrototypeOf(prototype);
+	for (
+		let prototype = object;
+		prototype && !['Function', 'Object'].includes(prototype.constructor.name);
+		prototype = Object.getPrototypeOf(prototype)
+	) {
 		constructors.push(prototype.constructor.name);
 	}
 	return constructors;
 }
 
+export function* getAllPrototypes(object: object): IterableIterator<object> {
+	for (let prototype = object; prototype; prototype = Object.getPrototypeOf(prototype)) {
+		yield prototype;
+	}
+}
+
 /**
  * Allows you to convert an object with specific member types into a Map that will give you the correct type for the correct member
  */
-export interface ConstMap<T extends Partial<Record<keyof any, any>>, K extends keyof any = keyof T, V = T[keyof T]> extends Map<K, V> {
+export interface ConstMap<T extends Partial<Record<keyof any, any>>, K extends keyof any = keyof T, V = T[keyof T]>
+	extends Map<K, V> {
 	get<TK extends keyof T>(key: TK): T[TK];
 	get(key: K): V;
 	set<TK extends keyof T>(key: TK, value: T[TK]): this;
@@ -89,3 +112,12 @@ export function setByString(object: Record<string, any>, path: string, value: un
 		.filter(p => p)
 		.reduce((o, p, i) => (o[p] = path.split(separator).filter(p => p).length === ++i ? value : o[p] || {}), object);
 }
+
+/** Binds a class member to the instance */
+// eslint-disable-next-line @typescript-eslint/unbound-method
+export function bound(value: unknown, { name, addInitializer }: ClassMethodDecoratorContext) {
+	addInitializer(function (this: any) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+		this[name] = this[name].bind(this);
+	});
+}

package/src/requests.ts

@@ -22,7 +22,11 @@ export type CacheOptions = cache.Options;
  */
 export const resourcesCache = new Map<string, cache.Resource<string> | undefined>();
 
-export type Issue = { tag: 'status'; response: Response } | { tag: 'buffer'; response: Response; message: string } | { tag: 'fetch' | 'size'; message: string } | Error;
+export type Issue =
+	| { tag: 'status'; response: Response }
+	| { tag: 'buffer'; response: Response; message: string }
+	| { tag: 'fetch' | 'size'; message: string }
+	| Error;
 
 /**
  * @deprecated Use `Issue`
@@ -103,7 +107,11 @@ export async function get(url: string, options: GetOptions, init: RequestInit =
 
 		const { headers } = await fetch(req, { method: 'HEAD' });
 		const size = parseInt(headers.get('Content-Length') ?? '');
-		if (typeof size != 'number') throw { tag: 'size', message: 'Response is missing content-length header and no size was provided' } satisfies Issue;
+		if (typeof size != 'number')
+			throw {
+				tag: 'size',
+				message: 'Response is missing content-length header and no size was provided',
+			} satisfies Issue;
 		options.size = size;
 	}
 
@@ -171,7 +179,10 @@ export function getCached(url: string, options: GetOptions): { data?: Uint8Array
 
 			if (overlapStart >= overlapEnd) continue;
 
-			data.set(region.data.subarray(overlapStart - region.offset, overlapEnd - region.offset), overlapStart - start);
+			data.set(
+				region.data.subarray(overlapStart - region.offset, overlapEnd - region.offset),
+				overlapStart - start
+			);
 		}
 	}
 

package/src/string.ts

@@ -6,9 +6,14 @@ export function uncapitalize<T extends string>(value: T): Uncapitalize<T> {
 	return (value.at(0)!.toLowerCase() + value.slice(1)) as Uncapitalize<T>;
 }
 
-export type ConcatString<T extends string[]> = T extends [infer F extends string, ...infer R extends string[]] ? `${F}${ConcatString<R>}` : '';
+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[]]
+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>}`}`
 	: '';
 

package/src/struct.ts

@@ -1,5 +1,14 @@
 import * as primitive from './internal/primitives.js';
-import type { DecoratorContext, InstanceLike, Member, MemberInit, Metadata, Options, Size, StaticLike } from './internal/struct.js';
+import type {
+	DecoratorContext,
+	InstanceLike,
+	Member,
+	MemberInit,
+	Metadata,
+	Options,
+	Size,
+	StaticLike,
+} from './internal/struct.js';
 import { checkInstance, checkStruct, isStatic, symbol_metadata, type MemberContext } from './internal/struct.js';
 import { capitalize } from './string.js';
 import type { ClassLike } from './types.js';
@@ -48,7 +57,10 @@ export function align(value: number, alignment: number): number {
  * Decorates a class as a struct
  */
 export function struct(options: Partial<Options> = {}) {
-	return function _decorateStruct<const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext): T {
+	return function _decorateStruct<const T extends StaticLike>(
+		target: T,
+		context: ClassDecoratorContext & DecoratorContext
+	): T {
 		context.metadata ??= {};
 		context.metadata[Symbol.struct_init] ||= [];
 		let size = 0;
@@ -110,7 +122,6 @@ export function serialize(instance: unknown): Uint8Array {
 		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);
@@ -165,21 +176,20 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 	checkInstance(instance);
 	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][Symbol.struct_metadata];
 
-	const buffer = _buffer instanceof Uint8Array ? _buffer : new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
+	const buffer =
+		_buffer instanceof Uint8Array ? _buffer : new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
 
 	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 
 	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);
+				instance[name] =
+					instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
 				continue;
 			}
 
@@ -208,15 +218,15 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 
 			if (fn == 'getInt128') {
 				object[key] =
-					(view.getBigInt64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64)) |
-					view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+					(view.getBigInt64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
+					| view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
 				continue;
 			}
 
 			if (fn == 'getUint128') {
 				object[key] =
-					(view.getBigUint64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64)) |
-					view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+					(view.getBigUint64(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
+					| view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
 				continue;
 			}
 
@@ -233,7 +243,10 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 function _member<T extends primitive.Valid>(type: T) {
 	function _structMemberDecorator<const V>(length: number): (value: V, context: MemberContext) => V;
 	function _structMemberDecorator<const V>(value: V, context: MemberContext): V;
-	function _structMemberDecorator<const V>(valueOrLength: V | number, context?: MemberContext): V | ((value: V, context: MemberContext) => V) {
+	function _structMemberDecorator<const V>(
+		valueOrLength: V | number,
+		context?: MemberContext
+	): V | ((value: V, context: MemberContext) => V) {
 		if (typeof valueOrLength == 'number') {
 			return member(type, valueOrLength);
 		}
@@ -248,4 +261,6 @@ function _member<T extends primitive.Valid>(type: T) {
  *
  * Instead of writing `@member(type)` you can write `@types.type`, or `@types.type(length)` for arrays
  */
-export const types = Object.fromEntries(primitive.valids.map(t => [t, _member(t)])) as { [K in primitive.Valid]: 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

@@ -2,7 +2,11 @@
  * Expands the type T (for intellisense and debugging)
  * @see https://stackoverflow.com/a/69288824/17637456
  */
-export type Expand<T> = T extends (...args: infer A) => infer R ? (...args: Expand<A>) => Expand<R> : T extends infer O ? { [K in keyof O]: O[K] } : never;
+export type Expand<T> = T extends (...args: infer A) => infer R
+	? (...args: Expand<A>) => Expand<R>
+	: T extends infer O
+		? { [K in keyof O]: O[K] }
+		: never;
 
 /**
  * Recursivly expands the type T (for intellisense and debugging)
@@ -52,14 +56,22 @@ export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
  * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
  */
 export type NestedKeys<T extends object> = {
-	[P in keyof T & (string | number)]: T[P] extends Date ? `${P}` : T[P] extends Record<string, unknown> ? `${P}` | `${P}.${NestedKeys<T[P]>}` : `${P}`;
+	[P in keyof T & (string | number)]: T[P] extends Date
+		? `${P}`
+		: T[P] extends Record<string, unknown>
+			? `${P}` | `${P}.${NestedKeys<T[P]>}`
+			: `${P}`;
 }[keyof T & (string | number)];
 
 /**
  * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
  */
 export type PartialRecursive<T> = {
-	[P in keyof T]?: T[P] extends (infer U)[] ? PartialRecursive<U>[] : T[P] extends object | undefined ? PartialRecursive<T[P]> : T[P];
+	[P in keyof T]?: T[P] extends (infer U)[]
+		? PartialRecursive<U>[]
+		: T[P] extends object | undefined
+			? PartialRecursive<T[P]>
+			: T[P];
 };
 
 /**
@@ -68,7 +80,9 @@ export type PartialRecursive<T> = {
  */
 export type UnionKeys<T> = T extends T ? keyof T : never;
 
-type StrictUnionHelper<T, TAll> = T extends unknown ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+type StrictUnionHelper<T, TAll> = T extends unknown
+	? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>>
+	: never;
 
 /**
  * @see https://stackoverflow.com/a/65805753/17637456
@@ -130,7 +144,8 @@ export type Remove<A extends unknown[], B extends unknown[]> = Empty extends B ?
  */
 export type Length<T extends { length: number }> = T['length'];
 
-type _FromLength<N extends number, R extends unknown[] = Empty> = Length<R> extends N ? R : _FromLength<N, Unshift<R, 0>>;
+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
@@ -162,12 +177,20 @@ export type Subtract<A extends number, B extends number> = Length<Remove<_FromLe
 /**
  * Gets the type of an array's members
  */
-export type Member<T, D = null> = D extends 0 ? T : T extends (infer U)[] ? Member<U, D extends number ? Decrement<D> : null> : T;
+export type Member<T, D = null> = D extends 0
+	? T
+	: T extends (infer U)[]
+		? Member<U, D extends number ? Decrement<D> : null>
+		: T;
 
 /**
  * Flattens an array
  */
-export type FlattenArray<A extends unknown[], D = null> = A extends (infer U)[] ? Member<Exclude<U, A>, D>[] : A extends unknown[] ? { [K in keyof A]: Member<A[K], D> } : A;
+export type FlattenArray<A extends unknown[], D = null> = A extends (infer U)[]
+	? Member<Exclude<U, A>, D>[]
+	: A extends unknown[]
+		? { [K in keyof A]: Member<A[K], D> }
+		: A;
 
 /**
  * Whether T is a tuple
@@ -178,7 +201,11 @@ export type IsTuple<T> = T extends [] ? false : T extends [infer _Head, ...infer
 /**
  * Flattens a tuple
  */
-export type FlattenTuple<A extends unknown[]> = A extends [infer U, ...infer Rest] ? (U extends unknown[] ? [...U, ...FlattenTuple<Rest>] : [U, ...FlattenTuple<Rest>]) : [];
+export type FlattenTuple<A extends unknown[]> = A extends [infer U, ...infer Rest]
+	? U extends unknown[]
+		? [...U, ...FlattenTuple<Rest>]
+		: [U, ...FlattenTuple<Rest>]
+	: [];
 
 /**
  * Flattens an array or tuple
@@ -195,7 +222,9 @@ export type Tuple<T, N extends number> = _Tuple<T, N>;
 /**
  * Makes all members of the tuple T optional
  */
-export type OptionalTuple<T extends unknown[]> = T extends [infer Head, ...infer Tail] ? [Head?, ...OptionalTuple<Tail>] : T;
+export type OptionalTuple<T extends unknown[]> = T extends [infer Head, ...infer Tail]
+	? [Head?, ...OptionalTuple<Tail>]
+	: T;
 
 /**
  * Keys of a Map
@@ -220,7 +249,9 @@ export type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : 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 type UnionToTuple<T, L = LastOfUnion<T>, N = [T] extends [never] ? true : false> = true extends N
+	? []
+	: Push<UnionToTuple<Exclude<T, L>>, L>;
 
 /**
  * Makes properties with keys assignable to K in T required

package/src/version.ts

@@ -8,7 +8,11 @@ export type WithPre = `${Part}${Sep}${string}${Sep | '.'}${Part | number}`;
 
 export type Full = Part | WithPre;
 
-type Type<S extends string, Acc extends string = ''> = S extends `${infer First}${infer Rest}` ? (First extends Sep | '.' ? Acc : Type<Rest, `${Acc}${First}`>) : Acc;
+type Type<S extends string, Acc extends string = ''> = S extends `${infer First}${infer Rest}`
+	? First extends Sep | '.'
+		? Acc
+		: Type<Rest, `${Acc}${First}`>
+	: Acc;
 
 export type Parse<T extends Full, StripCore extends boolean> = T extends `${infer Core}${Sep}${infer Rest}`
 	? Rest extends `${infer U}`
@@ -43,6 +47,8 @@ export function parse<const T extends Full>(full: T): Parse<T, false>;
 export function parse<const T extends Full, const S extends boolean>(full: T, stripCore: S): Parse<T, S>;
 export function parse<const T extends Full, const S extends boolean>(full: T, stripCore?: S): Parse<T, S> {
 	const { type, pre, core } = regex.exec(full)!.groups!;
-	const display = type ? `${stripCore && core == '1.0.0' ? '' : core + ' '}${capitalize(type)}${pre ? ` ${pre}` : ''}` : core;
+	const display = type
+		? `${stripCore && core == '1.0.0' ? '' : core + ' '}${capitalize(type)}${pre ? ` ${pre}` : ''}`
+		: core;
 	return { full, core, pre, type, display } as Parse<T, S>;
 }