utilium 0.5.9 → 0.6.0

package/dist/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/internal/struct.js

@@ -1,10 +1,23 @@
 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' && metadata in arg;
+    return typeof arg == 'function' && symbol_metadata(arg) in arg && isValidMetadata(arg[symbol_metadata(arg)]);
 }
 export function isInstance(arg) {
-    return metadata in (arg?.constructor || {});
+    return arg != null && typeof arg == 'object' && isStatic(arg.constructor);
 }
 export function isStruct(arg) {
     return isInstance(arg) || isStatic(arg);

package/dist/list.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'eventemitter3';
 export declare class List<T> extends EventEmitter<'update'> implements Set<T>, RelativeIndexable<T> {
     readonly [Symbol.toStringTag] = "List";
+    constructor(values?: readonly T[] | Iterable<T> | null);
     protected data: Set<T>;
     array(): T[];
     json(): string;
@@ -15,6 +16,13 @@ export declare class List<T> extends EventEmitter<'update'> implements Set<T>, R
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
+    union<U>(other: ReadonlySetLike<U>): List<T | U>;
+    intersection<U>(other: ReadonlySetLike<U>): List<T & U>;
+    difference<U>(other: ReadonlySetLike<U>): List<T>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): List<T | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
     forEach(callbackfn: (value: T, value2: T, list: List<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     get size(): number;

package/dist/list.js

@@ -1,6 +1,12 @@
 import { EventEmitter } from 'eventemitter3';
 export class List extends EventEmitter {
     [Symbol.toStringTag] = 'List';
+    constructor(values) {
+        super();
+        if (values) {
+            this.push(...values);
+        }
+    }
     data = new Set();
     array() {
         return [...this.data];
@@ -74,6 +80,27 @@ export class List extends EventEmitter {
         this.emit('update');
         return success;
     }
+    union(other) {
+        return new List(this.data.union(other));
+    }
+    intersection(other) {
+        return new List(this.data.intersection(other));
+    }
+    difference(other) {
+        return new List(this.data.difference(other));
+    }
+    symmetricDifference(other) {
+        return new List(this.data.symmetricDifference(other));
+    }
+    isSubsetOf(other) {
+        return this.data.isSubsetOf(other);
+    }
+    isSupersetOf(other) {
+        return this.data.isSupersetOf(other);
+    }
+    isDisjointFrom(other) {
+        return this.data.isDisjointFrom(other);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     forEach(callbackfn, thisArg) {
         this.data.forEach((v1, v2) => callbackfn.call(thisArg, v1, v2, this));

package/dist/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

@@ -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,13 @@ 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[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 +47,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 +64,19 @@ 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[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 +110,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 +152,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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "0.5.9",
+	"version": "0.6.0",
 	"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/list.ts

@@ -3,6 +3,13 @@ import { EventEmitter } from 'eventemitter3';
 export class List<T> extends EventEmitter<'update'> implements Set<T>, RelativeIndexable<T> {
 	public readonly [Symbol.toStringTag] = 'List';
 
+	public constructor(values?: readonly T[] | Iterable<T> | null) {
+		super();
+		if (values) {
+			this.push(...values);
+		}
+	}
+
 	protected data = new Set<T>();
 
 	public array(): T[] {
@@ -96,6 +103,34 @@ export class List<T> extends EventEmitter<'update'> implements Set<T>, RelativeI
 		return success;
 	}
 
+	public union<U>(other: ReadonlySetLike<U>): List<T | U> {
+		return new List(this.data.union(other));
+	}
+
+	public intersection<U>(other: ReadonlySetLike<U>): List<T & U> {
+		return new List(this.data.intersection(other));
+	}
+
+	public difference<U>(other: ReadonlySetLike<U>): List<T> {
+		return new List(this.data.difference(other));
+	}
+
+	public symmetricDifference<U>(other: ReadonlySetLike<U>): List<T | U> {
+		return new List(this.data.symmetricDifference(other));
+	}
+
+	public isSubsetOf(other: ReadonlySetLike<unknown>): boolean {
+		return this.data.isSubsetOf(other);
+	}
+
+	public isSupersetOf(other: ReadonlySetLike<unknown>): boolean {
+		return this.data.isSupersetOf(other);
+	}
+
+	public isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {
+		return this.data.isDisjointFrom(other);
+	}
+
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	public forEach(callbackfn: (value: T, value2: T, list: List<T>) => void, thisArg?: any): void {
 		this.data.forEach((v1, v2) => callbackfn.call(thisArg, v1, v2, this));

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,15 @@ 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[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 +71,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 +80,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 +91,9 @@ 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[init] ||= [];
+		context.metadata[init].push({ name, type, length } satisfies MemberInit);
+		return value;
 	};
 }
 
@@ -93,10 +101,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 +147,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 +199,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

@@ -1,6 +1,6 @@
 {
 	"compilerOptions": {
-		"lib": ["ES2023"],
+		"lib": ["ESNext"],
 		"module": "NodeNext",
 		"target": "ES2023",
 		"moduleResolution": "NodeNext",
@@ -10,7 +10,6 @@
 		"esModuleInterop": true,
 		"noImplicitThis": true,
 		"declaration": true,
-		"experimentalDecorators": true,
 		"strict": true
 	},
 	"typedocOptions": {