@the-w1zard/dx 1.0.8 → 1.0.9

package/package.json

@@ -1,28 +1,43 @@
 {
   "name": "@the-w1zard/dx",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "sideEffects": false,
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
     ".": {
-      "default": "./src/index.ts",
+      "default": "./dist/index.js",
       "types": "./src/dx.d.ts"
     }
   },
   "files": [
-    "src"
+    "dist",
+    "./src/dx.d.ts"
   ],
   "scripts": {
-    "build": "tsc",
-    "check": "tsc --noEmit"
+    "1": "git add .",
+    "2": "git commit -m 'first commit'",
+    "3": "git push",
+    "4": "npm version patch",
+    "5": "git push --tags",
+    "6": "npm publish --access public",
+    "build": "rspack build",
+    "dev": "rspack serve",
+    "check": "tsc --noEmit",
+    "*": "npm run 1 && npm run 2 && npm run 3 && npm run 4 && npm run 5 && npm run 6 && npm run *"
   },
   "devDependencies": {
+    "@rspack/cli": "^2.3.1",
+    "@rspack/core": "^2.3.1",
+    "@rspack/dev-server": "^2.2.2",
     "@tsconfig/node-lts": "^24.0.0",
     "@types/node": "^24.0.0",
     "typescript": "^6.0.0"
   },
   "dependencies": {
+    "@babel/parser": "^8.1.0",
+    "@babel/traverse": "^8.1.0",
+    "@babel/types": "^8.1.0",
     "@the-w1zard/alias_types": "^1.0.2"
   }
 }

package/src/dx.d.ts

@@ -130,7 +130,9 @@ declare global {
 		clone(): this;
 		equals(other: Map<H, T>): B;
 	}
+	interface M2B<H = A, T = A> extends M2<H, T> {}
 	interface M2I<H = A, T = A> extends M2<H, T> {}
+	interface M2BI<H = A, T = A> extends M2B<H, T> {}
 	interface B2B {
 		set(pid: number, value: boolean): void 
 		true(pid: number, value: boolean) 
@@ -455,13 +457,11 @@ declare global {
 	interface D2 extends Date {
 		clone(): D2;
 		isValid(): B;
-	
 		month(): N;
 		dateOfWeek(): N;
 		dayOfYear(): N;
 		quarter(): N;
 		unix(): N;
-	
 		addMs(ms: N): D2;
 		addSeconds(seconds: N): D2;
 		addMinutes(minutes: N): D2;
@@ -470,11 +470,9 @@ declare global {
 		addWeeks(weeks: N): D2;
 		addMonths(months: N): D2;
 		addYears(years: N): D2;
-	
 		subDays(days: N): D2;
 		subMonths(months: N): D2;
 		subYears(years: N): D2;
-	
 		startOfDay(): D2;
 		endOfDay(): D2;
 		startOfWeek(): D2;
@@ -485,33 +483,27 @@ declare global {
 		endOfQuarter(): D2;
 		startOfYear(): D2;
 		endOfYear(): D2;
-	
 		daysInMonth(): N;
 		daysInYear(): N;
 		isLeapYear(): B;
 		isWeekend(): B;
 		isWeekday(): B;
-	
 		isBefore(date: D): B;
 		isAfter(date: D): B;
 		isEqual(date: D): B;
 		isBetween(start: D, end: D): B;
-	
 		diffMs(date: D): N;
 		diffSeconds(date: D): N;
 		diffMinutes(date: D): N;
 		diffHours(date: D): N;
 		diffDays(date: D): N;
-	
 		sameDay(date: D): B;
 		sameMonth(date: D): B;
 		sameYear(date: D): B;
-	
 		toUnixMs(): N;
 		toUnix(): N;
 		toD2(): D2;
 		toLocalString(format?: A): S;
-	
 		subWeeks(weeks: N): D2;
 		endOfWeek(weekStartsOn?: N): D2;
 		at(hour: N, minute?: N, second?: N, ms?: N): D2;

package/src/array.js

@@ -1,221 +0,0 @@
-export class A2I extends Array {
-    constructor(...items) {
-        super(...items);
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-    static get [Symbol.species]() {
-        return Array;
-    }
-    static from(arrayLike) {
-        return new A2I(...Array.from(arrayLike));
-    }
-    static of(...items) {
-        return new A2I(...items);
-    }
-    first() {
-        return this[0];
-    }
-    last() {
-        return this[this.length - 1];
-    }
-    isEmpty() {
-        return this.length === 0;
-    }
-    isNotEmpty() {
-        return this.length !== 0;
-    }
-    clear() {
-        this.length = 0;
-        return this;
-    }
-    clone() {
-        return new A2I(...this);
-    }
-    unique() {
-        return new A2I(...new Set(this));
-    }
-    compact() {
-        return new A2(...this.filter((value) => value != null));
-    }
-    take(count) {
-        return new A2I(...this.slice(0, Math.max(0, count)));
-    }
-    takeLast(count) {
-        return new A2I(...this.slice(Math.max(0, this.length - Math.max(0, count))));
-    }
-    drop(count) {
-        return new A2I(...this.slice(Math.max(0, count)));
-    }
-    dropLast(count) {
-        return new A2I(...this.slice(0, Math.max(0, this.length - Math.max(0, count))));
-    }
-    chunk(size) {
-        if (!Number.isInteger(size) || size < 1) {
-            throw new RangeError("Chunk size must be a positive integer.");
-        }
-        const result = new A2();
-        for (let i = 0; i < this.length; i += size) {
-            result.push(new A2I(...this.slice(i, i + size)));
-        }
-        return result;
-    }
-    flatten(depth = Infinity) {
-        return new A2(...this.flat(depth));
-    }
-    flatMap(callback) {
-        return new A2(...this.flatMap((value, index) => callback(value, index, this)));
-    }
-    distinctBy(callback) {
-        const seen = new Set();
-        const result = new A2I();
-        this.forEach((value, index) => {
-            const key = callback(value, index);
-            if (!seen.has(key)) {
-                seen.add(key);
-                result.push(value);
-            }
-        });
-        return result;
-    }
-    groupBy(callback) {
-        const result = new Map();
-        this.forEach((value, index) => {
-            const key = callback(value, index);
-            let group = result.get(key);
-            if (!group) {
-                group = new A2I();
-                result.set(key, group);
-            }
-            group.push(value);
-        });
-        return result;
-    }
-    partition(callback) {
-        const yes = new A2I();
-        const no = new A2I();
-        this.forEach((value, index) => {
-            (callback(value, index) ? yes : no).push(value);
-        });
-        return [yes, no];
-    }
-    insert(index, ...items) {
-        this.splice(index, 0, ...items);
-        return this;
-    }
-    removeAt(index) {
-        const normalized = index < 0 ? this.length + index : index;
-        if (normalized < 0 || normalized >= this.length) {
-            return undefined;
-        }
-        return this.splice(normalized, 1)[0];
-    }
-    remove(value) {
-        const index = this.indexOf(value);
-        if (index === -1) {
-            return false;
-        }
-        this.splice(index, 1);
-        return true;
-    }
-    removeAll(value) {
-        let removed = 0;
-        for (let i = this.length - 1; i >= 0; i--) {
-            if (Object.is(this[i], value)) {
-                this.splice(i, 1);
-                removed++;
-            }
-        }
-        return removed;
-    }
-    replaceAt(index, value) {
-        const normalized = index < 0 ? this.length + index : index;
-        if (normalized < 0 || normalized >= this.length) {
-            return undefined;
-        }
-        const previous = this[normalized];
-        this[normalized] = value;
-        return previous;
-    }
-    move(from, to) {
-        const source = from < 0 ? this.length + from : from;
-        const target = to < 0 ? this.length + to : to;
-        if (source < 0 || source >= this.length ||
-            target < 0 || target >= this.length ||
-            source === target) {
-            return this;
-        }
-        const [item] = this.splice(source, 1);
-        this.splice(target, 0, item);
-        return this;
-    }
-    swap(first, second) {
-        const a = first < 0 ? this.length + first : first;
-        const b = second < 0 ? this.length + second : second;
-        if (a < 0 || a >= this.length ||
-            b < 0 || b >= this.length) {
-            return this;
-        }
-        [this[a], this[b]] = [this[b], this[a]];
-        return this;
-    }
-    sample() {
-        if (this.length === 0) {
-            return undefined;
-        }
-        return this[Math.floor(Math.random() * this.length)];
-    }
-    shuffle() {
-        for (let i = this.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [this[i], this[j]] = [this[j], this[i]];
-        }
-        return this;
-    }
-    countBy(callback) {
-        let count = 0;
-        this.forEach((value, index) => {
-            if (callback(value, index))
-                count++;
-        });
-        return count;
-    }
-    sum(callback) {
-        let total = 0;
-        this.forEach((value, index) => {
-            total += callback ? callback(value, index) : Number(value);
-        });
-        return total;
-    }
-    average(callback) {
-        return (this.length === 0 ? NaN : this.sum(callback) / this.length);
-    }
-    min(callback) {
-        if (this.length === 0)
-            return undefined;
-        return this.reduce((best, value, index) => {
-            const current = callback ? callback(value, index) : Number(value);
-            const bestValue = callback ? callback(best, this.indexOf(best)) : Number(best);
-            return current < bestValue ? value : best;
-        });
-    }
-    max(callback) {
-        if (this.length === 0)
-            return undefined;
-        return this.reduce((best, value, index) => {
-            const current = callback ? callback(value, index) : Number(value);
-            const bestValue = callback ? callback(best, this.indexOf(best)) : Number(best);
-            return current > bestValue ? value : best;
-        });
-    }
-    equals(array) {
-        return this.length === array.length &&
-            this.every((value, index) => Object.is(value, array[index]));
-    }
-    includesAll(values) {
-        return values.every(value => this.includes(value));
-    }
-    intersects(values) {
-        return values.some(value => this.includes(value));
-    }
-}
-globalThis.A2 = A2I;

package/src/array.ts

@@ -1,301 +0,0 @@
-
-
-export class A2I<T = A> extends Array<T> implements A2<T> {
-    constructor(...items: T[]) {
-        super(...items);
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-
-    static get [Symbol.species](): ArrayConstructor {
-        return Array;
-    }
-
-    static from<T>(arrayLike: ArrayLike<T> | Iterable<T>): A2<T> {
-        return new A2I<T>(...Array.from(arrayLike));
-    }
-
-    static of<T>(...items: T[]): A2<T> {
-        return new A2I<T>(...items);
-    }
-
-    first(): T | UD {
-        return this[0];
-    }
-
-    last(): T | UD {
-        return this[this.length - 1];
-    }
-
-    isEmpty(): B {
-        return this.length === 0;
-    }
-
-    isNotEmpty(): B {
-        return this.length !== 0;
-    }
-
-    clear(): this {
-        this.length = 0;
-        return this;
-    }
-
-    clone(): A2<T> {
-        return new A2I<T>(...this);
-    }
-
-    unique(): A2<T> {
-        return new A2I<T>(...new Set(this));
-    }
-
-    compact(): A2<NonNullable<T>> {
-        return new A2<NonNullable<T>>(
-            ...this.filter((value): value is NonNullable<T> => value != null)
-        );
-    }
-
-    take(count: N): A2<T> {
-        return new A2I<T>(...this.slice(0, Math.max(0, count)));
-    }
-
-    takeLast(count: N): A2<T> {
-        return new A2I<T>(...this.slice(Math.max(0, this.length - Math.max(0, count))));
-    }
-
-    drop(count: N): A2<T> {
-        return new A2I<T>(...this.slice(Math.max(0, count)));
-    }
-
-    dropLast(count: N): A2<T> {
-        return new A2I<T>(...this.slice(0, Math.max(0, this.length - Math.max(0, count))));
-    }
-
-    chunk(size: N): A2<A2<T>> {
-        if (!Number.isInteger(size) || size < 1) {
-            throw new RangeError("Chunk size must be a positive integer.");
-        }
-
-        const result = new A2<A2<T>>();
-
-        for (let i = 0; i < this.length; i += size) {
-            result.push(new A2I<T>(...this.slice(i, i + size)));
-        }
-
-        return result;
-    }
-
-    flatten<X>(depth: N = Infinity): A2<X> {
-        return new A2<X>(...this.flat(depth) as X[]);
-    }
-
-    flatMap<U>(callback: (value: T, index: N, array: this) => U | readonly U[]): A2<U> {
-        return new A2<U>(
-            ...this.flatMap((value, index) => callback(value, index as N, this))
-        );
-    }
-
-    distinctBy<K>(callback: (value: T, index: N) => K): A2<T> {
-        const seen = new Set<K>();
-        const result = new A2I<T>();
-
-        this.forEach((value, index) => {
-            const key = callback(value, index as N);
-
-            if (!seen.has(key)) {
-                seen.add(key);
-                result.push(value);
-            }
-        });
-
-        return result;
-    }
-
-    groupBy<K extends PropertyKey>(callback: (value: T, index: N) => K): Map<K, A2<T>> {
-        const result = new Map<K, A2<T>>();
-
-        this.forEach((value, index) => {
-            const key = callback(value, index as N);
-            let group = result.get(key);
-
-            if (!group) {
-                group = new A2I<T>();
-                result.set(key, group);
-            }
-
-            group.push(value);
-        });
-
-        return result;
-    }
-
-    partition(callback: (value: T, index: N) => B): [A2<T>, A2<T>] {
-        const yes = new A2I<T>();
-        const no = new A2I<T>();
-
-        this.forEach((value, index) => {
-            (callback(value, index as N) ? yes : no).push(value);
-        });
-
-        return [yes, no];
-    }
-
-    insert(index: N, ...items: T[]): this {
-        this.splice(index, 0, ...items);
-        return this;
-    }
-
-    removeAt(index: N): T | UD {
-        const normalized = index < 0 ? this.length + index : index;
-
-        if (normalized < 0 || normalized >= this.length) {
-            return undefined;
-        }
-
-        return this.splice(normalized, 1)[0];
-    }
-
-    remove(value: T): B {
-        const index = this.indexOf(value);
-
-        if (index === -1) {
-            return false;
-        }
-
-        this.splice(index, 1);
-        return true;
-    }
-
-    removeAll(value: T): N {
-        let removed = 0;
-
-        for (let i = this.length - 1; i >= 0; i--) {
-            if (Object.is(this[i], value)) {
-                this.splice(i, 1);
-                removed++;
-            }
-        }
-
-        return removed as N;
-    }
-
-    replaceAt(index: N, value: T): T | UD {
-        const normalized = index < 0 ? this.length + index : index;
-
-        if (normalized < 0 || normalized >= this.length) {
-            return undefined;
-        }
-
-        const previous = this[normalized];
-        this[normalized] = value;
-        return previous;
-    }
-
-    move(from: N, to: N): this {
-        const source = from < 0 ? this.length + from : from;
-        const target = to < 0 ? this.length + to : to;
-
-        if (
-            source < 0 || source >= this.length ||
-            target < 0 || target >= this.length ||
-            source === target
-        ) {
-            return this;
-        }
-
-        const [item] = this.splice(source, 1);
-        this.splice(target, 0, item);
-        return this;
-    }
-
-    swap(first: N, second: N): this {
-        const a = first < 0 ? this.length + first : first;
-        const b = second < 0 ? this.length + second : second;
-
-        if (
-            a < 0 || a >= this.length ||
-            b < 0 || b >= this.length
-        ) {
-            return this;
-        }
-
-        [this[a], this[b]] = [this[b], this[a]];
-        return this;
-    }
-
-    sample(): T | UD {
-        if (this.length === 0) {
-            return undefined;
-        }
-
-        return this[Math.floor(Math.random() * this.length)];
-    }
-
-    shuffle(): this {
-        for (let i = this.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [this[i], this[j]] = [this[j], this[i]];
-        }
-
-        return this;
-    }
-
-    countBy(callback: (value: T, index: N) => B): N {
-        let count = 0;
-
-        this.forEach((value, index) => {
-            if (callback(value, index as N)) count++;
-        });
-
-        return count as N;
-    }
-
-    sum(callback?: (value: T, index: N) => N): N {
-        let total = 0;
-
-        this.forEach((value, index) => {
-            total += callback ? callback(value, index as N) : Number(value);
-        });
-
-        return total as N;
-    }
-
-    average(callback?: (value: T, index: N) => N): N {
-        return (this.length === 0 ? NaN : this.sum(callback) / this.length) as N;
-    }
-
-    min(callback?: (value: T, index: N) => N): T | UD {
-        if (this.length === 0) return undefined;
-
-        return this.reduce((best, value, index) => {
-            const current = callback ? callback(value, index as N) : Number(value);
-            const bestValue = callback ? callback(best, this.indexOf(best) as N) : Number(best);
-
-            return current < bestValue ? value : best;
-        });
-    }
-
-    max(callback?: (value: T, index: N) => N): T | UD {
-        if (this.length === 0) return undefined;
-
-        return this.reduce((best, value, index) => {
-            const current = callback ? callback(value, index as N) : Number(value);
-            const bestValue = callback ? callback(best, this.indexOf(best) as N) : Number(best);
-
-            return current > bestValue ? value : best;
-        });
-    }
-
-    equals(array: readonly T[]): B {
-        return this.length === array.length &&
-            this.every((value, index) => Object.is(value, array[index]));
-    }
-
-    includesAll(values: readonly T[]): B {
-        return values.every(value => this.includes(value));
-    }
-
-    intersects(values: readonly T[]): B {
-        return values.some(value => this.includes(value));
-    }
-}
-
-globalThis.A2 = A2I;

package/src/boolean_byte.js

@@ -1,22 +0,0 @@
-/*  ==========================================================================================================================
-    SITH - PURE BINARY BYTE_BOOL
-    Replaces boolean properties and boolean maps with a zero-allocation, PID-indexed Uint8Array lane.
-    ================================================================================================================    ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [BYTE_BOOL] */
-export class B2BI {
-    flags;
-    constructor(maxParticles = 8192) {
-        this.flags = new Uint8Array(maxParticles);
-    } /** Set a boolean flag for a PID. O(1) time complexity. */
-    set(pid, value) { this.flags[pid] = value ? 1 : 0; }
-    true(pid, value) { this.flags[pid] = 1; }
-    false(pid, value) { this.flags[pid] = 0; }
-    /** Get the boolean state for a PID. O(1) time complexity. */
-    get(pid) { return this.flags[pid] === 1; }
-    /** Toggle the boolean state for a PID. O(1) time complexity. */
-    toggle(pid) {
-        this.flags[pid] = this.flags[pid] === 1 ? 0 : 1;
-        return this.flags[pid] === 1;
-    } /** Clear all flags instantly without reallocating memory. */
-    clear() { this.flags.fill(0); }
-}
-globalThis.B2B = B2BI;

package/src/boolean_byte.ts

@@ -1,23 +0,0 @@
-/*  ==========================================================================================================================
-    SITH - PURE BINARY BYTE_BOOL
-    Replaces boolean properties and boolean maps with a zero-allocation, PID-indexed Uint8Array lane.
-    ================================================================================================================    ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [BYTE_BOOL] */
-
-export class B2BI {
-    public readonly flags: Uint8Array;
-    constructor(maxParticles: number = 8192) {
-        this.flags = new Uint8Array(maxParticles);
-    }/** Set a boolean flag for a PID. O(1) time complexity. */
-    public set(pid: number, value: boolean): void { this.flags[pid] = value ? 1 : 0; }
-    public true(pid: number, value: boolean) { this.flags[pid] = 1 }
-    public false(pid: number, value: boolean) { this.flags[pid] = 0 }
-    /** Get the boolean state for a PID. O(1) time complexity. */
-    public get(pid: number): boolean { return this.flags[pid] === 1; }
-    /** Toggle the boolean state for a PID. O(1) time complexity. */
-    public toggle(pid: number): boolean {
-        this.flags[pid] = this.flags[pid] === 1 ? 0 : 1;
-        return this.flags[pid] === 1;
-    }/** Clear all flags instantly without reallocating memory. */
-    public clear(): void { this.flags.fill(0);    }
-}
-globalThis.B2B = B2BI;

package/src/class.js

@@ -1 +0,0 @@
-"use strict";