utilium 1.7.10 → 1.7.12

package/dist/debugging.d.ts

@@ -27,4 +27,16 @@ type LoggableDecoratorContext = Exclude<DecoratorContext, ClassFieldDecoratorCon
  * Create a function that can be used to decorate classes and non-field members.
  */
 export declare function createLogDecorator(options: CreateLoggerOptions): <T extends (...args: any[]) => any>(value: T, context: LoggableDecoratorContext) => T;
+/**
+ * @internal @hidden
+ */
+export declare let U_DEBUG: boolean;
+/**
+ * @internal @hidden
+ */
+export declare function _setDebug(value: boolean): void;
+/**
+ * @internal @hidden
+ */
+export declare function _debugLog(...text: any[]): void;
 export {};

package/dist/debugging.js

@@ -53,3 +53,20 @@ export function createLogDecorator(options) {
         };
     };
 }
+/**
+ * @internal @hidden
+ */
+export let U_DEBUG = 'process' in globalThis && 'env' in globalThis.process && globalThis.process.env.U_DEBUG == 'true';
+/**
+ * @internal @hidden
+ */
+export function _setDebug(value) {
+    U_DEBUG = value;
+}
+/**
+ * @internal @hidden
+ */
+export function _debugLog(...text) {
+    if (U_DEBUG)
+        console.debug('[U]', ...text);
+}

package/dist/internal/struct.d.ts

@@ -10,7 +10,7 @@ declare global {
         readonly deserialize: unique symbol;
     }
 }
-export type TypeLike = Custom | Like | primitive.Valid;
+export type TypeLike = Custom | Like | primitive.Valid | undefined | null;
 export type Type = Custom | Static | primitive.Typename;
 /**
  * Member initialization data
@@ -30,22 +30,31 @@ export interface Options {
     isUnion: boolean;
 }
 export interface Member {
+    name: string;
     type: Type;
-    offset: number;
+    staticOffset: number;
     length?: number | string;
+    /** A C-style type/name declaration string, used for diagnostics */
+    decl: string;
 }
 export interface Metadata {
     options: Partial<Options>;
     members: Map<string, Member>;
-    init?: MemberInit[];
     staticSize: number;
+    isDynamic: boolean;
 }
 type _DecoratorMetadata<T extends Metadata = Metadata> = DecoratorMetadata & {
-    struct?: Partial<T>;
+    struct?: T;
+    structInit?: MemberInit[];
 };
 export interface DecoratorContext<T extends Metadata = Metadata> {
     metadata: _DecoratorMetadata<T>;
 }
+/**
+ * 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 interface Static<T extends Metadata = Metadata> {
     [Symbol.metadata]: {
@@ -63,12 +72,9 @@ export declare function isValidMetadata<T extends Metadata = Metadata>(arg: unkn
 /**
  * Polyfill context.metadata
  * @see https://github.com/microsoft/TypeScript/issues/53461
+ * @internal @hidden
  */
-export declare function _polyfill_contextMetadata(target: object): void;
-/**
- * Gets a reference to Symbol.metadata, even on platforms that do not expose it globally (like Node)
- */
-export declare function symbol_metadata(arg: ClassLike): typeof Symbol.metadata;
+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> {
     constructor: Static<T>;
@@ -90,7 +96,7 @@ export interface Custom {
 }
 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 {
-    readonly [Symbol.size]: infer S;
+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 {};

package/dist/internal/struct.js

@@ -1,22 +1,32 @@
+/**
+ * Polyfill Symbol.metadata
+ * @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 ?? [])];
+    return context.metadata.structInit;
+}
 export function isValidMetadata(arg) {
     return arg != null && typeof arg == 'object' && 'struct' in arg;
 }
-/**
- * Polyfill Symbol.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- */
-Symbol.metadata ??= Symbol.for('Symbol.metadata');
 /**
  * Polyfill context.metadata
  * @see https://github.com/microsoft/TypeScript/issues/53461
+ * @internal @hidden
  */
-export function _polyfill_contextMetadata(target) {
-    if (!Symbol?.metadata || Symbol.metadata in target)
+export function _polyfill_metadata(target) {
+    if (Symbol.metadata in target)
         return;
     Object.defineProperty(target, Symbol.metadata, {
         enumerable: true,
@@ -25,21 +35,8 @@ export function _polyfill_contextMetadata(target) {
         value: Object.create(null),
     });
 }
-/**
- * Gets a reference to Symbol.metadata, even on platforms that do not expose it globally (like Node)
- */
-export function symbol_metadata(arg) {
-    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');
-    }
-    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 in arg && isValidMetadata(arg[Symbol.metadata]);
 }
 export function isInstance(arg) {
     return arg != null && typeof arg == 'object' && isStatic(arg.constructor);

package/dist/struct.d.ts

@@ -5,7 +5,7 @@ export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
  */
-export declare function sizeof<T extends TypeLike>(type: T): Size<T>;
+export declare function sizeof<T extends TypeLike>(type: T | T[]): Size<T>;
 /**
  * Returns the offset (in bytes) of a member in a struct.
  */

package/dist/struct.js

@@ -1,6 +1,7 @@
 import { toUint8Array } from './buffer.js';
+import { _debugLog } from './debugging.js';
 import * as primitive from './internal/primitives.js';
-import { checkInstance, checkStruct, isCustom, isStatic, symbol_metadata } from './internal/struct.js';
+import { _polyfill_metadata, checkInstance, checkStruct, initMetadata, isCustom, isInstance, isStatic, } from './internal/struct.js';
 import { _throw } from './misc.js';
 import { capitalize } from './string.js';
 export * as Struct from './internal/struct.js';
@@ -8,6 +9,15 @@ export * as Struct from './internal/struct.js';
  * Gets the size in bytes of a type
  */
 export function sizeof(type) {
+    if (type === undefined || type === null)
+        return 0;
+    if (Array.isArray(type)) {
+        let size = 0;
+        for (let i = 0; i < type.length; i++) {
+            size += sizeof(type[i]);
+        }
+        return size;
+    }
     // primitive
     if (typeof type == 'string') {
         primitive.checkValid(type);
@@ -16,20 +26,40 @@ export function sizeof(type) {
     if (isCustom(type))
         return type[Symbol.size];
     checkStruct(type);
-    const struct = isStatic(type) ? type : type.constructor;
-    return struct[symbol_metadata(struct)].struct.staticSize;
+    const constructor = isStatic(type) ? type : type.constructor;
+    _polyfill_metadata(constructor);
+    const { struct } = constructor[Symbol.metadata];
+    if (isStatic(type))
+        return struct.staticSize;
+    let size = struct.staticSize;
+    for (const member of struct.members.values()) {
+        if (typeof member.length != 'string')
+            continue;
+        for (let i = 0; i < type[member.length]; i++) {
+            size += sizeof(type[member.name][i]);
+        }
+    }
+    return 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)].struct;
-    const member = metadata.members.get(memberName);
-    if (!member)
-        throw new Error('Struct does not have member: ' + memberName);
-    return member.offset;
+    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;
+        offset += sizeof(type[member.name]);
+    }
+    throw new Error('Struct does not have member: ' + memberName);
 }
 /**
  * Aligns a number
@@ -37,65 +67,40 @@ export function offsetof(type, memberName) {
 export function align(value, alignment) {
     return Math.ceil(value / alignment) * alignment;
 }
-/**
- * Gets the length of an array in a struct
- * @param length The numeric length or the name of the field which has the array length (like __counted_by)
- * @param name The name of the array field— only used for errors
- */
-function _memberLength(struct, length, name) {
-    if (length === undefined)
-        return -1;
-    if (typeof length != 'string')
-        return Number.isSafeInteger(length) && length >= 0
-            ? length
-            : _throw(new Error('Array lengths must be natural numbers'));
-    if (!(length in struct))
-        throw new Error(`Can not use non-existent member to count ${name}: ` + length);
-    const n = struct[length];
-    if (typeof n != 'number')
-        throw new Error(`Can not use "${name}" to count ${length}`);
-    return n;
-}
-/** Compute the size of a struct including dynamically sized members */
-function _structSize() {
-    const { staticSize, members } = this.constructor[symbol_metadata(this.constructor)].struct;
-    let size = staticSize;
-    for (const [name, { type, length: key }] of members) {
-        if (typeof key != 'string')
-            continue;
-        size += sizeof(type) * _memberLength(this, key, name);
-    }
-    return size;
-}
 /**
  * Decorates a class as a struct
  */
 export function struct(options = {}) {
     return function _decorateStruct(target, context) {
-        context.metadata ??= {};
-        context.metadata.struct ??= {};
-        context.metadata.struct.init ??= [];
-        let staticSize = 0;
         const members = new Map();
-        for (const { name, type, length } of context.metadata.struct.init) {
+        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, {
-                offset: options.isUnion ? 0 : staticSize,
+                name,
+                staticOffset: options.isUnion ? 0 : staticSize,
                 type: primitive.isValid(type) ? primitive.normalize(type) : type,
                 length,
+                decl,
             });
             const memberSize = typeof length == 'string' ? 0 : sizeof(type) * (length || 1);
+            isDynamic ||= typeof length == 'string';
             staticSize = options.isUnion ? Math.max(staticSize, memberSize) : staticSize + memberSize;
             staticSize = align(staticSize, options.align || 1);
+            _debugLog('define', target.name + '.' + name);
         }
-        context.metadata.struct = { options, members, staticSize };
-        context.addInitializer(function () {
-            Object.defineProperty(this.prototype, Symbol.size, {
-                get: _structSize.bind(this),
-                enumerable: false,
-            });
-        });
+        context.metadata.struct = { options, members, staticSize, isDynamic };
         return target;
     };
 }
@@ -111,13 +116,20 @@ export function member(type, length) {
         }
         if (!name)
             throw new ReferenceError('Invalid name for struct member');
-        context.metadata ??= {};
-        context.metadata.struct ??= {};
-        context.metadata.struct.init ??= [];
-        context.metadata.struct.init.push({ name, type, length });
+        initMetadata(context).push({ name, type, length });
         return value;
     };
 }
+/** Gets the length of a member */
+function _memberLength(instance, member) {
+    if (member.length === undefined)
+        return -1;
+    if (typeof member.length == 'string')
+        return instance[member.length];
+    return Number.isSafeInteger(member.length) && member.length >= 0
+        ? member.length
+        : _throw(new Error('Array lengths must be natural numbers'));
+}
 /**
  * Serializes a struct into a Uint8Array
  */
@@ -125,47 +137,53 @@ export function serialize(instance) {
     if (isCustom(instance) && typeof instance[Symbol.serialize] == 'function')
         return instance[Symbol.serialize]();
     checkInstance(instance);
-    const { options, members } = instance.constructor[symbol_metadata(instance.constructor)].struct;
-    const buffer = new Uint8Array(sizeof(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 [name, { type, length: rawLength, offset }] of members) {
-        const length = _memberLength(instance, rawLength, name);
+    for (const member of members.values()) {
+        const length = _memberLength(instance, member);
+        _debugLog('\t', member.decl);
         for (let i = 0; i < Math.abs(length); i++) {
-            const iOff = offset + sizeof(type) * i;
-            let value = length != -1 ? instance[name][i] : instance[name];
+            let value = length != -1 ? instance[member.name][i] : instance[member.name];
             if (typeof value == 'string') {
                 value = value.charCodeAt(0);
             }
-            if (!primitive.isType(type)) {
-                buffer.set(value ? serialize(value) : new Uint8Array(sizeof(type)), iOff);
+            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(type)}`;
+            const fn = `set${capitalize(member.type)}`;
             if (fn == 'setInt64') {
-                view.setBigInt64(iOff, BigInt(value), !options.bigEndian);
+                view.setBigInt64(offset, BigInt(value), !options.bigEndian);
                 continue;
             }
             if (fn == 'setUint64') {
-                view.setBigUint64(iOff, BigInt(value), !options.bigEndian);
+                view.setBigUint64(offset, 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);
+                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(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-                view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+                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(iOff + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
-                view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
+                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](iOff, Number(value), !options.bigEndian);
+            view[fn](offset, Number(value), !options.bigEndian);
         }
     }
     return buffer;
@@ -178,53 +196,62 @@ export function deserialize(instance, _buffer) {
     if (isCustom(instance) && typeof instance[Symbol.deserialize] == 'function')
         return instance[Symbol.deserialize](buffer);
     checkInstance(instance);
-    const { options, members } = instance.constructor[symbol_metadata(instance.constructor)].struct;
+    _polyfill_metadata(instance.constructor);
+    const { options, members } = instance.constructor[Symbol.metadata].struct;
     const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    for (const [name, { type, offset, length: rawLength }] of members) {
-        const length = _memberLength(instance, rawLength, name);
+    _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[name] : instance;
-            const key = length != -1 ? i : name, iOff = offset + sizeof(type) * i;
-            if (typeof instance[name] == 'string') {
-                instance[name] =
-                    instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
+            let object = length != -1 ? instance[member.name] : instance;
+            const key = length != -1 ? i : member.name;
+            offset = nextOffset;
+            if (!isInstance(object[key]))
+                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(type)) {
-                if (object[key] === null || object[key] === undefined) {
+            if (!primitive.isType(member.type)) {
+                if (object[key] === null || object[key] === undefined)
                     continue;
-                }
-                deserialize(object[key], new Uint8Array(buffer.subarray(iOff, iOff + sizeof(type))));
+                deserialize(object[key], new Uint8Array(buffer.subarray(offset)));
+                nextOffset += sizeof(object[key]);
                 continue;
             }
             if (length && length != -1)
                 object ||= [];
-            const fn = `get${capitalize(type)}`;
+            const fn = `get${capitalize(member.type)}`;
             if (fn == 'getInt64') {
-                object[key] = view.getBigInt64(iOff, !options.bigEndian);
+                object[key] = view.getBigInt64(offset, !options.bigEndian);
                 continue;
             }
             if (fn == 'getUint64') {
-                object[key] = view.getBigUint64(iOff, !options.bigEndian);
+                object[key] = view.getBigUint64(offset, !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);
+                    (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(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-                        | view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+                    (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(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+                object[key] = view.getFloat64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
                 continue;
             }
-            object[key] = view[fn](iOff, !options.bigEndian);
+            object[key] = view[fn](offset, !options.bigEndian);
         }
     }
 }

package/package.json

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

package/src/debugging.ts

@@ -92,3 +92,22 @@ export function createLogDecorator(options: CreateLoggerOptions) {
 		} as T;
 	};
 }
+
+/**
+ * @internal @hidden
+ */
+export let U_DEBUG = 'process' in globalThis && 'env' in globalThis.process && globalThis.process.env.U_DEBUG == 'true';
+
+/**
+ * @internal @hidden
+ */
+export function _setDebug(value: boolean) {
+	U_DEBUG = value;
+}
+
+/**
+ * @internal @hidden
+ */
+export function _debugLog(...text: any[]) {
+	if (U_DEBUG) console.debug('[U]', ...text);
+}

package/src/internal/struct.ts

@@ -14,13 +14,19 @@ declare global {
 	}
 }
 
+/**
+ * Polyfill Symbol.metadata
+ * @see https://github.com/microsoft/TypeScript/issues/53461
+ */
+(Symbol as { metadata: symbol }).metadata ??= Symbol.for('Symbol.metadata');
+
 Object.assign(Symbol, {
 	size: Symbol('uSize'),
 	serialize: Symbol('uSerialize'),
 	deserialize: Symbol('uDeserialize'),
 });
 
-export type TypeLike = Custom | Like | primitive.Valid;
+export type TypeLike = Custom | Like | primitive.Valid | undefined | null;
 
 export type Type = Custom | Static | primitive.Typename;
 
@@ -44,26 +50,43 @@ export interface Options {
 }
 
 export interface Member {
+	name: string;
 	type: Type;
-	offset: number;
+	staticOffset: number;
 	length?: number | string;
+
+	/** A C-style type/name declaration string, used for diagnostics */
+	decl: string;
 }
 
 export interface Metadata {
 	options: Partial<Options>;
 	members: Map<string, Member>;
-	init?: MemberInit[];
 	staticSize: number;
+	isDynamic: boolean;
 }
 
 type _DecoratorMetadata<T extends Metadata = Metadata> = DecoratorMetadata & {
-	struct?: Partial<T>;
+	struct?: T;
+	structInit?: MemberInit[];
 };
 
 export interface DecoratorContext<T extends Metadata = Metadata> {
 	metadata: _DecoratorMetadata<T>;
 }
 
+/**
+ * Initializes the struct metadata for a class
+ * This also handles copying metadata from parent classes
+ */
+export function initMetadata(context: DecoratorContext): MemberInit[] {
+	context.metadata ??= {};
+
+	context.metadata.structInit = [...(context.metadata.structInit ?? [])];
+
+	return context.metadata.structInit;
+}
+
 export type MemberContext = ClassMemberDecoratorContext & DecoratorContext;
 
 export interface Static<T extends Metadata = Metadata> {
@@ -84,18 +107,13 @@ export function isValidMetadata<T extends Metadata = Metadata>(
 	return arg != null && typeof arg == 'object' && 'struct' in arg;
 }
 
-/**
- * Polyfill Symbol.metadata
- * @see https://github.com/microsoft/TypeScript/issues/53461
- */
-(Symbol as { metadata: symbol }).metadata ??= Symbol.for('Symbol.metadata');
-
 /**
  * Polyfill context.metadata
  * @see https://github.com/microsoft/TypeScript/issues/53461
+ * @internal @hidden
  */
-export function _polyfill_contextMetadata(target: object): void {
-	if (!Symbol?.metadata || Symbol.metadata in target) return;
+export function _polyfill_metadata(target: object): void {
+	if (Symbol.metadata in target) return;
 
 	Object.defineProperty(target, Symbol.metadata, {
 		enumerable: true,
@@ -105,26 +123,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');
-	_polyfill_contextMetadata(arg);
-	if (!symbol_metadata) {
-		throw new ReferenceError('Could not get a reference to Symbol.metadata');
-	}
-
-	return symbol_metadata as 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 in arg && isValidMetadata(arg[Symbol.metadata]);
 }
 
 export interface Instance<T extends Metadata = Metadata> {
@@ -176,8 +176,10 @@ export 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 { readonly [Symbol.size]: infer S }
-	? S
-	: T extends primitive.Valid
-		? primitive.Size<T>
-		: number;
+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;

package/src/struct.ts

@@ -1,4 +1,5 @@
 import { toUint8Array } from './buffer.js';
+import { _debugLog } from './debugging.js';
 import * as primitive from './internal/primitives.js';
 import type {
 	DecoratorContext,
@@ -10,11 +11,18 @@ import type {
 	Metadata,
 	Options,
 	Size,
-	Static,
 	StaticLike,
 	TypeLike,
 } from './internal/struct.js';
-import { checkInstance, checkStruct, isCustom, isStatic, symbol_metadata } from './internal/struct.js';
+import {
+	_polyfill_metadata,
+	checkInstance,
+	checkStruct,
+	initMetadata,
+	isCustom,
+	isInstance,
+	isStatic,
+} from './internal/struct.js';
 import { _throw } from './misc.js';
 import { capitalize } from './string.js';
 import type { ClassLike } from './types.js';
@@ -23,7 +31,19 @@ export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
  */
-export function sizeof<T extends TypeLike>(type: T): Size<T> {
+export function sizeof<T extends TypeLike>(type: T | T[]): Size<T> {
+	if (type === undefined || type === null) return 0 as Size<T>;
+
+	if (Array.isArray(type)) {
+		let size = 0;
+
+		for (let i = 0; i < type.length; i++) {
+			size += sizeof(type[i]);
+		}
+
+		return size as Size<T>;
+	}
+
 	// primitive
 	if (typeof type == 'string') {
 		primitive.checkValid(type);
@@ -35,9 +55,22 @@ export function sizeof<T extends TypeLike>(type: T): Size<T> {
 
 	checkStruct(type);
 
-	const struct = isStatic(type) ? type : type.constructor;
+	const constructor = isStatic(type) ? type : type.constructor;
+	_polyfill_metadata(constructor);
+	const { struct } = constructor[Symbol.metadata];
+
+	if (isStatic(type)) return struct.staticSize as Size<T>;
 
-	return struct[symbol_metadata(struct)].struct.staticSize as Size<T>;
+	let size = struct.staticSize;
+
+	for (const member of struct.members.values()) {
+		if (typeof member.length != 'string') continue;
+		for (let i = 0; i < (type as any)[member.length]; i++) {
+			size += sizeof((type as any)[member.name][i]);
+		}
+	}
+
+	return size as Size<T>;
 }
 
 /**
@@ -46,12 +79,26 @@ export function sizeof<T extends TypeLike>(type: T): Size<T> {
 export function offsetof(type: StaticLike | InstanceLike, memberName: string): number {
 	checkStruct(type);
 
-	const struct = isStatic(type) ? type : type.constructor;
-	const metadata = struct[symbol_metadata(struct)].struct;
+	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;
+		offset += sizeof((type as any)[member.name]);
+	}
 
-	const member = metadata.members.get(memberName);
-	if (!member) throw new Error('Struct does not have member: ' + memberName);
-	return member.offset;
+	throw new Error('Struct does not have member: ' + memberName);
 }
 
 /**
@@ -61,45 +108,6 @@ export function align(value: number, alignment: number): number {
 	return Math.ceil(value / alignment) * alignment;
 }
 
-/**
- * Gets the length of an array in a struct
- * @param length The numeric length or the name of the field which has the array length (like __counted_by)
- * @param name The name of the array field— only used for errors
- */
-function _memberLength<T extends Metadata>(
-	struct: Instance<T>,
-	length: string | number | undefined,
-	name: string
-): number {
-	if (length === undefined) return -1;
-	if (typeof length != 'string')
-		return Number.isSafeInteger(length) && length >= 0
-			? length
-			: _throw(new Error('Array lengths must be natural numbers'));
-
-	if (!(length in struct)) throw new Error(`Can not use non-existent member to count ${name}: ` + length);
-
-	const n = (struct as any)[length];
-
-	if (typeof n != 'number') throw new Error(`Can not use "${name}" to count ${length}`);
-
-	return n;
-}
-
-/** Compute the size of a struct including dynamically sized members */
-function _structSize<T extends Metadata>(this: Instance<T>) {
-	const { staticSize, members } = this.constructor[symbol_metadata(this.constructor)].struct;
-
-	let size = staticSize;
-
-	for (const [name, { type, length: key }] of members) {
-		if (typeof key != 'string') continue;
-		size += sizeof(type) * _memberLength(this, key, name);
-	}
-
-	return size;
-}
-
 /**
  * Decorates a class as a struct
  */
@@ -108,33 +116,44 @@ export function struct(options: Partial<Options> = {}) {
 		target: T,
 		context: ClassDecoratorContext & DecoratorContext
 	): T {
-		context.metadata ??= {};
-		context.metadata.struct ??= {};
-		context.metadata.struct.init ??= [];
-
-		let staticSize = 0;
 		const members = new Map<string, Member>();
-		for (const { name, type, length } of context.metadata.struct.init) {
+
+		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, {
-				offset: options.isUnion ? 0 : staticSize,
+				name,
+				staticOffset: options.isUnion ? 0 : staticSize,
 				type: primitive.isValid(type) ? primitive.normalize(type) : type,
 				length,
+				decl,
 			});
+
 			const memberSize = typeof length == 'string' ? 0 : sizeof(type) * (length || 1);
+			isDynamic ||= typeof length == 'string';
 			staticSize = options.isUnion ? Math.max(staticSize, memberSize) : staticSize + memberSize;
 			staticSize = align(staticSize, options.align || 1);
-		}
 
-		context.metadata.struct = { options, members, staticSize } satisfies Metadata;
+			_debugLog('define', target.name + '.' + name);
+		}
 
-		context.addInitializer(function (this: any) {
-			Object.defineProperty(this.prototype, Symbol.size, {
-				get: _structSize.bind(this),
-				enumerable: false,
-			});
-		});
+		context.metadata.struct = { options, members, staticSize, isDynamic } satisfies Metadata;
 
 		return target;
 	};
@@ -153,14 +172,20 @@ export function member(type: primitive.Valid | ClassLike, length?: number | stri
 
 		if (!name) throw new ReferenceError('Invalid name for struct member');
 
-		context.metadata ??= {};
-		context.metadata.struct ??= {};
-		context.metadata.struct.init ??= [];
-		context.metadata.struct.init.push({ name, type, length } satisfies MemberInit);
+		initMetadata(context).push({ name, type, length } satisfies MemberInit);
 		return value;
 	};
 }
 
+/** Gets the length of a member */
+function _memberLength<T extends Metadata>(instance: Instance<T>, member: Member): number {
+	if (member.length === undefined) return -1;
+	if (typeof member.length == 'string') return (instance as any)[member.length];
+	return Number.isSafeInteger(member.length) && member.length >= 0
+		? member.length
+		: _throw(new Error('Array lengths must be natural numbers'));
+}
+
 /**
  * Serializes a struct into a Uint8Array
  */
@@ -168,58 +193,69 @@ export function serialize(instance: unknown): Uint8Array {
 	if (isCustom(instance) && typeof instance[Symbol.serialize] == 'function') return instance[Symbol.serialize]!();
 
 	checkInstance(instance);
-	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)].struct;
+	_polyfill_metadata(instance.constructor);
+	const { options, members } = instance.constructor[Symbol.metadata].struct;
 
-	const buffer = new Uint8Array(sizeof(instance));
+	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 [name, { type, length: rawLength, offset }] of members) {
-		const length = _memberLength(instance, rawLength, name);
-		for (let i = 0; i < Math.abs(length); i++) {
-			const iOff = offset + sizeof(type) * i;
+	for (const member of members.values()) {
+		const length = _memberLength(instance, member);
+
+		_debugLog('\t', member.decl);
 
-			let value = length != -1 ? instance[name][i] : instance[name];
+		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);
 			}
 
-			if (!primitive.isType(type)) {
-				buffer.set(value ? serialize(value) : new Uint8Array(sizeof(type)), iOff);
+			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(type)}` as const;
+			const fn = `set${capitalize(member.type)}` as const;
 
 			if (fn == 'setInt64') {
-				view.setBigInt64(iOff, BigInt(value), !options.bigEndian);
+				view.setBigInt64(offset, BigInt(value), !options.bigEndian);
 				continue;
 			}
 
 			if (fn == 'setUint64') {
-				view.setBigUint64(iOff, BigInt(value), !options.bigEndian);
+				view.setBigUint64(offset, 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);
+				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(iOff + (!options.bigEndian ? 0 : 8), value & primitive.mask64, !options.bigEndian);
-				view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), value >> BigInt(64), !options.bigEndian);
+				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(iOff + (!options.bigEndian ? 0 : 8), Number(value), !options.bigEndian);
-				view.setBigUint64(iOff + (!options.bigEndian ? 8 : 0), BigInt(0), !options.bigEndian);
+				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](iOff, Number(value), !options.bigEndian);
+			view[fn](offset, Number(value), !options.bigEndian);
 		}
 	}
 
@@ -236,64 +272,77 @@ export function deserialize(instance: unknown, _buffer: ArrayBufferLike | ArrayB
 		return instance[Symbol.deserialize]!(buffer);
 
 	checkInstance(instance);
-	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)].struct;
+	_polyfill_metadata(instance.constructor);
+	const { options, members } = instance.constructor[Symbol.metadata].struct;
 
 	const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 
-	for (const [name, { type, offset, length: rawLength }] of members) {
-		const length = _memberLength(instance, rawLength, name);
+	_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[name] : instance;
-			const key = length != -1 ? i : name,
-				iOff = offset + sizeof(type) * i;
+			let object = length != -1 ? instance[member.name] : instance;
+			const key = length != -1 ? i : member.name;
+
+			offset = nextOffset;
+			if (!isInstance(object[key])) nextOffset += sizeof(member.type);
 
-			if (typeof instance[name] == 'string') {
-				instance[name] =
-					instance[name].slice(0, i) + String.fromCharCode(view.getUint8(iOff)) + instance[name].slice(i + 1);
+			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(type)) {
-				if (object[key] === null || object[key] === undefined) {
-					continue;
-				}
-				deserialize(object[key], new Uint8Array(buffer.subarray(iOff, iOff + sizeof(type))));
+			if (!primitive.isType(member.type)) {
+				if (object[key] === null || object[key] === undefined) continue;
+
+				deserialize(object[key], new Uint8Array(buffer.subarray(offset)));
+				nextOffset += sizeof(object[key]);
 				continue;
 			}
 
 			if (length && length != -1) object ||= [];
 
-			const fn = `get${capitalize(type)}` as const;
+			const fn = `get${capitalize(member.type)}` as const;
 			if (fn == 'getInt64') {
-				object[key] = view.getBigInt64(iOff, !options.bigEndian);
+				object[key] = view.getBigInt64(offset, !options.bigEndian);
 				continue;
 			}
 
 			if (fn == 'getUint64') {
-				object[key] = view.getBigUint64(iOff, !options.bigEndian);
+				object[key] = view.getBigUint64(offset, !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);
+					(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(iOff + (!options.bigEndian ? 8 : 0), !options.bigEndian) << BigInt(64))
-					| view.getBigUint64(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+					(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(iOff + (!options.bigEndian ? 0 : 8), !options.bigEndian);
+				object[key] = view.getFloat64(offset + (!options.bigEndian ? 0 : 8), !options.bigEndian);
 				continue;
 			}
 
-			object[key] = view[fn](iOff, !options.bigEndian);
+			object[key] = view[fn](offset, !options.bigEndian);
 		}
 	}
 }