@the-w1zard/dx 1.0.8 → 1.0.10

package/package.json

@@ -1,28 +1,44 @@
 {
-  "name": "@the-w1zard/dx",
-  "version": "1.0.8",
-  "sideEffects": false,
-  "type": "module",
-  "main": "./src/index.ts",
-  "exports": {
-    ".": {
-      "default": "./src/index.ts",
-      "types": "./src/dx.d.ts"
-    }
-  },
-  "files": [
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "check": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@tsconfig/node-lts": "^24.0.0",
-    "@types/node": "^24.0.0",
-    "typescript": "^6.0.0"
-  },
-  "dependencies": {
-    "@the-w1zard/alias_types": "^1.0.2"
-  }
+	"name": "@the-w1zard/dx",
+	"version": "1.0.10",
+	"sideEffects": false,
+	"type": "module",
+	"main": "./dist/index.js",
+	"exports": {
+		".": {
+			"default": "./dist/index.js",
+			"types": "./src/dx.d.ts"
+		}
+	},
+	"files": [
+		"dist",
+		"./src/dx.d.ts"
+	],
+	"scripts": {
+		"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",
+		"jsrepo": "^3.8.3"
+	},
+	"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

@@ -29,11 +29,14 @@ declare global {
 	================================================================================== ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [UX/DX] */
 	type MaybePromise<R = any> = R;
 	var MaybePromise: MaybePromise;
-	var B2B: typeof B2BI; // map
+	var B2B: typeof B2BI; // BOOLEAN BINARY
+
 	var M2: typeof M2I; // map
 	var M2B: typeof M2BI; // map
+
 	var SET2: typeof SET2I; // set
 	var SET2B: typeof SET2BI; // set
+	
 	var D2: typeof D2I; // Date
 	var A2: typeof A2I; // Array
 	var O2: typeof O2I; // Object
@@ -130,7 +133,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 +460,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 +473,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 +486,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;