utilium 1.2.10 → 1.3.1

package/dist/checksum.d.ts

@@ -0,0 +1,5 @@
+/** Utilities for computing checksums */
+/**
+ * Computes the CRC32C checksum of a Uint8Array.
+ */
+export declare function crc32c(data: Uint8Array): number;

package/dist/checksum.js

@@ -0,0 +1,20 @@
+/** Utilities for computing checksums */
+// Precompute CRC32C table
+const crc32cTable = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+    let value = i;
+    for (let j = 0; j < 8; j++) {
+        value = value & 1 ? 0x82f63b78 ^ (value >>> 1) : value >>> 1;
+    }
+    crc32cTable[i] = value;
+}
+/**
+ * Computes the CRC32C checksum of a Uint8Array.
+ */
+export function crc32c(data) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc = (crc >>> 8) ^ crc32cTable[(crc ^ data[i]) & 0xff];
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

package/dist/internal/primitives.d.ts

@@ -3,12 +3,13 @@ type BitsToBytes = {
     '16': 2;
     '32': 4;
     '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 Type = `${'int' | 'uint'}${8 | 16 | 32 | 64}` | `float${32 | 64}`;
+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';
-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 valids: ("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>;
@@ -21,4 +22,5 @@ export declare function isValid(type: {
 export declare function checkValid(type: {
     toString(): string;
 }): asserts type is Valid;
+export declare const mask64: bigint;
 export {};

package/dist/internal/primitives.js

@@ -1,7 +1,7 @@
 import { capitalize } from '../string.js';
-export const types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64'];
+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)$/i;
+export const regex = /^(u?int|float)(8|16|32|64|128)$/i;
 export function normalize(type) {
     return (type == 'char' ? 'uint8' : type.toLowerCase());
 }
@@ -16,3 +16,4 @@ export function checkValid(type) {
         throw new TypeError('Not a valid primitive type: ' + type);
     }
 }
+export const mask64 = BigInt('0xffffffffffffffff');

package/dist/struct.d.ts

@@ -7,6 +7,10 @@ export * as Struct from './internal/struct.js';
  * Gets the size in bytes of a type
  */
 export declare function sizeof<T extends primitive.Valid | StaticLike | InstanceLike>(type: T): Size<T>;
+/**
+ * Returns the offset (in bytes) of a member in a struct.
+ */
+export declare function offsetof(type: StaticLike | InstanceLike, memberName: string): number;
 /**
  * Aligns a number
  */

package/dist/struct.js

@@ -15,6 +15,18 @@ export function sizeof(type) {
     const struct = isStatic(type) ? type : type.constructor;
     return struct[symbol_metadata(struct)][Symbol.struct_metadata].size;
 }
+/**
+ * Returns the offset (in bytes) of a member in a struct.
+ */
+export function offsetof(type, memberName) {
+    checkStruct(type);
+    const struct = isStatic(type) ? type : type.constructor;
+    const metadata = struct[symbol_metadata(struct)][Symbol.struct_metadata];
+    const member = metadata.members.get(memberName);
+    if (!member)
+        throw new Error('Struct does not have member: ' + memberName);
+    return member.offset;
+}
 /**
  * Aligns a number
  */
@@ -88,8 +100,7 @@ export function serialize(instance) {
                 buffer.set(value ? serialize(value) : new Uint8Array(sizeof(type)), iOff);
                 continue;
             }
-            const Type = capitalize(type);
-            const fn = ('set' + Type);
+            const fn = `set${capitalize(type)}`;
             if (fn == 'setInt64') {
                 view.setBigInt64(iOff, BigInt(value), !options.bigEndian);
                 continue;
@@ -98,6 +109,21 @@ export function serialize(instance) {
                 view.setBigUint64(iOff, BigInt(value), !options.bigEndian);
                 continue;
             }
+            if (fn == 'setInt128') {
+                view.setBigUint64(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
+                view.setBigInt64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+                continue;
+            }
+            if (fn == 'setUint128') {
+                view.setBigUint64(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
+                view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+                continue;
+            }
+            if (fn == 'setFloat128') {
+                view.setFloat64(iOff + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
+                view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
+                continue;
+            }
             view[fn](iOff, Number(value), !options.bigEndian);
         }
     }
@@ -132,8 +158,7 @@ export function deserialize(instance, _buffer) {
             if (length > 0) {
                 object ||= [];
             }
-            const Type = capitalize(type);
-            const fn = ('get' + Type);
+            const fn = `get${capitalize(type)}`;
             if (fn == 'getInt64') {
                 object[key] = view.getBigInt64(iOff, !options.bigEndian);
                 continue;
@@ -142,6 +167,22 @@ export function deserialize(instance, _buffer) {
                 object[key] = view.getBigUint64(iOff, !options.bigEndian);
                 continue;
             }
+            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);
+                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);
+                continue;
+            }
+            if (fn == 'getFloat128') {
+                object[key] = view.getFloat64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+                continue;
+            }
             object[key] = view[fn](iOff, !options.bigEndian);
         }
     }

package/package.json

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

package/src/checksum.ts

@@ -0,0 +1,22 @@
+/** Utilities for computing checksums */
+
+// Precompute CRC32C table
+const crc32cTable = new Uint32Array(256);
+for (let i = 0; i < 256; i++) {
+	let value = i;
+	for (let j = 0; j < 8; j++) {
+		value = value & 1 ? 0x82f63b78 ^ (value >>> 1) : value >>> 1;
+	}
+	crc32cTable[i] = value;
+}
+
+/**
+ * Computes the CRC32C checksum of a Uint8Array.
+ */
+export function crc32c(data: Uint8Array): number {
+	let crc = 0xffffffff;
+	for (let i = 0; i < data.length; i++) {
+		crc = (crc >>> 8) ^ crc32cTable[(crc ^ data[i]) & 0xff];
+	}
+	return (crc ^ 0xffffffff) >>> 0;
+}

package/src/internal/primitives.ts

@@ -5,17 +5,20 @@ type BitsToBytes = {
 	'16': 2;
 	'32': 4;
 	'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 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 types = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'int128', 'uint128', 'float32', 'float64', 'float128'] as const;
+
+export type Type = (typeof types)[number];
+
+export type Valid = Type | Capitalize<Type> | 'char';
 
 export const valids = [...types, ...types.map(t => capitalize(t)), 'char'] satisfies Valid[];
 
-export const regex = /^(u?int|float)(8|16|32|64)$/i;
+export const regex = /^(u?int|float)(8|16|32|64|128)$/i;
 
 export type Normalize<T extends Valid> = T extends 'char' ? 'uint8' : Uncapitalize<T>;
 
@@ -36,3 +39,5 @@ export function checkValid(type: { toString(): string }): asserts type is Valid
 		throw new TypeError('Not a valid primitive type: ' + type);
 	}
 }
+
+export const mask64 = BigInt('0xffffffffffffffff');

package/src/struct.ts

@@ -23,6 +23,20 @@ export function sizeof<T extends primitive.Valid | StaticLike | InstanceLike>(ty
 	return struct[symbol_metadata(struct)][Symbol.struct_metadata].size as Size<T>;
 }
 
+/**
+ * Returns the offset (in bytes) of a member in a struct.
+ */
+export function offsetof(type: StaticLike | InstanceLike, memberName: string): number {
+	checkStruct(type);
+
+	const struct = isStatic(type) ? type : type.constructor;
+	const metadata = struct[symbol_metadata(struct)][Symbol.struct_metadata];
+
+	const member = metadata.members.get(memberName);
+	if (!member) throw new Error('Struct does not have member: ' + memberName);
+	return member.offset;
+}
+
 /**
  * Aligns a number
  */
@@ -107,8 +121,8 @@ export function serialize(instance: unknown): Uint8Array {
 				continue;
 			}
 
-			const Type = capitalize(type);
-			const fn = ('set' + Type) as `set${typeof Type}`;
+			const fn = `set${capitalize(type)}` as const;
+
 			if (fn == 'setInt64') {
 				view.setBigInt64(iOff, BigInt(value), !options.bigEndian);
 				continue;
@@ -119,6 +133,24 @@ export function serialize(instance: unknown): Uint8Array {
 				continue;
 			}
 
+			if (fn == 'setInt128') {
+				view.setBigUint64(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
+				view.setBigInt64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+				continue;
+			}
+
+			if (fn == 'setUint128') {
+				view.setBigUint64(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
+				view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+				continue;
+			}
+
+			if (fn == 'setFloat128') {
+				view.setFloat64(iOff + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
+				view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
+				continue;
+			}
+
 			view[fn](iOff, Number(value), !options.bigEndian);
 		}
 	}
@@ -163,8 +195,7 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 				object ||= [];
 			}
 
-			const Type = capitalize(type);
-			const fn = ('get' + Type) as `get${typeof Type}`;
+			const fn = `get${capitalize(type)}` as const;
 			if (fn == 'getInt64') {
 				object[key] = view.getBigInt64(iOff, !options.bigEndian);
 				continue;
@@ -175,6 +206,25 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 				continue;
 			}
 
+			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);
+				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);
+				continue;
+			}
+
+			if (fn == 'getFloat128') {
+				object[key] = view.getFloat64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+				continue;
+			}
+
 			object[key] = view[fn](iOff, !options.bigEndian);
 		}
 	}