utilium 1.10.0 → 2.0.0-pre.1

package/dist/internal/struct.d.ts

@@ -1,38 +1,26 @@
 import type { ClassLike } from '../types.js';
 import type * as primitive from './primitives.js';
-declare global {
-    interface SymbolConstructor {
-        readonly size: unique symbol;
-        readonly serialize: unique symbol;
-        readonly deserialize: unique symbol;
-    }
-}
-export type TypeLike = Custom | Like | primitive.Valid | undefined | null;
-export type Type = Custom | Static | primitive.Typename;
-/**
- * Member initialization data
- * This is needed since class decorators are called *after* member decorators
- */
-export interface MemberInit {
-    name: string;
-    type: string | ClassLike;
-    length?: number | string;
-}
+export type TypeLike = primitive.Type | Like | primitive.Valid | undefined | null;
+export type Type = Static | primitive.Type;
 /**
  * Options for struct initialization
  */
 export interface Options {
+    packed: boolean;
     align: number;
-    bigEndian: boolean;
     isUnion: boolean;
 }
 export interface Member {
     name: string;
     type: Type;
-    staticOffset: number;
+    offset: number;
+    /** The size of the member, 0 for dynamically sized arrays */
+    size: number;
     length?: number | string;
     /** A C-style type/name declaration string, used for diagnostics */
     decl: string;
+    /** Whether the member is little endian */
+    littleEndian: boolean;
 }
 export interface Metadata {
     options: Partial<Options>;
@@ -43,9 +31,15 @@ export interface Metadata {
     /** Whether the struct is a union */
     isUnion: boolean;
 }
+export interface Init {
+    members: Member[];
+    size: number;
+    isDynamic: boolean;
+    isUnion: boolean;
+}
 type _DecoratorMetadata<T extends Metadata = Metadata> = DecoratorMetadata & {
     struct?: T;
-    structInit?: MemberInit[];
+    structInit?: Init;
 };
 export interface DecoratorContext<T extends Metadata = Metadata> {
     metadata: _DecoratorMetadata<T>;
@@ -54,30 +48,21 @@ export interface DecoratorContext<T extends Metadata = Metadata> {
  * Initializes the struct metadata for a class
  * This also handles copying metadata from parent classes
  */
-export declare function initMetadata(context: DecoratorContext): MemberInit[];
-export type MemberContext = ClassMemberDecoratorContext & DecoratorContext;
+export declare function initMetadata(context: DecoratorContext): Init;
 export interface Static<T extends Metadata = Metadata> {
-    [Symbol.metadata]: {
-        struct: T;
-    };
-    new (): Instance<T>;
-    prototype: Instance<T>;
+    [Symbol.metadata]: Required<_DecoratorMetadata<T>>;
+    readonly prototype: Instance<T>;
+    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): Instance<T> & ArrayBufferView<TArrayBuffer>;
+    new (array?: ArrayLike<number> | ArrayBuffer): Instance<T>;
 }
 export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
     [Symbol.metadata]?: _DecoratorMetadata<T> | null;
-    new (): unknown;
 }
 export declare function isValidMetadata<T extends Metadata = Metadata>(arg: unknown): arg is DecoratorMetadata & {
     struct: T;
 };
-/**
- * Polyfill context.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- * @internal @hidden
- */
-export declare function _polyfill_metadata(target: object): void;
 export declare function isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T>;
-export interface Instance<T extends Metadata = Metadata> {
+export interface Instance<T extends Metadata = Metadata> extends ArrayBufferView, Record<PropertyKey, any> {
     constructor: Static<T>;
 }
 export interface InstanceLike<T extends Metadata = Metadata> {
@@ -87,17 +72,6 @@ export declare function isInstance<T extends Metadata = Metadata>(arg: unknown):
 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>;
-/**
- * A "custom" type, which can be used to implement non-builtin size, serialization, and deserialization
- */
-export interface Custom {
-    readonly [Symbol.size]: number;
-    [Symbol.serialize]?(): Uint8Array;
-    [Symbol.deserialize]?(value: Uint8Array): void;
-}
-export declare function isCustom(arg: unknown): arg is Custom;
 export type Like<T extends Metadata = Metadata> = InstanceLike<T> | StaticLike<T>;
-export type Size<T extends TypeLike> = T extends undefined | null ? 0 : T extends {
-    readonly [Symbol.size]: infer S extends number;
-} ? S : T extends primitive.Valid ? primitive.Size<T> : number;
+export type Size<T extends TypeLike> = T extends undefined | null ? 0 : T extends primitive.Valid ? primitive.Size<T> : number;
 export {};

package/dist/internal/struct.js

@@ -3,38 +3,24 @@
  * @see https://github.com/microsoft/TypeScript/issues/53461
  */
 Symbol.metadata ??= Symbol.for('Symbol.metadata');
-Object.assign(Symbol, {
-    size: Symbol('uSize'),
-    serialize: Symbol('uSerialize'),
-    deserialize: Symbol('uDeserialize'),
-});
 /**
  * Initializes the struct metadata for a class
  * This also handles copying metadata from parent classes
  */
 export function initMetadata(context) {
     context.metadata ??= {};
-    context.metadata.structInit = [...(context.metadata.structInit ?? [])];
+    const existing = context.metadata.structInit ?? {};
+    context.metadata.structInit = {
+        members: [...(existing.members ?? [])],
+        size: existing.size ?? 0,
+        isDynamic: existing.isDynamic ?? false,
+        isUnion: existing.isUnion ?? false,
+    };
     return context.metadata.structInit;
 }
 export function isValidMetadata(arg) {
     return arg != null && typeof arg == 'object' && 'struct' in arg;
 }
-/**
- * Polyfill context.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- * @internal @hidden
- */
-export function _polyfill_metadata(target) {
-    if (Symbol.metadata in target)
-        return;
-    Object.defineProperty(target, Symbol.metadata, {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: Object.create(null),
-    });
-}
 export function isStatic(arg) {
     return typeof arg == 'function' && Symbol.metadata in arg && isValidMetadata(arg[Symbol.metadata]);
 }
@@ -56,6 +42,3 @@ export function checkStruct(arg) {
     throw new TypeError((typeof arg == 'function' ? arg.name : typeof arg == 'object' && arg ? arg.constructor.name : arg)
         + ' is not a struct');
 }
-export function isCustom(arg) {
-    return typeof arg == 'object' && arg != null && Symbol.size in arg;
-}

package/dist/objects.d.ts

@@ -48,3 +48,9 @@ export type Bound<T extends object, This = any> = T & {
  * Binds a this value for all of the functions in an object (not recursive)
  */
 export declare function bindFunctions<T extends object, This = any>(fns: T, thisValue: This): Bound<T, This>;
+/**
+ * Makes all properties in T mutable
+ */
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};

package/dist/string.js

@@ -16,7 +16,13 @@ const decoder = new TextDecoder();
  * Decodes a UTF-8 string from a buffer
  */
 export function decodeUTF8(input) {
-    return decoder.decode(input);
+    if (!input)
+        return '';
+    if (input.buffer instanceof ArrayBuffer && !input.buffer.resizable)
+        return decoder.decode(input);
+    const buffer = new Uint8Array(input.byteLength);
+    buffer.set(input);
+    return decoder.decode(buffer);
 }
 export function encodeASCII(input) {
     const data = new Uint8Array(input.length);

package/dist/struct.d.ts

@@ -1,6 +1,5 @@
 import * as primitive from './internal/primitives.js';
-import type { DecoratorContext, InstanceLike, MemberContext, Options, Size, StaticLike, TypeLike } from './internal/struct.js';
-import type { ClassLike } from './types.js';
+import type { DecoratorContext, InstanceLike, Options, Size, StaticLike, TypeLike } from './internal/struct.js';
 export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
@@ -10,29 +9,29 @@ export declare function sizeof<T extends TypeLike>(type: T | 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
- */
+/** Aligns a number */
 export declare function align(value: number, alignment: number): number;
 /**
  * Decorates a class as a struct
  */
-export declare function struct(options?: Partial<Options>): <const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext) => T;
+export declare function struct(options?: Partial<Options>): <T extends StaticLike>(target: T, context: ClassDecoratorContext<T> & DecoratorContext) => void;
+export interface MemberOptions {
+    bigEndian?: boolean;
+    length?: number | string;
+    align?: number;
+    typeName?: string;
+}
 /**
  * Decorates a class member to be serialized
  */
-export declare function member(type: primitive.Valid | ClassLike, length?: number | string): <V>(value: V, context: MemberContext) => V;
-/**
- * Serializes a struct into a Uint8Array
- */
-export declare function serialize(instance: unknown): Uint8Array;
-/**
- * Deserializes a struct from a Uint8Array
- */
-export declare function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayBufferView): void;
-declare function _member<T extends primitive.Valid>(type: T): {
-    <const V>(length: number | string): (value: V, context: MemberContext) => V;
-    <const V>(value: V, context: MemberContext): V;
+export declare function member<V>(type: primitive.Type | StaticLike, opt?: MemberOptions): (value: Target<V>, context: Context<V>) => Result<V>;
+type Target<V> = ClassAccessorDecoratorTarget<any, V>;
+type Result<V> = ClassAccessorDecoratorResult<any, V>;
+type Context<V> = ClassAccessorDecoratorContext<any, V> & DecoratorContext;
+type Decorator<V> = (value: Target<V>, context: Context<V>) => Result<V>;
+declare function _member<T extends primitive.Valid>(typeName: T): {
+    <V>(length: number | string): Decorator<V>;
+    <V>(value: Target<V>, context: Context<V>): Result<V>;
 };
 /**
  * Shortcut types

package/dist/struct.js

@@ -1,9 +1,9 @@
-import { toUint8Array } from './buffer.js';
+import { BufferViewArray } from './buffer.js';
 import { _debugLog } from './debugging.js';
 import * as primitive from './internal/primitives.js';
-import { _polyfill_metadata, checkInstance, checkStruct, initMetadata, isCustom, isInstance, isStatic, isStruct, } from './internal/struct.js';
+import { checkStruct, initMetadata, isInstance, isStatic, isStruct } from './internal/struct.js';
 import { _throw } from './misc.js';
-import { capitalize } from './string.js';
+import { getAllPrototypes } from './objects.js';
 export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
@@ -21,38 +21,28 @@ export function sizeof(type) {
     // primitive or character
     if (typeof type == 'string') {
         primitive.checkValid(type);
-        return (+primitive.normalize(type).match(primitive.regex)[2] / 8);
+        return primitive.types[primitive.normalize(type)].size;
     }
-    if (isCustom(type))
-        return type[Symbol.size];
+    if (primitive.isType(type))
+        return type.size;
     checkStruct(type);
     const constructor = isStatic(type) ? type : type.constructor;
-    _polyfill_metadata(constructor);
-    const { struct } = constructor[Symbol.metadata];
-    let size = struct.staticSize;
-    if (isStatic(type))
-        return size;
-    for (const member of struct.members.values()) {
-        const value = type[member.name];
-        if (isInstance(value) && value.constructor[Symbol.metadata].struct.isDynamic) {
-            if (struct.isUnion)
-                size = Math.max(size, sizeof(value));
-            else
-                size += sizeof(value);
-            continue;
-        }
-        if (typeof member.length != 'string')
-            continue;
-        let subSize = 0;
-        for (let i = 0; i < type[member.length]; i++) {
-            subSize += sizeof(isStruct(value[i]) ? value[i] : member.type);
+    const { struct, structInit } = constructor[Symbol.metadata];
+    if (isStatic(type) || !struct.isDynamic)
+        return struct.staticSize;
+    const last = structInit.members.at(-1);
+    const length = type[last.length];
+    let dynamicSize = 0;
+    if (primitive.isType(last.type)) {
+        dynamicSize = last.type.size * length;
+    }
+    else {
+        const value = type[last.name];
+        for (let i = 0; i < length; i++) {
+            dynamicSize += sizeof(isStruct(value[i]) ? value[i] : last.type);
         }
-        if (struct.isUnion)
-            size = Math.max(size, subSize);
-        else
-            size += subSize;
     }
-    return size;
+    return (struct.isUnion ? Math.max(struct.staticSize, dynamicSize) : struct.staticSize + dynamicSize);
 }
 /**
  * Returns the offset (in bytes) of a member in a struct.
@@ -60,24 +50,12 @@ export function sizeof(type) {
 export function offsetof(type, memberName) {
     checkStruct(type);
     const constructor = isStatic(type) ? type : type.constructor;
-    _polyfill_metadata(constructor);
-    const { struct } = constructor[Symbol.metadata];
-    if (isStatic(type) || !struct.isDynamic) {
-        return (struct.members.get(memberName)?.staticOffset
-            ?? _throw(new Error('Struct does not have member: ' + memberName)));
-    }
-    let offset = 0;
-    for (const member of struct.members.values()) {
-        if (member.name == memberName)
-            return offset;
-        const value = type[member.name];
-        offset += sizeof(isStruct(value) ? value : member.type);
-    }
-    throw new Error('Struct does not have member: ' + memberName);
+    const member = constructor[Symbol.metadata].struct.members.get(memberName);
+    if (!member)
+        throw new Error('Struct does not have member: ' + memberName);
+    return member.offset;
 }
-/**
- * Aligns a number
- */
+/** Aligns a number */
 export function align(value, alignment) {
     return Math.ceil(value / alignment) * alignment;
 }
@@ -86,51 +64,33 @@ export function align(value, alignment) {
  */
 export function struct(options = {}) {
     return function _decorateStruct(target, context) {
+        const init = initMetadata(context);
         const members = new Map();
-        let staticSize = 0, isDynamic = false;
-        for (const { name, type, length } of initMetadata(context)) {
-            if (!primitive.isValid(type) && !isStatic(type))
-                throw new TypeError('Not a valid type: ' + type);
-            if (typeof length == 'string') {
-                const countedBy = members.get(length);
-                if (!countedBy)
-                    throw new Error(`"${length}" is undefined or declared after "${name}"`);
-                if (!primitive.isType(countedBy.type))
-                    throw new Error(`"${length}" is not a number and cannot be used to count "${name}"`);
-            }
-            let decl = `${typeof type == 'string' ? type : type.name} ${name}`;
-            if (length !== undefined)
-                decl += `[${length}]`;
-            members.set(name, {
-                name,
-                staticOffset: options.isUnion ? 0 : staticSize,
-                type: primitive.isValid(type) ? primitive.normalize(type) : type,
-                length,
-                decl,
-            });
-            const memberSize = typeof length == 'string' || (isStatic(type) && type[Symbol.metadata].struct.isDynamic)
-                ? 0
-                : sizeof(type) * (length || 1);
-            isDynamic ||= isStatic(type) ? type[Symbol.metadata].struct.isDynamic : typeof length == 'string';
-            staticSize = options.isUnion ? Math.max(staticSize, memberSize) : staticSize + memberSize;
-            staticSize = align(staticSize, options.align || 1);
-            _debugLog('define', target.name + '.' + name);
+        for (const member of init.members) {
+            if (options.isUnion)
+                member.offset = 0;
+            _debugLog('define', target.name + '.' + member.name);
+            members.set(member.name, member);
         }
         context.metadata.struct = {
             options,
             members,
-            staticSize,
-            isDynamic,
+            staticSize: init.size,
+            isDynamic: init.isDynamic,
             isUnion: options.isUnion ?? false,
         };
-        return target;
     };
 }
 /**
  * Decorates a class member to be serialized
  */
-export function member(type, length) {
-    return function (value, context) {
+export function member(type, opt = {}) {
+    return function __decorateMember(value, context) {
+        if (context.kind != 'accessor')
+            throw new Error('Member must be an accessor');
+        const init = initMetadata(context);
+        if (init.isDynamic)
+            throw new Error('Dynamic members must be declared at the end of the struct');
         let name = context.name;
         if (typeof name == 'symbol') {
             console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
@@ -138,155 +98,100 @@ export function member(type, length) {
         }
         if (!name)
             throw new ReferenceError('Invalid name for struct member');
-        initMetadata(context).push({ name, type, length });
-        return value;
+        if (!primitive.isType(type) && !isStatic(type))
+            throw new TypeError('Not a valid type: ' + type.name);
+        if (typeof opt.length == 'string') {
+            const countedBy = init.members.find(m => m.name == opt.length);
+            if (!countedBy)
+                throw new Error(`"${opt.length}" is not declared and cannot be used to count "${name}"`);
+            if (!primitive.isType(countedBy.type))
+                throw new Error(`"${opt.length}" is not a number and cannot be used to count "${name}"`);
+            init.isDynamic = true;
+        }
+        const size = align(sizeof(type) * (typeof opt.length == 'string' ? 0 : (opt.length ?? 1)), opt.align ?? sizeof(type));
+        const member = {
+            name,
+            offset: init.size,
+            type,
+            length: opt.length,
+            size,
+            decl: `${opt.typeName ?? type.name} ${name}${opt.length !== undefined ? `[${JSON.stringify(opt.length)}]` : ''}`,
+            littleEndian: !opt.bigEndian,
+        };
+        init.members.push(member);
+        // Apply after setting `offset`
+        init.size += size;
+        return {
+            get() {
+                return _get(this, member);
+            },
+            set(value) {
+                _set(this, member, value);
+            },
+        };
     };
 }
 /** Gets the length of a member */
-function _memberLength(instance, member) {
-    if (member.length === undefined)
+function _memberLength(instance, length) {
+    if (length === undefined)
         return -1;
-    if (typeof member.length == 'string')
-        return instance[member.length];
-    return Number.isSafeInteger(member.length) && member.length >= 0
-        ? member.length
+    if (typeof length == 'string')
+        return instance[length];
+    return Number.isSafeInteger(length) && length >= 0
+        ? length
         : _throw(new Error('Array lengths must be natural numbers'));
 }
-/**
- * Serializes a struct into a Uint8Array
- */
-export function serialize(instance) {
-    if (isCustom(instance) && typeof instance[Symbol.serialize] == 'function')
-        return instance[Symbol.serialize]();
-    checkInstance(instance);
-    _polyfill_metadata(instance.constructor);
-    const { options, members } = instance.constructor[Symbol.metadata].struct;
-    const size = sizeof(instance);
-    const buffer = new Uint8Array(size);
-    const view = new DataView(buffer.buffer);
-    _debugLog('serialize', instance.constructor.name);
-    let offset = 0, nextOffset = 0;
-    // for unions we should write members in ascending last modified order, but we don't have that info.
-    for (const member of members.values()) {
-        const length = _memberLength(instance, member);
-        _debugLog('\t', member.decl);
-        for (let i = 0; i < Math.abs(length); i++) {
-            let value = length != -1 ? instance[member.name][i] : instance[member.name];
-            if (typeof value == 'string') {
-                value = value.charCodeAt(0);
-            }
-            offset = nextOffset;
-            nextOffset += isInstance(value) ? sizeof(value) : sizeof(member.type);
-            if (!primitive.isType(member.type)) {
-                buffer.set(value ? serialize(value) : new Uint8Array(sizeof(member.type)), offset);
-                continue;
-            }
-            const fn = `set${capitalize(member.type)}`;
-            if (fn == 'setInt64') {
-                view.setBigInt64(offset, BigInt(value), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'setUint64') {
-                view.setBigUint64(offset, BigInt(value), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'setInt128') {
-                view.setBigUint64(offset + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-                view.setBigInt64(offset + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'setUint128') {
-                view.setBigUint64(offset + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-                view.setBigUint64(offset + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'setFloat128') {
-                view.setFloat64(offset + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
-                view.setBigUint64(offset + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
-                continue;
-            }
-            view[fn](offset, Number(value), !options.bigEndian);
+function _set(instance, member, value, index) {
+    const { name, type, length: rawLength } = member;
+    const length = _memberLength(instance, rawLength);
+    if (!primitive.isType(type)) {
+        if (!isInstance(value))
+            return _debugLog(`Tried to set "${name}" to a non-instance value`);
+        if (length > 0 && typeof index != 'number') {
+            for (let i = 0; i < length; i++)
+                _set(instance, member, value[i], i);
+            return;
         }
+        if (!Array.from(getAllPrototypes(value.constructor)).some(c => c === type))
+            throw new Error(`${value.constructor.name} is not a subtype of ${type.name}`);
+        const offset = instance.byteOffset + member.offset + (index ?? 0) * sizeof(type);
+        // It's already the same value
+        if (value.buffer === instance.buffer && value.byteOffset === offset)
+            return;
+        const current = new Uint8Array(instance.buffer, offset, sizeof(value));
+        current.set(new Uint8Array(value.buffer, value.byteOffset, sizeof(value)));
+        return;
     }
-    return buffer;
-}
-/**
- * Deserializes a struct from a Uint8Array
- */
-export function deserialize(instance, _buffer) {
-    const buffer = toUint8Array(_buffer);
-    if (isCustom(instance) && typeof instance[Symbol.deserialize] == 'function')
-        return instance[Symbol.deserialize](buffer);
-    checkInstance(instance);
-    _polyfill_metadata(instance.constructor);
-    const { options, members } = instance.constructor[Symbol.metadata].struct;
-    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    _debugLog('deserialize', instance.constructor.name);
-    let offset = 0, nextOffset = 0;
-    for (const member of members.values()) {
-        const length = _memberLength(instance, member);
-        _debugLog('\t', member.decl);
-        for (let i = 0; i < Math.abs(length); i++) {
-            let object = length != -1 ? instance[member.name] : instance;
-            const key = length != -1 ? i : member.name;
-            const isNullish = object[key] === null || object[key] === undefined;
-            const needsAllocation = isNullish && isStatic(member.type) && member.type[Symbol.metadata].struct.isDynamic;
-            offset = nextOffset;
-            if (!isInstance(object[key]) && !needsAllocation)
-                nextOffset += sizeof(member.type);
-            if (typeof instance[member.name] == 'string') {
-                instance[member.name] =
-                    instance[member.name].slice(0, i)
-                        + String.fromCharCode(view.getUint8(offset))
-                        + instance[member.name].slice(i + 1);
-                continue;
-            }
-            if (!primitive.isType(member.type)) {
-                if (needsAllocation && isStatic(member.type))
-                    object[key] ??= new member.type();
-                else if (isNullish)
-                    continue;
-                deserialize(object[key], new Uint8Array(buffer.subarray(offset)));
-                nextOffset += sizeof(object[key]);
-                continue;
-            }
-            if (length && length != -1)
-                object ||= [];
-            const fn = `get${capitalize(member.type)}`;
-            if (fn == 'getInt64') {
-                object[key] = view.getBigInt64(offset, !options.bigEndian);
-                continue;
-            }
-            if (fn == 'getUint64') {
-                object[key] = view.getBigUint64(offset, !options.bigEndian);
-                continue;
-            }
-            if (fn == 'getInt128') {
-                object[key] =
-                    (view.getBigInt64(offset + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-                        | view.getBigUint64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'getUint128') {
-                object[key] =
-                    (view.getBigUint64(offset + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-                        | view.getBigUint64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-                continue;
-            }
-            if (fn == 'getFloat128') {
-                object[key] = view.getFloat64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
-                continue;
-            }
-            object[key] = view[fn](offset, !options.bigEndian);
+    const view = new DataView(instance.buffer, instance.byteOffset, instance.byteLength);
+    if (length > 0 && typeof index != 'number') {
+        for (let i = 0; i < length; i++) {
+            const offset = member.offset + i * type.size;
+            type.set(view, offset, member.littleEndian, value[i]);
         }
+        return;
     }
+    if (typeof value == 'string')
+        value = value.charCodeAt(0);
+    type.set(view, member.offset + (index ?? 0) * type.size, member.littleEndian, value);
 }
-function _member(type) {
+function _get(instance, member, index) {
+    const { type, length: rawLength } = member;
+    const length = _memberLength(instance, rawLength);
+    if (length > 0 && typeof index != 'number') {
+        return new (primitive.isType(type) ? type.array : BufferViewArray(type, sizeof(type)))(instance.buffer, instance.byteOffset + member.offset, length * sizeof(type));
+    }
+    const offset = member.offset + (index ?? 0) * sizeof(type);
+    if (isStatic(type))
+        return new type(instance.buffer, offset, sizeof(type));
+    const view = new DataView(instance.buffer, instance.byteOffset, instance.byteLength);
+    return type.get(view, offset, member.littleEndian);
+}
+function _member(typeName) {
+    const type = primitive.types[primitive.normalize(typeName)];
     function _structMemberDecorator(valueOrLength, context) {
-        if (typeof valueOrLength == 'number' || typeof valueOrLength == 'string') {
-            return member(type, valueOrLength);
-        }
-        return member(type)(valueOrLength, context);
+        return typeof valueOrLength == 'number' || typeof valueOrLength == 'string'
+            ? member(type, { length: valueOrLength, typeName })
+            : member(type, { typeName })(valueOrLength, context);
     }
     return _structMemberDecorator;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "1.10.0",
+	"version": "2.0.0-pre.1",
 	"description": "Typescript utilities",
 	"funding": {
 		"type": "individual",