@the-w1zard/dx 1.0.12 → 1.0.14

package/dist/string.d.ts

@@ -0,0 +1,39 @@
+export declare class S2I extends String implements S2 {
+    constructor(value?: A);
+    empty(): boolean;
+    notEmpty(): boolean;
+    blank(): boolean;
+    notBlank(): boolean;
+    equals(value: string): boolean;
+    equalsIgnoreCase(value: string): boolean;
+    contains(value: string): boolean;
+    starts(value: string): boolean;
+    ends(value: string): boolean;
+    first(): string;
+    last(): string;
+    reverse(): string;
+    capitalize(): string;
+    uncapitalize(): string;
+    titleCase(): string;
+    camelCase(): string;
+    kebabCase(): string;
+    snakeCase(): string;
+    pascalCase(): string;
+    words(): string[];
+    lines(): string[];
+    chars(): string[];
+    unique(): string;
+    escapeRegExp(): string;
+    stripHtml(): string;
+    stripWhitespace(): string;
+    truncate(length: N, suffix?: string): string;
+    limit(length: N, suffix?: string): string;
+    toNumber(): number;
+    toInt(radix?: N): number;
+    toFloat(): number;
+    toBoolean(): boolean;
+    toArray(): string[];
+    toJSON(): string;
+    isWellFormed(): boolean;
+    toWellFormed(): string;
+}

package/dist/unit8array.d.ts

@@ -0,0 +1,64 @@
+export declare class U82I<T = A> extends Array<T> implements U82<T> {
+    constructor(...items: T[]);
+    static get [Symbol.species](): ArrayConstructor;
+    static from<T>(arrayLike: ArrayLike<T>): U82I<T>;
+    static from<T, U>(arrayLike: ArrayLike<T>, mapFn: (value: T, index: number) => U, thisArg?: A): U82I<U>;
+    static from<T>(iterable: Iterable<T> | ArrayLike<T>): U82I<T>;
+    static of<T>(...items: T[]): U82I<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    second(): T | undefined;
+    third(): T | undefined;
+    random(): T | undefined;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    isNotEmptyAndDefined(): boolean;
+    clear(): this;
+    clone(): U82I<T>;
+    unique(): U82I<T>;
+    compact(): U82I<NonNullable<T>>;
+    chunk(size: N): U82I<U82I<T>>;
+    flatten<D extends N = 1>(depth?: D): U82I<A>;
+    shuffle(): this;
+    sample(count?: N): U82I<T>;
+    count(predicate?: (value: T, index: N, array: T[]) => unknown): N;
+    sum(this: U82I<number>): number;
+    average(this: U82I<number>): number;
+    min(this: U82I<number>): number | undefined;
+    max(this: U82I<number>): number | undefined;
+    groupBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, U82I<T>>;
+    keyBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T>;
+    partition(predicate: (value: T, index: N, array: T[]) => unknown): [U82I<T>, U82I<T>];
+    difference(other: Iterable<T>): U82I<T>;
+    intersection(other: Iterable<T>): U82I<T>;
+    union(other: Iterable<T>): U82I<T>;
+    symmetricDifference(other: Iterable<T>): U82I<T>;
+    take(count: N): U82I<T>;
+    takeLast(count: N): U82I<T>;
+    drop(count: N): U82I<T>;
+    dropLast(count: N): U82I<T>;
+    pluck<K extends keyof T>(key: K): U82I<T[K]>;
+    flattenDeep(): U82I<A>;
+    insert(index: N, ...items: T[]): this;
+    removeAt(index: N): T | undefined;
+    remove(value: T): boolean;
+    removeWhere(predicate: (value: T, index: N, array: T[]) => unknown): this;
+    replace(oldValue: T, newValue: T): boolean;
+    move(from: N, to: N): this;
+    swap(i: N, j: N): this;
+    shuffleInPlace(): this;
+    pick(count?: N): U82I<T>;
+    toSet(): Set<T>;
+    toMap<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T>;
+    equals(other: readonly T[]): boolean;
+    startsWith(other: readonly T[]): boolean;
+    endsWith(other: readonly T[]): boolean;
+    isSorted(compareFn?: (a: T, b: T) => N): boolean;
+    frequencies(): Map<T, N>;
+    findLast<S extends T>(predicate: (value: T, index: N, obj: T[]) => value is S, thisArg?: A): S | undefined;
+    findLastIndex(predicate: (value: T, index: N, obj: T[]) => unknown, thisArg?: A): N;
+    toReversed(): T[];
+    toSorted(compareFn?: (a: T, b: T) => N): T[];
+    toSpliced(start: N, deleteCount: N, ...items: T[]): T[];
+    with(index: N, value: T): T[];
+}

package/dist/url_search_params.d.ts

@@ -0,0 +1,30 @@
+export declare class USP2I extends URLSearchParams implements USP2 {
+    constructor(init?: S | URLSearchParams | R<S, S> | S[][]);
+    get size(): N;
+    getOr(name: S, fallback: S): S;
+    getOrNull(name: S): S | NU;
+    getOrThrow(name: S, error?: A): string;
+    getNumber(name: S, fallback?: N): N | UD;
+    getInt(name: S, radix?: N): N | UD;
+    getFloat(name: S): N | UD;
+    getBoolean(name: S, fallback?: boolean): B;
+    getJSON<T = A>(name: S): T | UD;
+    getArray(name: S, separator?: string): S[];
+    getObject<T extends R<S, A> = R<S, A>>(): T;
+    setNumber(name: S, value: N): this;
+    setBoolean(name: S, value: B): this;
+    setJSON(name: S, value: A): this;
+    setArray(name: S, values: Iterable<A>, separator?: string): this;
+    setIfAbsent(name: S, value: S): this;
+    setIfPresent(name: S, value: S): this;
+    appendAll(params: URLSearchParams | R<S, A>): this;
+    merge(params: URLSearchParams | R<S, A>, overwrite?: boolean): this;
+    clone(): USP2I;
+    clear(): V;
+    isEmpty(): B;
+    isNotEmpty(): B;
+    toObject(): R<S, S | S[]>;
+    toJSON(): R<S, S | S[]>;
+    toURLSearchParams(): URLSearchParams;
+    toURL(url: S | URL): URL;
+}

package/dist/weak_map.d.ts

@@ -0,0 +1,32 @@
+export declare class WM2I<H extends WeakKey = A, T = A> extends WeakMap<H, T> implements WM2<H, T> {
+    g: (key: H) => T | undefined;
+    h: (key: H) => boolean;
+    d: (key: H) => boolean;
+    private _tracked?;
+    s(k: H, v: T | (() => T)): this;
+    swap(key: H, value: T): T | UD;
+    take(key: H): T | UD;
+    getAndDelete(key: H): T | UD;
+    peek(key: H): T | false;
+    getOrI(key: H, value: T): T;
+    getOrM(key: H, make: () => T): T;
+    getOr<G>(key: H, fallback: G): T | G;
+    getOrThrow(key: H, error?: Error): T;
+    getOrCreate(key: H, make: () => T): T;
+    ensure(key: H, make: () => T): T;
+    update(key: H, fn: (old: T, has: B) => T, initial: T): T;
+    setIfAbsent(key: H, value: T): B;
+    setIfPresent(key: H, value: T): B;
+    hasOrSet(key: H, value: T): B;
+    replace(key: H, value: T): B;
+    touch(key: H): B;
+    get tracked(): B;
+    get trackedSize(): N;
+    track(key: H): this;
+    untrack(key: H): B;
+    trackedKeys(): AR<H>;
+    trackedValues(): AR<T>;
+    trackedEntries(): AR<[H, T]>;
+    forEachTracked(fn: (value: T, key: H, map: this) => void): void;
+    clearTracked(): void;
+}

package/dist/weak_set.d.ts

@@ -0,0 +1,20 @@
+export declare class WS2I<T extends WeakKey = A> extends WeakSet<T> implements WS2<T> {
+    private readonly _tracked;
+    constructor(values?: readonly T[] | Iterable<T> | null);
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    addIfAbsent(value: T): boolean;
+    toggle(value: T): boolean;
+    deleteIfPresent(value: T): boolean;
+    hasAll(values: Iterable<T>): boolean;
+    hasAny(values: Iterable<T>): boolean;
+    addAll(values: Iterable<T>): this;
+    deleteAll(values: Iterable<T>): N;
+    replace(oldValue: T, newValue: T): boolean;
+    track(value: T): this;
+    untrack(value: T): boolean;
+    trackedKeys(): T[];
+    forEachTracked(callback: (value: T, set: this) => void, thisArg?: A): void;
+    clearTracked(): void;
+}

package/package.json

@@ -1,18 +1,20 @@
 {
 	"name": "@the-w1zard/dx",
-	"version": "1.0.12",
+	"version": "1.0.14",
 	"sideEffects": false,
 	"type": "module",
 	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
+			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js",
-			"types": "./src/dx.d.ts"
+			"import": "./dist/index.js"
 		}
 	},
 	"files": [
 		"dist",
-		"./src/dx.d.ts"
+		"src"
 	],
 	"scripts": {
 		"1": "git add .",
@@ -21,7 +23,7 @@
 		"4": "npm version patch",
 		"5": "git push --tags",
 		"6": "npm publish --access public",
-		"build": "rspack build",
+		"build": "tsc --emitDeclarationOnly && 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 *"
@@ -30,15 +32,15 @@
 		"@rspack/cli": "^2.3.1",
 		"@rspack/core": "^2.3.1",
 		"@rspack/dev-server": "^2.2.2",
+		"@the-w1zard/alias_types": "^1.0.3",
 		"@tsconfig/node-lts": "^24.0.0",
 		"@types/node": "^24.0.0",
-		"typescript": "^6.0.0",
-		"jsrepo": "^3.8.3"
+		"jsrepo": "^3.8.3",
+		"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"
+		"@babel/types": "^8.1.0"
 	}
 }

package/src/array.ts

@@ -0,0 +1,301 @@
+
+
+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.ts

@@ -0,0 +1,23 @@
+/*  ==========================================================================================================================
+    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;