utilium 0.5.10 → 0.6.1

package/dist/{internal → src/internal}/struct.d.ts

@@ -6,7 +6,6 @@ export interface MemberInit {
     length?: number;
 }
 export declare const init: unique symbol;
-export type init = typeof init;
 /**
  * Options for struct initialization
  */
@@ -25,16 +24,31 @@ export interface Metadata {
     size: number;
 }
 export declare const metadata: unique symbol;
-export type metadata = typeof metadata;
+export interface _DecoratorMetadata<T extends Metadata = Metadata> extends DecoratorMetadata {
+    [metadata]?: T;
+    [init]?: MemberInit[];
+}
+export interface DecoratorContext<T extends Metadata = Metadata> {
+    metadata: _DecoratorMetadata<T>;
+}
+export type MemberContext = ClassMemberDecoratorContext & DecoratorContext;
 export interface Static<T extends Metadata = Metadata> {
-    [metadata]: T;
-    new (): Instance;
-    prototype: Instance;
+    [Symbol.metadata]: DecoratorMetadata & {
+        [metadata]: T;
+    };
+    new (): Instance<T>;
+    prototype: Instance<T>;
 }
 export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
-    [metadata]?: T;
-    [init]?: MemberInit[];
+    [Symbol.metadata]?: _DecoratorMetadata<T> | null;
 }
+export declare function isValidMetadata<T extends Metadata = Metadata>(arg: unknown): arg is DecoratorMetadata & {
+    [metadata]: T;
+};
+/**
+ * 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 isStatic<T extends Metadata = Metadata>(arg: unknown): arg is Static<T>;
 export interface Instance<T extends Metadata = Metadata> {
     constructor: Static<T>;

package/dist/src/internal/struct.js

@@ -0,0 +1,24 @@
+export const init = Symbol('struct_init');
+export const metadata = Symbol('struct');
+export function isValidMetadata(arg) {
+    return arg != null && typeof arg == 'object' && metadata in arg;
+}
+/**
+ * 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');
+    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)]);
+}
+export function isInstance(arg) {
+    return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
+}
+export function isStruct(arg) {
+    return isInstance(arg) || isStatic(arg);
+}

package/dist/{struct.d.ts → src/struct.d.ts}

@@ -1,11 +1,11 @@
-import * as Struct from './internal/struct.js';
-import { ClassLike } from './types.js';
 import * as primitive from './internal/primitives.js';
-export { Struct };
+import { DecoratorContext, InstanceLike, Options, Size, StaticLike, type MemberContext } from './internal/struct.js';
+import { ClassLike } from './types.js';
+export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
  */
-export declare function sizeof<T extends primitive.Valid | Struct.StaticLike | Struct.InstanceLike>(type: T): Struct.Size<T>;
+export declare function sizeof<T extends primitive.Valid | StaticLike | InstanceLike>(type: T): Size<T>;
 /**
  * Aligns a number
  */
@@ -13,11 +13,11 @@ export declare function align(value: number, alignment: number): number;
 /**
  * Decorates a class as a struct
  */
-export declare function struct(options?: Partial<Struct.Options>): (target: Struct.StaticLike, _?: ClassDecoratorContext) => void;
+export declare function struct(options?: Partial<Options>): <const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext) => T;
 /**
  * Decorates a class member to be serialized
  */
-export declare function member(type: primitive.Valid | ClassLike, length?: number): (target: object, context?: ClassMemberDecoratorContext | string | symbol) => void;
+export declare function member(type: primitive.Valid | ClassLike, length?: number): <V>(value: V, context: MemberContext) => V;
 /**
  * Serializes a struct into a Uint8Array
  */
@@ -26,13 +26,9 @@ export declare function serialize(instance: unknown): Uint8Array;
  * Deserializes a struct from a Uint8Array
  */
 export declare function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBufferView): void;
-/**
- * Also can be a name when legacy decorators are used
- */
-type Context = string | symbol | ClassMemberDecoratorContext;
 declare function _member<T extends primitive.Valid>(type: T): {
-    (length: number): (target: object, context?: Context) => void;
-    (target: object, context?: Context): void;
+    <const V>(length: number): (value: V, context: MemberContext) => V;
+    <const V>(value: V, context: MemberContext): V;
 };
 /**
  * Shortcut types

package/dist/{struct.js → src/struct.js}

@@ -1,7 +1,7 @@
-import * as Struct from './internal/struct.js';
-import { capitalize } from './string.js';
 import * as primitive from './internal/primitives.js';
-export { Struct };
+import { symbol_metadata, init, isInstance, isStatic, isStruct, metadata, } from './internal/struct.js';
+import { capitalize } from './string.js';
+export * as Struct from './internal/struct.js';
 /**
  * Gets the size in bytes of a type
  */
@@ -13,11 +13,11 @@ export function sizeof(type) {
         }
         return (+primitive.normalize(type).match(primitive.regex)[2] / 8);
     }
-    if (!Struct.isStruct(type)) {
+    if (!isStruct(type)) {
         throw new TypeError('Not a struct');
     }
-    const meta = Struct.isStatic(type) ? type[Struct.metadata] : type.constructor[Struct.metadata];
-    return meta.size;
+    const struct = isStatic(type) ? type : type.constructor;
+    return struct[symbol_metadata(struct)][metadata].size;
 }
 /**
  * Aligns a number
@@ -30,12 +30,14 @@ export function align(value, alignment) {
  */
 export function struct(options = {}) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return function (target, _) {
-        target[Struct.init] ||= [];
+    return function __decorateStruct(target, context) {
+        context.metadata ??= {};
+        context.metadata[init] ||= [];
         let size = 0;
         const members = new Map();
-        for (const { name, type, length } of target[Struct.init]) {
-            if (!primitive.isValid(type) && !Struct.isStatic(type)) {
+        for (const _ of context.metadata[init]) {
+            const { name, type, length } = _;
+            if (!primitive.isValid(type) && !isStatic(type)) {
                 throw new TypeError('Not a valid type: ' + type);
             }
             members.set(name, {
@@ -46,15 +48,16 @@ export function struct(options = {}) {
             size += sizeof(type) * (length || 1);
             size = align(size, options.align || 1);
         }
-        target[Struct.metadata] = { options, members, size };
+        context.metadata[metadata] = { options, members, size };
+        return target;
     };
 }
 /**
  * Decorates a class member to be serialized
  */
 export function member(type, length) {
-    return function (target, context) {
-        let name = typeof context == 'object' ? context.name : context;
+    return function (value, context) {
+        let name = context.name;
         if (typeof name == 'symbol') {
             console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
             name = name.toString();
@@ -62,25 +65,20 @@ export function member(type, length) {
         if (!name) {
             throw new ReferenceError('Invalid name for struct member');
         }
-        if (typeof target != 'object') {
-            throw new TypeError('Invalid member for struct field');
-        }
-        if (!('constructor' in target)) {
-            throw new TypeError('Invalid member for struct field');
-        }
-        const struct = target.constructor;
-        struct[Struct.init] ||= [];
-        struct[Struct.init].push({ name, type, length });
+        context.metadata ??= {};
+        context.metadata[init] ||= [];
+        context.metadata[init].push({ name, type, length });
+        return value;
     };
 }
 /**
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance) {
-    if (!Struct.isInstance(instance)) {
+    if (!isInstance(instance)) {
         throw new TypeError('Can not serialize, not a struct instance');
     }
-    const { options, members } = instance.constructor[Struct.metadata];
+    const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
     const buffer = new Uint8Array(sizeof(instance));
     const view = new DataView(buffer.buffer);
     for (const [name, { type, length, offset }] of members) {
@@ -114,10 +112,10 @@ export function serialize(instance) {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance, _buffer) {
-    if (!Struct.isInstance(instance)) {
+    if (!isInstance(instance)) {
         throw new TypeError('Can not deserialize, not a struct instance');
     }
-    const { options, members } = instance.constructor[Struct.metadata];
+    const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
     const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
     const view = new DataView(buffer.buffer);
     for (const [name, { type, offset, length }] of members) {
@@ -156,13 +154,13 @@ export function deserialize(instance, _buffer) {
     }
 }
 function _member(type) {
-    function _(targetOrLength, context) {
-        if (typeof targetOrLength == 'number') {
-            return member(type, targetOrLength);
+    function _structMemberDecorator(valueOrLength, context) {
+        if (typeof valueOrLength == 'number') {
+            return member(type, valueOrLength);
         }
-        return member(type)(targetOrLength, context);
+        return member(type)(valueOrLength, context);
     }
-    return _;
+    return _structMemberDecorator;
 }
 /**
  * Shortcut types

package/dist/test/struct-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/struct-test.js

@@ -0,0 +1,188 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { writeFileSync } from 'fs';
+import { deserialize, member, serialize, struct, types as t } from '../src/struct.js';
+import { join } from 'path';
+let Header = (() => {
+    var _a;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _magic_start_decorators;
+    let _magic_start_initializers = [];
+    let _magic_start_extraInitializers = [];
+    let _segments_decorators;
+    let _segments_initializers = [];
+    let _segments_extraInitializers = [];
+    let _magic_end_decorators;
+    let _magic_end_initializers = [];
+    let _magic_end_extraInitializers = [];
+    var Header = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _magic_start_decorators = [t.char(4)];
+            _segments_decorators = [(_a = t).uint16.bind(_a)];
+            _magic_end_decorators = [t.char(4)];
+            __esDecorate(null, null, _magic_start_decorators, { kind: "field", name: "magic_start", static: false, private: false, access: { has: obj => "magic_start" in obj, get: obj => obj.magic_start, set: (obj, value) => { obj.magic_start = value; } }, metadata: _metadata }, _magic_start_initializers, _magic_start_extraInitializers);
+            __esDecorate(null, null, _segments_decorators, { kind: "field", name: "segments", static: false, private: false, access: { has: obj => "segments" in obj, get: obj => obj.segments, set: (obj, value) => { obj.segments = value; } }, metadata: _metadata }, _segments_initializers, _segments_extraInitializers);
+            __esDecorate(null, null, _magic_end_decorators, { kind: "field", name: "magic_end", static: false, private: false, access: { has: obj => "magic_end" in obj, get: obj => obj.magic_end, set: (obj, value) => { obj.magic_end = value; } }, metadata: _metadata }, _magic_end_initializers, _magic_end_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Header = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        magic_start = __runInitializers(this, _magic_start_initializers, 'test');
+        segments = (__runInitializers(this, _magic_start_extraInitializers), __runInitializers(this, _segments_initializers, 0));
+        magic_end = (__runInitializers(this, _segments_extraInitializers), __runInitializers(this, _magic_end_initializers, 'end'));
+        constructor() {
+            __runInitializers(this, _magic_end_extraInitializers);
+        }
+    };
+    return Header = _classThis;
+})();
+let AnotherHeader = (() => {
+    var _a;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Header;
+    let __plus_decorators;
+    let __plus_initializers = [];
+    let __plus_extraInitializers = [];
+    var AnotherHeader = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __plus_decorators = [(_a = t).uint64.bind(_a)];
+            __esDecorate(null, null, __plus_decorators, { kind: "field", name: "_plus", static: false, private: false, access: { has: obj => "_plus" in obj, get: obj => obj._plus, set: (obj, value) => { obj._plus = value; } }, metadata: _metadata }, __plus_initializers, __plus_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AnotherHeader = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        _plus = __runInitializers(this, __plus_initializers, 0x12345678);
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, __plus_extraInitializers);
+        }
+    };
+    return AnotherHeader = _classThis;
+})();
+let Segment = (() => {
+    var _a;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
+    var Segment = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [(_a = t).uint64.bind(_a)];
+            _data_decorators = [t.uint32(64)];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Segment = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, 0x021);
+        data = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _data_initializers, []));
+        constructor() {
+            __runInitializers(this, _data_extraInitializers);
+        }
+    };
+    return Segment = _classThis;
+})();
+let BinObject = (() => {
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _comment_decorators;
+    let _comment_initializers = [];
+    let _comment_extraInitializers = [];
+    let _segments_decorators;
+    let _segments_initializers = [];
+    let _segments_extraInitializers = [];
+    var BinObject = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _header_decorators = [member(AnotherHeader)];
+            _comment_decorators = [t.char(32)];
+            _segments_decorators = [member(Segment, 16)];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _comment_decorators, { kind: "field", name: "comment", static: false, private: false, access: { has: obj => "comment" in obj, get: obj => obj.comment, set: (obj, value) => { obj.comment = value; } }, metadata: _metadata }, _comment_initializers, _comment_extraInitializers);
+            __esDecorate(null, null, _segments_decorators, { kind: "field", name: "segments", static: false, private: false, access: { has: obj => "segments" in obj, get: obj => obj.segments, set: (obj, value) => { obj.segments = value; } }, metadata: _metadata }, _segments_initializers, _segments_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BinObject = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, new AnotherHeader());
+        comment = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _comment_initializers, ''));
+        segments = (__runInitializers(this, _comment_extraInitializers), __runInitializers(this, _segments_initializers, [new Segment()]));
+        constructor() {
+            __runInitializers(this, _segments_extraInitializers);
+        }
+    };
+    return BinObject = _classThis;
+})();
+const obj = new BinObject();
+obj.comment = '!!! Omg, hi! this is cool' + '.'.repeat(32);
+obj.header.segments = 1;
+const segment = new Segment();
+segment.data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+serialize(segment);
+obj.segments = [segment];
+const bin = serialize(obj);
+writeFileSync(join(import.meta.dirname, '../tmp/bin'), bin);
+const omg = new BinObject();
+deserialize(omg, bin);
+console.log(omg);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.5.10",
+	"version": "0.6.1",
 	"description": "Typescript utilies",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/internal/struct.ts

@@ -7,9 +7,7 @@ export interface MemberInit {
 	length?: number;
 }
 
-export const init = Symbol('struct_init');
-
-export type init = typeof init;
+export const init: unique symbol = Symbol('struct_init');
 
 /**
  * Options for struct initialization
@@ -31,23 +29,53 @@ export interface Metadata {
 	size: number;
 }
 
-export const metadata = Symbol('struct');
+export const metadata: unique symbol = Symbol('struct');
 
-export type metadata = typeof metadata;
+export interface _DecoratorMetadata<T extends Metadata = Metadata> extends DecoratorMetadata {
+	[metadata]?: T;
+	[init]?: MemberInit[];
+}
+
+export interface DecoratorContext<T extends Metadata = Metadata> {
+	metadata: _DecoratorMetadata<T>;
+}
+
+export type MemberContext = ClassMemberDecoratorContext & DecoratorContext;
 
 export interface Static<T extends Metadata = Metadata> {
-	[metadata]: T;
-	new (): Instance;
-	prototype: Instance;
+	[Symbol.metadata]: DecoratorMetadata & {
+		[metadata]: T;
+	};
+	new (): Instance<T>;
+	prototype: Instance<T>;
 }
 
 export interface StaticLike<T extends Metadata = Metadata> extends ClassLike {
-	[metadata]?: T;
-	[init]?: MemberInit[];
+	[Symbol.metadata]?: _DecoratorMetadata<T> | null;
+}
+
+export function isValidMetadata<T extends Metadata = Metadata>(
+	arg: unknown
+): arg is DecoratorMetadata & {
+	[metadata]: T;
+} {
+	return arg != null && typeof arg == 'object' && metadata in arg;
+}
+
+/**
+ * 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');
+	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' && metadata in arg;
+	return typeof arg == 'function' && symbol_metadata(arg as ClassLike) in arg && isValidMetadata(arg[symbol_metadata(arg as ClassLike)]);
 }
 
 export interface Instance<T extends Metadata = Metadata> {
@@ -59,7 +87,7 @@ export interface InstanceLike<T extends Metadata = Metadata> {
 }
 
 export function isInstance<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> {
-	return metadata in (arg?.constructor || {});
+	return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
 
 export function isStruct<T extends Metadata = Metadata>(arg: unknown): arg is Instance<T> | Static<T> {

package/src/struct.ts

@@ -1,29 +1,44 @@
-import * as Struct from './internal/struct.js';
+import * as primitive from './internal/primitives.js';
+import {
+	DecoratorContext,
+	InstanceLike,
+	MemberInit,
+	Metadata,
+	Options,
+	Size,
+	StaticLike,
+	symbol_metadata,
+	init,
+	isInstance,
+	isStatic,
+	isStruct,
+	metadata,
+	type MemberContext,
+} from './internal/struct.js';
 import { capitalize } from './string.js';
 import { ClassLike } from './types.js';
-import * as primitive from './internal/primitives.js';
-export { Struct };
+export * as Struct from './internal/struct.js';
 
 /**
  * Gets the size in bytes of a type
  */
-export function sizeof<T extends primitive.Valid | Struct.StaticLike | Struct.InstanceLike>(type: T): Struct.Size<T> {
+export function sizeof<T extends primitive.Valid | StaticLike | InstanceLike>(type: T): Size<T> {
 	// primitive
 	if (typeof type == 'string') {
 		if (!primitive.isValid(type)) {
 			throw new TypeError('Invalid primitive type: ' + type);
 		}
 
-		return (+primitive.normalize(type).match(primitive.regex)![2] / 8) as Struct.Size<T>;
+		return (+primitive.normalize(type).match(primitive.regex)![2] / 8) as Size<T>;
 	}
 
-	if (!Struct.isStruct(type)) {
+	if (!isStruct(type)) {
 		throw new TypeError('Not a struct');
 	}
 
-	const meta: Struct.Metadata = Struct.isStatic(type) ? type[Struct.metadata] : type.constructor[Struct.metadata];
+	const struct = isStatic(type) ? type : type.constructor;
 
-	return meta.size as Struct.Size<T>;
+	return struct[symbol_metadata(struct)][metadata].size as Size<T>;
 }
 
 /**
@@ -36,14 +51,16 @@ export function align(value: number, alignment: number): number {
 /**
  * Decorates a class as a struct
  */
-export function struct(options: Partial<Struct.Options> = {}) {
+export function struct(options: Partial<Options> = {}) {
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	return function (target: Struct.StaticLike, _?: ClassDecoratorContext) {
-		target[Struct.init] ||= [];
+	return function __decorateStruct<const T extends StaticLike>(target: T, context: ClassDecoratorContext & DecoratorContext): T {
+		context.metadata ??= {};
+		context.metadata[init] ||= [];
 		let size = 0;
 		const members = new Map();
-		for (const { name, type, length } of target[Struct.init]) {
-			if (!primitive.isValid(type) && !Struct.isStatic(type)) {
+		for (const _ of context.metadata[init]) {
+			const { name, type, length } = _;
+			if (!primitive.isValid(type) && !isStatic(type)) {
 				throw new TypeError('Not a valid type: ' + type);
 			}
 			members.set(name, {
@@ -55,7 +72,8 @@ export function struct(options: Partial<Struct.Options> = {}) {
 			size = align(size, options.align || 1);
 		}
 
-		target[Struct.metadata] = { options, members, size } satisfies Struct.Metadata;
+		context.metadata[metadata] = { options, members, size } satisfies Metadata;
+		return target;
 	};
 }
 
@@ -63,8 +81,8 @@ export function struct(options: Partial<Struct.Options> = {}) {
  * Decorates a class member to be serialized
  */
 export function member(type: primitive.Valid | ClassLike, length?: number) {
-	return function (target: object, context?: ClassMemberDecoratorContext | string | symbol) {
-		let name = typeof context == 'object' ? context.name : context;
+	return function <V>(value: V, context: MemberContext): V {
+		let name = context.name;
 		if (typeof name == 'symbol') {
 			console.warn('Symbol used for struct member name will be coerced to string: ' + name.toString());
 			name = name.toString();
@@ -74,18 +92,10 @@ export function member(type: primitive.Valid | ClassLike, length?: number) {
 			throw new ReferenceError('Invalid name for struct member');
 		}
 
-		if (typeof target != 'object') {
-			throw new TypeError('Invalid member for struct field');
-		}
-
-		if (!('constructor' in target)) {
-			throw new TypeError('Invalid member for struct field');
-		}
-
-		const struct = (target as Struct.InstanceLike).constructor;
-
-		struct[Struct.init] ||= [];
-		struct[Struct.init].push({ name, type, length } satisfies Struct.MemberInit);
+		context.metadata ??= {};
+		context.metadata[init] ||= [];
+		context.metadata[init].push({ name, type, length } satisfies MemberInit);
+		return value;
 	};
 }
 
@@ -93,10 +103,10 @@ export function member(type: primitive.Valid | ClassLike, length?: number) {
  * Serializes a struct into a Uint8Array
  */
 export function serialize(instance: unknown): Uint8Array {
-	if (!Struct.isInstance(instance)) {
+	if (!isInstance(instance)) {
 		throw new TypeError('Can not serialize, not a struct instance');
 	}
-	const { options, members } = instance.constructor[Struct.metadata];
+	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
 
 	const buffer = new Uint8Array(sizeof(instance));
 	const view = new DataView(buffer.buffer);
@@ -139,10 +149,10 @@ export function serialize(instance: unknown): Uint8Array {
  * Deserializes a struct from a Uint8Array
  */
 export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBufferView) {
-	if (!Struct.isInstance(instance)) {
+	if (!isInstance(instance)) {
 		throw new TypeError('Can not deserialize, not a struct instance');
 	}
-	const { options, members } = instance.constructor[Struct.metadata];
+	const { options, members } = instance.constructor[symbol_metadata(instance.constructor)][metadata];
 
 	const buffer = new Uint8Array('buffer' in _buffer ? _buffer.buffer : _buffer);
 
@@ -191,22 +201,17 @@ export function deserialize(instance: unknown, _buffer: ArrayBuffer | ArrayBuffe
 	}
 }
 
-/**
- * Also can be a name when legacy decorators are used
- */
-type Context = string | symbol | ClassMemberDecoratorContext;
-
 function _member<T extends primitive.Valid>(type: T) {
-	function _(length: number): (target: object, context?: Context) => void;
-	function _(target: object, context?: Context): void;
-	function _(targetOrLength: object | number, context?: Context) {
-		if (typeof targetOrLength == 'number') {
-			return member(type, targetOrLength);
+	function _structMemberDecorator<const V>(length: number): (value: V, context: MemberContext) => V;
+	function _structMemberDecorator<const V>(value: V, context: MemberContext): V;
+	function _structMemberDecorator<const V>(valueOrLength: V | number, context?: MemberContext): V | ((value: V, context: MemberContext) => V) {
+		if (typeof valueOrLength == 'number') {
+			return member(type, valueOrLength);
 		}
 
-		return member(type)(targetOrLength, context);
+		return member(type)(valueOrLength, context!);
 	}
-	return _;
+	return _structMemberDecorator;
 }
 
 /**

package/tsconfig.json

@@ -10,13 +10,12 @@
 		"esModuleInterop": true,
 		"noImplicitThis": true,
 		"declaration": true,
-		"experimentalDecorators": true,
 		"strict": true
 	},
 	"typedocOptions": {
 		"entryPoints": ["src/index.ts"],
 		"out": "docs"
 	},
-	"include": ["./src/**/*.ts"],
+	"include": ["./src/**/*.ts", "./test/**/*.ts"],
 	"exclude": ["node_modules"]
 }

package/dist/internal/struct.js

@@ -1,11 +0,0 @@
-export const init = Symbol('struct_init');
-export const metadata = Symbol('struct');
-export function isStatic(arg) {
-    return typeof arg == 'function' && metadata in arg;
-}
-export function isInstance(arg) {
-    return metadata in (arg?.constructor || {});
-}
-export function isStruct(arg) {
-    return isInstance(arg) || isStatic(arg);
-}