utilium 1.10.0 → 2.0.0-pre.1

package/dist/buffer.d.ts

@@ -1,5 +1,6 @@
+import type { Mutable } from './objects.js';
 /**
- * A generic ArrayBufferView (typed array) constructor
+ * A generic constructor for an `ArrayBufferView`
  */
 export interface ArrayBufferViewConstructor {
     readonly prototype: ArrayBufferView<ArrayBufferLike>;
@@ -8,9 +9,347 @@ export interface ArrayBufferViewConstructor {
     new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): ArrayBufferView<TArrayBuffer>;
     new (array: ArrayLike<number> | ArrayBuffer): ArrayBufferView<ArrayBuffer>;
 }
+/**
+ * A generic typed array.
+ */
+export interface TypedArray<TArrayBuffer extends ArrayBufferLike = ArrayBuffer, TValue = number | bigint> extends ArrayBufferView<TArrayBuffer> {
+    /**
+     * The size in bytes of each element in the array.
+     */
+    readonly BYTES_PER_ELEMENT: number;
+    /**
+     * Returns the this object after copying a section of the array identified by start and end
+     * to the same array starting at position target
+     * @param target If target is negative, it is treated as length+target where length is the
+     * length of the array.
+     * @param start If start is negative, it is treated as length+start. If end is negative, it
+     * is treated as length+end.
+     * @param end If not specified, length of the this object is used as its default value.
+     */
+    copyWithin(target: number, start: number, end?: number): this;
+    /**
+     * Determines whether all the members of an array satisfy the specified test.
+     * @param predicate A function that accepts up to three arguments. The every method calls
+     * the predicate function for each element in the array until the predicate returns a value
+     * which is coercible to the Boolean value false, or until the end of the array.
+     * @param thisArg An object to which the this keyword can refer in the predicate function.
+     * If thisArg is omitted, undefined is used as the this value.
+     */
+    every(predicate: (value: TValue, index: number, array: this) => unknown, thisArg?: any): boolean;
+    /**
+     * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array
+     * @param value value to fill array section with
+     * @param start index to start filling the array at. If start is negative, it is treated as
+     * length+start where length is the length of the array.
+     * @param end index to stop filling the array at. If end is negative, it is treated as
+     * length+end.
+     */
+    fill(value: TValue, start?: number, end?: number): this;
+    /**
+     * Returns the elements of an array that meet the condition specified in a callback function.
+     * @param predicate A function that accepts up to three arguments. The filter method calls
+     * the predicate function one time for each element in the array.
+     * @param thisArg An object to which the this keyword can refer in the predicate function.
+     * If thisArg is omitted, undefined is used as the this value.
+     */
+    filter(predicate: (value: TValue, index: number, array: this) => any, thisArg?: any): TypedArray<TArrayBuffer, TValue>;
+    /**
+     * Returns the value of the first element in the array where predicate is true, and undefined
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found, find
+     * immediately returns that element value. Otherwise, find returns undefined.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    find(predicate: (value: TValue, index: number, obj: this) => boolean, thisArg?: any): TValue | undefined;
+    /**
+     * Returns the index of the first element in the array where predicate is true, and -1
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found,
+     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    findIndex(predicate: (value: TValue, index: number, obj: this) => boolean, thisArg?: any): number;
+    /**
+     * Performs the specified action for each element in an array.
+     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
+     * callbackfn function one time for each element in the array.
+     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
+     * If thisArg is omitted, undefined is used as the this value.
+     */
+    forEach(callbackfn: (value: TValue, index: number, array: this) => void, thisArg?: any): void;
+    /**
+     * Returns the index of the first occurrence of a value in an array.
+     * @param searchElement The value to locate in the array.
+     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
+     *  search starts at index 0.
+     */
+    indexOf(searchElement: TValue, fromIndex?: number): number;
+    /**
+     * Adds all the elements of an array separated by the specified separator string.
+     * @param separator A string used to separate one element of an array from the next in the
+     * resulting String. If omitted, the array elements are separated with a comma.
+     */
+    join(separator?: string): string;
+    /**
+     * Returns the index of the last occurrence of a value in an array.
+     * @param searchElement The value to locate in the array.
+     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
+     * search starts at index 0.
+     */
+    lastIndexOf(searchElement: TValue, fromIndex?: number): number;
+    /**
+     * The length of the array.
+     */
+    readonly length: number;
+    /**
+     * Calls a defined callback function on each element of an array, and returns an array that
+     * contains the results.
+     * @param callbackfn A function that accepts up to three arguments. The map method calls the
+     * callbackfn function one time for each element in the array.
+     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+     * If thisArg is omitted, undefined is used as the this value.
+     */
+    map(callbackfn: (value: TValue, index: number, array: this) => TValue, thisArg?: any): TypedArray<TArrayBuffer, TValue>;
+    /**
+     * Calls the specified callback function for all the elements in an array. The return value of
+     * the callback function is the accumulated result, and is provided as an argument in the next
+     * call to the callback function.
+     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
+     * callbackfn function one time for each element in the array.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start
+     * the accumulation. The first call to the callbackfn function provides this value as an argument
+     * instead of an array value.
+     */
+    reduce(callbackfn: (previousValue: TValue, currentValue: TValue, currentIndex: number, array: this) => number): number;
+    reduce(callbackfn: (previousValue: TValue, currentValue: TValue, currentIndex: number, array: this) => number, initialValue: number): number;
+    /**
+     * Calls the specified callback function for all the elements in an array. The return value of
+     * the callback function is the accumulated result, and is provided as an argument in the next
+     * call to the callback function.
+     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
+     * callbackfn function one time for each element in the array.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start
+     * the accumulation. The first call to the callbackfn function provides this value as an argument
+     * instead of an array value.
+     */
+    reduce<U>(callbackfn: (previousValue: U, currentValue: TValue, currentIndex: number, array: this) => U, initialValue: U): U;
+    /**
+     * Calls the specified callback function for all the elements in an array, in descending order.
+     * The return value of the callback function is the accumulated result, and is provided as an
+     * argument in the next call to the callback function.
+     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
+     * the callbackfn function one time for each element in the array.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start
+     * the accumulation. The first call to the callbackfn function provides this value as an
+     * argument instead of an array value.
+     */
+    reduceRight(callbackfn: (previousValue: TValue, currentValue: TValue, currentIndex: number, array: this) => number): number;
+    reduceRight(callbackfn: (previousValue: TValue, currentValue: TValue, currentIndex: number, array: this) => number, initialValue: number): number;
+    /**
+     * Calls the specified callback function for all the elements in an array, in descending order.
+     * The return value of the callback function is the accumulated result, and is provided as an
+     * argument in the next call to the callback function.
+     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
+     * the callbackfn function one time for each element in the array.
+     * @param initialValue If initialValue is specified, it is used as the initial value to start
+     * the accumulation. The first call to the callbackfn function provides this value as an argument
+     * instead of an array value.
+     */
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: TValue, currentIndex: TValue, array: this) => U, initialValue: U): U;
+    /**
+     * Reverses the elements in an Array.
+     */
+    reverse(): this;
+    /**
+     * Sets a value or an array of values.
+     * @param array A typed or untyped array of values to set.
+     * @param offset The index in the current array at which the values are to be written.
+     */
+    set(array: ArrayLike<TValue>, offset?: number): void;
+    /**
+     * Returns a section of an array.
+     * @param start The beginning of the specified portion of the array.
+     * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
+     */
+    slice(start?: number, end?: number): TypedArray<TArrayBuffer, TValue>;
+    /**
+     * Determines whether the specified callback function returns true for any element of an array.
+     * @param predicate A function that accepts up to three arguments. The some method calls
+     * the predicate function for each element in the array until the predicate returns a value
+     * which is coercible to the Boolean value true, or until the end of the array.
+     * @param thisArg An object to which the this keyword can refer in the predicate function.
+     * If thisArg is omitted, undefined is used as the this value.
+     */
+    some(predicate: (value: TValue, index: number, array: this) => unknown, thisArg?: any): boolean;
+    /**
+     * Sorts an array.
+     * @param compareFn Function used to determine the order of the elements. It is expected to return
+     * a negative value if first argument is less than second argument, zero if they're equal and a positive
+     * value otherwise. If omitted, the elements are sorted in ascending order.
+     * ```ts
+     * [11,2,22,1].sort((a, b) => a - b)
+     * ```
+     */
+    sort(compareFn?: (a: TValue, b: TValue) => number): this;
+    /**
+     * Gets a new Int8Array view of the ArrayBuffer store for this array, referencing the elements
+     * at begin, inclusive, up to end, exclusive.
+     * @param begin The index of the beginning of the array.
+     * @param end The index of the end of the array.
+     */
+    subarray(begin?: number, end?: number): TypedArray<TArrayBuffer, TValue>;
+    /**
+     * Converts a number to a string by using the current locale.
+     */
+    toLocaleString(): string;
+    /**
+     * Returns a string representation of an array.
+     */
+    toString(): string;
+    /** Returns the primitive value of the specified object. */
+    valueOf(): this;
+    [index: number]: TValue;
+}
+export interface TypedArrayConstructor {
+    readonly prototype: TypedArray<ArrayBufferLike>;
+    new (length: number): TypedArray<ArrayBuffer>;
+    new (array: ArrayLike<number>): TypedArray<ArrayBuffer>;
+    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): TypedArray<TArrayBuffer>;
+    new (array: ArrayLike<number> | ArrayBuffer): TypedArray<ArrayBuffer>;
+    readonly BYTES_PER_ELEMENT: number;
+}
 /**
  * Grows a buffer if it isn't large enough
  * @returns The original buffer if resized successfully, or a newly created buffer
  */
 export declare function extendBuffer<T extends ArrayBufferLike | ArrayBufferView>(buffer: T, newByteLength: number): T;
 export declare function toUint8Array(buffer: ArrayBufferLike | ArrayBufferView): Uint8Array;
+export declare function initView<T extends ArrayBufferLike = ArrayBuffer>(view: Mutable<ArrayBufferView<T> & {
+    BYTES_PER_ELEMENT?: number;
+}>, buffer?: T | ArrayBufferView<T> | ArrayLike<number> | number, byteOffset?: number, byteLength?: number): void;
+/** Creates a view of an array buffer */
+export declare class BufferView<T extends ArrayBufferLike = ArrayBufferLike> implements ArrayBufferView<T> {
+    readonly buffer: T;
+    readonly byteOffset: number;
+    readonly byteLength: number;
+    constructor(buffer?: T | ArrayBufferView<T> | ArrayLike<number>, byteOffset?: number, byteLength?: number);
+}
+/** Creates an array of a buffer view type */
+export declare function BufferViewArray<T extends ArrayBufferViewConstructor>(element: T, size: number): {
+    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer?: TArrayBuffer | ArrayBufferView<TArrayBuffer> | ArrayLike<number>, byteOffset?: number, byteLength?: number): {
+        [n: number]: any;
+        readonly BYTES_PER_ELEMENT: number;
+        readonly buffer: TArrayBuffer;
+        readonly byteOffset: number;
+        readonly byteLength: number;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+        pop(): any;
+        push(...items: any[]): number;
+        concat(...items: ConcatArray<any>[]): any[];
+        concat(...items: any[]): any[];
+        join(separator?: string): string;
+        reverse(): any[];
+        shift(): any;
+        slice(start?: number, end?: number): any[];
+        sort(compareFn?: ((a: any, b: any) => number) | undefined): /*elided*/ any;
+        splice(start: number, deleteCount?: number): any[];
+        splice(start: number, deleteCount: number, ...items: any[]): any[];
+        unshift(...items: any[]): number;
+        indexOf(searchElement: any, fromIndex?: number): number;
+        lastIndexOf(searchElement: any, fromIndex?: number): number;
+        every<S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any): U[];
+        filter<S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S[];
+        filter(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any[];
+        reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+        reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+        reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any;
+        reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any;
+        reduceRight<U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U;
+        find<S extends any>(predicate: (value: any, index: number, obj: any[]) => value is S, thisArg?: any): S | undefined;
+        find(predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any): any;
+        findIndex(predicate: (value: any, index: number, obj: any[]) => unknown, thisArg?: any): number;
+        fill(value: any, start?: number, end?: number): /*elided*/ any;
+        copyWithin(target: number, start: number, end?: number): /*elided*/ any;
+        entries(): ArrayIterator<[number, any]>;
+        keys(): ArrayIterator<number>;
+        values(): ArrayIterator<any>;
+        includes(searchElement: any, fromIndex?: number): boolean;
+        flatMap<U, This = undefined>(callback: (this: This, value: any, index: number, array: any[]) => U | readonly U[], thisArg?: This | undefined): U[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        at(index: number): any;
+        findLast<S extends any>(predicate: (value: any, index: number, array: any[]) => value is S, thisArg?: any): S | undefined;
+        findLast(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): any;
+        findLastIndex(predicate: (value: any, index: number, array: any[]) => unknown, thisArg?: any): number;
+        toReversed(): any[];
+        toSorted(compareFn?: ((a: any, b: any) => number) | undefined): any[];
+        toSpliced(start: number, deleteCount: number, ...items: any[]): any[];
+        toSpliced(start: number, deleteCount?: number): any[];
+        with(index: number, value: any): any[];
+        [Symbol.iterator](): ArrayIterator<any>;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    };
+    isArray(arg: any): arg is any[];
+    from<T_1>(arrayLike: ArrayLike<T_1>): T_1[];
+    from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    from<T_1>(iterable: Iterable<T_1> | ArrayLike<T_1>): T_1[];
+    from<T_1, U>(iterable: Iterable<T_1> | ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    of<T_1>(...items: T_1[]): T_1[];
+    fromAsync<T_1>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1 | PromiseLike<T_1>> | ArrayLike<T_1 | PromiseLike<T_1>>): Promise<T_1[]>;
+    fromAsync<T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+    readonly [Symbol.species]: ArrayConstructor;
+};

package/dist/buffer.js

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions */
+import { _throw } from './misc.js';
 /**
  * Grows a buffer if it isn't large enough
  * @returns The original buffer if resized successfully, or a newly created buffer
@@ -37,3 +38,60 @@ export function toUint8Array(buffer) {
         return new Uint8Array(buffer);
     return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 }
+export function initView(view, buffer, byteOffset, byteLength) {
+    if (typeof buffer == 'number') {
+        const per = view.BYTES_PER_ELEMENT ?? _throw('BYTES_PER_ELEMENT is not set');
+        view.buffer = new ArrayBuffer(buffer * per);
+        view.byteOffset = 0;
+        view.byteLength = buffer * per;
+        return;
+    }
+    if (!buffer
+        || buffer instanceof ArrayBuffer
+        || (globalThis.SharedArrayBuffer && buffer instanceof globalThis.SharedArrayBuffer)) {
+        const { staticSize = 0 } = view.constructor?.[Symbol.metadata]?.struct ?? {};
+        view.buffer = buffer ?? new ArrayBuffer(staticSize);
+        view.byteOffset = byteOffset ?? 0;
+        view.byteLength = byteLength ?? staticSize;
+        return;
+    }
+    if (ArrayBuffer.isView(buffer)) {
+        view.buffer = buffer.buffer;
+        view.byteOffset = buffer.byteOffset;
+        view.byteLength = buffer.byteLength;
+        return;
+    }
+    const array = buffer;
+    view.buffer = new ArrayBuffer(array.length);
+    view.byteOffset = 0;
+    view.byteLength = array.length;
+    const data = new Uint8Array(view.buffer);
+    for (let i = 0; i < array.length; i++) {
+        data[i] = array[i];
+    }
+}
+/** Creates a view of an array buffer */
+export class BufferView {
+    constructor(buffer, byteOffset, byteLength) {
+        initView(this, buffer, byteOffset, byteLength);
+    }
+}
+BufferView;
+/** Creates an array of a buffer view type */
+export function BufferViewArray(element, size) {
+    return class BufferViewArray extends Array {
+        BYTES_PER_ELEMENT = size;
+        constructor(buffer, byteOffset, byteLength) {
+            const t_size = size;
+            const length = (byteLength ?? t_size) / t_size;
+            if (!Number.isSafeInteger(length))
+                throw new Error('Invalid array length: ' + length);
+            super(length);
+            initView(this, buffer, byteOffset, byteLength);
+            for (let i = 0; i < length; i++) {
+                this[i] = new element(this.buffer, this.byteOffset + i * t_size, t_size);
+            }
+        }
+    };
+}
+BufferView;

package/dist/internal/primitives.d.ts

@@ -1,26 +1,99 @@
-type BitsToBytes = {
-    '8': 1;
-    '16': 2;
-    '32': 4;
-    '64': 8;
-    '128': 16;
+import type { ArrayBufferViewConstructor } from '../buffer.js';
+import type { UnionToTuple } from '../types.js';
+/** A definition for a primitive type */
+export interface Type<T = any> {
+    readonly name: string;
+    readonly size: number;
+    readonly array: ArrayBufferViewConstructor;
+    get(this: void, view: DataView, offset: number, littleEndian: boolean): T;
+    set(this: void, view: DataView, offset: number, littleEndian: boolean, value: T): void;
+}
+export declare function isType<T = any>(type: unknown): type is Type<T>;
+export declare const types: {
+    readonly int8: {
+        readonly name: "int8";
+        readonly size: 1;
+        readonly array: Int8ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, _le: boolean, value: any) => void;
+    };
+    readonly uint8: {
+        readonly name: "uint8";
+        readonly size: 1;
+        readonly array: Uint8ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, _le: boolean, value: any) => void;
+    };
+    readonly int16: {
+        readonly name: "int16";
+        readonly size: 2;
+        readonly array: Int16ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly uint16: {
+        readonly name: "uint16";
+        readonly size: 2;
+        readonly array: Uint16ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly int32: {
+        readonly name: "int32";
+        readonly size: 4;
+        readonly array: Int32ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly uint32: {
+        readonly name: "uint32";
+        readonly size: 4;
+        readonly array: Uint32ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly int64: {
+        readonly name: "int64";
+        readonly size: 8;
+        readonly array: BigInt64ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => bigint;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly uint64: {
+        readonly name: "uint64";
+        readonly size: 8;
+        readonly array: BigUint64ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => bigint;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly float32: {
+        readonly name: "float32";
+        readonly size: 4;
+        readonly array: Float32ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
+    readonly float64: {
+        readonly name: "float64";
+        readonly size: 8;
+        readonly array: Float64ArrayConstructor;
+        readonly get: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean) => number;
+        readonly set: (this: void, view: DataView<ArrayBufferLike>, offset: number, le: boolean, value: any) => void;
+    };
 };
-export type Size<T extends string> = T extends `${'int' | 'uint' | 'float'}${infer bits}` ? bits extends keyof BitsToBytes ? BitsToBytes[bits] : never : never;
-export declare const typeNames: readonly ["int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "int128", "uint128", "float32", "float64", "float128"];
-export type Typename = (typeof typeNames)[number];
-export type Valid = Typename | Capitalize<Typename> | 'char';
-export declare const validNames: ("int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "int128" | "uint128" | "float32" | "float64" | "float128" | "Int8" | "Uint8" | "Int16" | "Uint16" | "Int32" | "Uint32" | "Int64" | "Uint64" | "Int128" | "Uint128" | "Float32" | "Float64" | "Float128" | "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: {
+export type TypeName = keyof typeof types;
+export declare const typeNames: UnionToTuple<TypeName>;
+export declare function isTypeName(type: {
     toString(): string;
-}): type is Typename;
+}): type is TypeName;
+export type Valid = TypeName | Capitalize<TypeName> | 'char';
+export declare const validNames: ("int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64" | "float32" | "float64" | "Int8" | "Uint8" | "Int16" | "Uint16" | "Int32" | "Uint32" | "Int64" | "Uint64" | "Float32" | "Float64" | "char")[];
 export declare function isValid(type: {
     toString(): string;
 }): type is Valid;
 export declare function checkValid(type: {
     toString(): string;
 }): asserts type is Valid;
-export declare const mask64: bigint;
-export {};
+export type Normalize<T extends Valid> = (T extends 'char' ? 'uint8' : Uncapitalize<T>) & TypeName;
+export declare function normalize<T extends Valid>(type: T): Normalize<T>;
+export type Size<T extends Valid | Type> = (T extends Valid ? (typeof types)[Normalize<T>] : T)['size'];

package/dist/internal/primitives.js

@@ -1,33 +1,98 @@
 import { capitalize } from '../string.js';
-export const typeNames = [
-    'int8',
-    'uint8',
-    'int16',
-    'uint16',
-    'int32',
-    'uint32',
-    'int64',
-    'uint64',
-    'int128',
-    'uint128',
-    'float32',
-    'float64',
-    'float128',
-];
-export const validNames = [...typeNames, ...typeNames.map(t => capitalize(t)), 'char'];
-export const regex = /^(u?int|float)(8|16|32|64|128)$/i;
-export function normalize(type) {
-    return (type == 'char' ? 'uint8' : type.toLowerCase());
-}
 export function isType(type) {
-    return regex.test(type.toString());
+    return (typeof type == 'object'
+        && type != null
+        && 'size' in type
+        && 'get' in type
+        && 'set' in type
+        && typeof type.size == 'number'
+        && typeof type.get == 'function'
+        && typeof type.set == 'function');
+}
+export const types = {
+    int8: {
+        name: 'int8',
+        size: 1,
+        array: Int8Array,
+        get: (view, offset) => view.getInt8(offset),
+        set: (view, offset, _le, value) => view.setInt8(offset, value),
+    },
+    uint8: {
+        name: 'uint8',
+        size: 1,
+        array: Uint8Array,
+        get: (view, offset) => view.getUint8(offset),
+        set: (view, offset, _le, value) => view.setUint8(offset, value),
+    },
+    int16: {
+        name: 'int16',
+        size: 2,
+        array: Int16Array,
+        get: (view, offset, le) => view.getInt16(offset, le),
+        set: (view, offset, le, value) => view.setInt16(offset, value, le),
+    },
+    uint16: {
+        name: 'uint16',
+        size: 2,
+        array: Uint16Array,
+        get: (view, offset, le) => view.getUint16(offset, le),
+        set: (view, offset, le, value) => view.setUint16(offset, value, le),
+    },
+    int32: {
+        name: 'int32',
+        size: 4,
+        array: Int32Array,
+        get: (view, offset, le) => view.getInt32(offset, le),
+        set: (view, offset, le, value) => view.setInt32(offset, value, le),
+    },
+    uint32: {
+        name: 'uint32',
+        size: 4,
+        array: Uint32Array,
+        get: (view, offset, le) => view.getUint32(offset, le),
+        set: (view, offset, le, value) => view.setUint32(offset, value, le),
+    },
+    int64: {
+        name: 'int64',
+        size: 8,
+        array: BigInt64Array,
+        get: (view, offset, le) => view.getBigInt64(offset, le),
+        set: (view, offset, le, value) => view.setBigInt64(offset, value, le),
+    },
+    uint64: {
+        name: 'uint64',
+        size: 8,
+        array: BigUint64Array,
+        get: (view, offset, le) => view.getBigUint64(offset, le),
+        set: (view, offset, le, value) => view.setBigUint64(offset, value, le),
+    },
+    float32: {
+        name: 'float32',
+        size: 4,
+        array: Float32Array,
+        get: (view, offset, le) => view.getFloat32(offset, le),
+        set: (view, offset, le, value) => view.setFloat32(offset, value, le),
+    },
+    float64: {
+        name: 'float64',
+        size: 8,
+        array: Float64Array,
+        get: (view, offset, le) => view.getFloat64(offset, le),
+        set: (view, offset, le, value) => view.setFloat64(offset, value, le),
+    },
+};
+export const typeNames = Object.keys(types);
+export function isTypeName(type) {
+    return typeNames.includes(type.toString());
 }
+export const validNames = [...typeNames, ...typeNames.map(t => capitalize(t)), 'char'];
 export function isValid(type) {
-    return type == 'char' || regex.test(type.toString().toLowerCase());
+    return validNames.includes(type.toString());
 }
 export function checkValid(type) {
-    if (!isValid(type)) {
+    if (!isValid(type))
         throw new TypeError('Not a valid primitive type: ' + type);
-    }
 }
-export const mask64 = BigInt('0xffffffffffffffff');
+export function normalize(type) {
+    return (type == 'char' ? 'uint8' : type.toLowerCase());
+}