recursive-set 5.0.3 → 7.0.0

package/dist/cjs/index.js

@@ -1,178 +1,256 @@
 "use strict";
 /**
  * @module recursive-set
- * High-Performance Recursive Set with "Freeze-on-Hash" semantics.
+ * @version 7.0.0
+ * @description
+ * **High-Performance ZFC Set Implementation.**
+ * This library sacrifices runtime safety checks for raw speed.
+ * * **Strict Contract:**
+ * 1. **Finite Numbers Only:** No `NaN`, no `Infinity`.
+ * 2. **No Mutation:** Do not mutate arrays/tuples/objects after insertion.
+ * 3. **Type Consistency:** Avoid mixing distinct types (Array vs Tuple) that might hash collide.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecursiveSet = exports.Tuple = void 0;
+exports.compare = compare;
 exports.emptySet = emptySet;
 exports.singleton = singleton;
-exports.fromIterable = fromIterable;
-// === HASHING ENGINE (FNV-1a) ===
+// ============================================================================
+// FAST HASHING (Optimized FNV-1a)
+// ============================================================================
 const FNV_PRIME = 16777619;
 const FNV_OFFSET = 2166136261;
 const floatBuffer = new ArrayBuffer(8);
-const floatView = new Float64Array(floatBuffer);
-const intView = new Int32Array(floatBuffer);
+const view = new DataView(floatBuffer);
+/**
+ * Hashes a number using FNV-1a.
+ * Optimizes for 32-bit integers to avoid Float64 processing overhead.
+ */
 function hashNumber(val) {
-    if (Number.isInteger(val)) {
-        let h = FNV_OFFSET;
-        h ^= val;
-        h = Math.imul(h, FNV_PRIME);
-        return h >>> 0;
-    }
-    floatView[0] = val;
+    // Integer optimization: Skip float logic if it's a 32-bit int
+    if ((val | 0) === val)
+        return val | 0;
+    view.setFloat64(0, val, true); // Little Endian
     let h = FNV_OFFSET;
-    h ^= intView[0];
+    h ^= view.getInt32(0, true);
     h = Math.imul(h, FNV_PRIME);
-    h ^= intView[1];
+    h ^= view.getInt32(4, true);
     h = Math.imul(h, FNV_PRIME);
     return h >>> 0;
 }
 function hashString(str) {
-    let hash = FNV_OFFSET;
+    let h = FNV_OFFSET;
     const len = str.length;
     for (let i = 0; i < len; i++) {
-        hash ^= str.charCodeAt(i);
-        hash = Math.imul(hash, FNV_PRIME);
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, FNV_PRIME);
     }
-    return hash >>> 0;
+    return h >>> 0;
 }
-function hashValue(val) {
-    if (typeof val === 'string')
-        return hashString(val);
-    if (typeof val === 'number')
-        return hashNumber(val);
-    // Fast Path: Objects with cached hash
-    if (val && typeof val === 'object' && 'hashCode' in val) {
-        return val.hashCode;
-    }
-    if (Array.isArray(val)) {
+function hashValue(v) {
+    if (typeof v === 'number')
+        return hashNumber(v);
+    if (typeof v === 'string')
+        return hashString(v);
+    if (v instanceof RecursiveSet || v instanceof Tuple)
+        return v.hashCode;
+    if (Array.isArray(v)) {
         let h = FNV_OFFSET;
-        const len = val.length;
-        for (let i = 0; i < len; i++) {
-            h ^= hashValue(val[i]);
+        for (let i = 0; i < v.length; i++) {
+            h ^= hashValue(v[i]);
             h = Math.imul(h, FNV_PRIME);
         }
         return h >>> 0;
     }
     return 0;
 }
-// === COMPARATOR ===
+// ============================================================================
+// COMPARATOR (Optimized)
+// ============================================================================
+/**
+ * Global comparator for Total Ordering.
+ * * **WARNING: UNSAFE OPTIMIZATIONS**
+ * - Uses `a - b` for numbers. **Precondition:** Only finite numbers allowed.
+ * Inputting `NaN` or `Infinity` results in undefined sorting behavior.
+ * - **Hash Collisions:** If two distinct object types (e.g. Array vs Tuple) have the
+ * same hash, they may be treated as equal. Avoid mixing structure types in the same set.
+ */
 function compare(a, b) {
     if (a === b)
         return 0;
-    // 1. Hash Short-Circuit (Optimization)
-    const aH = a?.hashCode;
-    const bH = b?.hashCode;
-    const ha = (aH !== undefined) ? aH : hashValue(a);
-    const hb = (bH !== undefined) ? bH : hashValue(b);
-    if (ha !== hb)
-        return ha < hb ? -1 : 1;
-    // 2. Structural Type Check
+    // Fast path for primitives
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (typeof a === 'string' && typeof b === 'string')
+        return a < b ? -1 : 1;
     const typeA = typeof a;
     const typeB = typeof b;
-    if (typeA === 'string' && typeB === 'string')
-        return a < b ? -1 : 1;
-    if (typeA === 'number' && typeB === 'number')
-        return a < b ? -1 : 1;
-    const isSetA = a instanceof RecursiveSet;
-    const isSetB = b instanceof RecursiveSet;
-    if (isSetA && isSetB) {
-        return a.compare(b);
-    }
-    const isSeqA = Array.isArray(a) || a instanceof Tuple;
-    const isSeqB = Array.isArray(b) || b instanceof Tuple;
-    // Sort Order: Primitives (0) < Sequences (1) < Sets (2)
-    if (isSetA !== isSetB || isSeqA !== isSeqB) {
-        const scoreA = isSetA ? 2 : isSeqA ? 1 : 0;
-        const scoreB = isSetB ? 2 : isSeqB ? 1 : 0;
+    // Type Score: Number(1) < String(2) < Array/Tuple(3) < Set(4)
+    if (typeA !== typeB) {
+        const scoreA = (typeA === 'number') ? 1 : (typeA === 'string' ? 2 : 3);
+        const scoreB = (typeB === 'number') ? 1 : (typeB === 'string' ? 2 : 3);
         return scoreA - scoreB;
     }
-    // 3. Sequence Comparison
-    if (isSeqA && isSeqB) {
-        const valA = (a instanceof Tuple) ? a.values : a;
-        const valB = (b instanceof Tuple) ? b.values : b;
-        const len = valA.length;
-        if (len !== valB.length)
-            return len - valB.length;
-        for (let i = 0; i < len; i++) {
-            const diff = compare(valA[i], valB[i]);
-            if (diff !== 0)
-                return diff;
-        }
-        return 0;
+    // Hash Short-Circuit
+    const h1 = hashValue(a);
+    const h2 = hashValue(b);
+    if (h1 !== h2)
+        return h1 < h2 ? -1 : 1;
+    // Deep Compare
+    if (a instanceof RecursiveSet && b instanceof RecursiveSet)
+        return a.compare(b);
+    if (a instanceof Tuple && b instanceof Tuple)
+        return compareSequences(a.raw, b.raw);
+    if (Array.isArray(a) && Array.isArray(b))
+        return compareSequences(a, b);
+    return 0;
+}
+function compareSequences(a, b) {
+    const len = a.length;
+    if (len !== b.length)
+        return len - b.length;
+    for (let i = 0; i < len; i++) {
+        const diff = compare(a[i], b[i]);
+        if (diff !== 0)
+            return diff;
     }
-    return a < b ? -1 : 1;
+    return 0;
 }
-// === CLASSES ===
+// ============================================================================
+// CLASSES
+// ============================================================================
+/**
+ * Immutable Tuple container.
+ * * **Contract:**
+ * - Creates a defensive copy of the input array.
+ * - Freezes the internal storage (`Object.freeze`).
+ * - **Note:** Freezing is **shallow**. Do not mutate nested elements.
+ * @template T - Array type of the tuple elements.
+ */
 class Tuple {
-    values;
+    #values;
     hashCode;
     constructor(...values) {
-        this.values = values;
-        this.hashCode = hashValue(values);
+        this.#values = values.slice(); // Defensive copy
+        Object.freeze(this.#values); // Freeze for safety
+        this.hashCode = hashValue(this.#values);
     }
-    get length() { return this.values.length; }
-    get(i) { return this.values[i]; }
-    *[Symbol.iterator]() { yield* this.values; }
-    toString() { return `(${this.values.join(', ')})`; }
+    /** * Returns the readonly internal array.
+     * **Warning:** Readonly is only enforced by TypeScript.
+     * Mutating the underlying array via `as any` breaks invariants.
+     */
+    get raw() { return this.#values; }
+    get length() { return this.#values.length; }
+    /** Alias for compatibility. */
+    get values() { return this.#values; }
+    /** Iterates over tuple elements. */
+    *[Symbol.iterator]() { yield* this.#values; }
+    /** Returns string representation "(a, b)". */
+    toString() { return `(${this.#values.join(', ')})`; }
+    /** Custom inspection for Node.js console.log to print "(a, b)" cleanly. */
     [Symbol.for('nodejs.util.inspect.custom')]() { return this.toString(); }
 }
 exports.Tuple = Tuple;
+/**
+ * High-Performance Recursive Set.
+ * * **Lifecycle & Safety:**
+ * - **Freeze-on-Hash:** The set is effectively immutable once `hashCode` is accessed
+ * (or it is added to another set/map).
+ * - **Runtime Checks:** Mutation methods verify frozen state via a fast boolean check.
+ * * @template T - Type of elements.
+ */
 class RecursiveSet {
-    _elements;
-    _hashCode = null;
-    _isFrozen = false;
+    #elements;
+    #hashCode = null;
+    #isFrozen = false;
+    // Static wrapper for compatibility
     static compare(a, b) { return compare(a, b); }
+    /**
+     * Creates a new RecursiveSet.
+     * Elements are sorted and deduplicated ($O(N \log N)$).
+     * @param elements Initial elements.
+     */
     constructor(...elements) {
-        if (elements.length === 0) {
-            this._elements = [];
-            this._hashCode = 0;
+        if (elements.length > 1) {
+            elements.sort(compare);
+            this.#elements = this.#unique(elements);
         }
         else {
-            this._elements = elements;
-            this._elements.sort(compare);
-            this._unique();
+            this.#elements = elements;
         }
     }
-    _checkFrozen(op) {
-        if (this._isFrozen) {
-            throw new Error(`InvalidOperation: Cannot ${op} a frozen RecursiveSet.\n` +
-                `This Set has been hashed or used in a collection (Value Semantics).\n` +
-                `Use .mutableCopy() to create a modifiable copy.`);
+    // === CRITICAL PERFORMANCE METHODS ===
+    /** * **Bulk Load (O(N log N))**: Creates a set from a raw array.
+     * Sorts and deduplicates. Much faster than iterative insertion.
+     */
+    static fromArray(elements) {
+        const s = new RecursiveSet();
+        if (elements.length > 1) {
+            elements.sort(compare);
+            s.#elements = s.#unique(elements);
         }
+        else {
+            s.#elements = elements;
+        }
+        return s;
     }
-    _unique() {
-        const arr = this._elements;
-        const len = arr.length;
-        if (len < 2)
-            return;
-        let write = 1;
-        for (let read = 1; read < len; read++) {
-            if (compare(arr[read], arr[read - 1]) !== 0) {
-                arr[write++] = arr[read];
+    /** * **UNSAFE (O(1))**: Bypasses all checks.
+     * @param sortedUnique Input must be ALREADY sorted and deduplicated.
+     * Use only if you strictly guarantee invariants.
+     */
+    static fromSortedUnsafe(sortedUnique) {
+        const s = new RecursiveSet();
+        s.#elements = sortedUnique;
+        return s;
+    }
+    #unique(sorted) {
+        if (sorted.length < 2)
+            return sorted;
+        const out = [sorted[0]];
+        let last = sorted[0];
+        const len = sorted.length;
+        for (let i = 1; i < len; i++) {
+            const curr = sorted[i];
+            if (compare(curr, last) !== 0) {
+                out.push(curr);
+                last = curr;
             }
         }
-        arr.length = write;
+        return out;
     }
-    /**
-     * Calculates/Caches hash code and FREEZES the set.
+    #checkFrozen(op) {
+        if (this.#isFrozen) {
+            throw new Error(`InvalidOperation: Cannot ${op} a frozen RecursiveSet. Use mutableCopy().`);
+        }
+    }
+    /** * Returns the internal sorted array (readonly).
+     * **Warning:** Readonly is only enforced by TypeScript.
+     * Mutating the underlying array via `as any` breaks invariants (Binary Search/Sort rely on strict ordering).
+     */
+    get raw() { return this.#elements; }
+    /** * Computes the hash code.
+     * **Side Effect**: Freezes the set to prevent hash corruption.
      */
     get hashCode() {
-        if (this._hashCode !== null)
-            return this._hashCode;
+        if (this.#hashCode !== null)
+            return this.#hashCode;
         let h = 0;
-        const arr = this._elements;
+        const arr = this.#elements;
         const len = arr.length;
         for (let i = 0; i < len; i++) {
-            h = Math.imul(31, h) + hashValue(arr[i]);
+            h = (Math.imul(31, h) + hashValue(arr[i])) | 0;
         }
-        this._hashCode = h | 0;
-        this._isFrozen = true;
-        return this._hashCode;
+        this.#hashCode = h;
+        this.#isFrozen = true; // Freeze on hash access
+        return h;
     }
-    get isFrozen() { return this._isFrozen; }
+    get isFrozen() { return this.#isFrozen; }
+    get size() { return this.#elements.length; }
+    isEmpty() { return this.#elements.length === 0; }
+    /**
+     * Compares this set with another set for ordering.
+     * Uses hash comparison first, then deep structural comparison.
+     */
     compare(other) {
         if (this === other)
             return 0;
@@ -180,32 +258,33 @@ class RecursiveSet {
         const h2 = other.hashCode;
         if (h1 !== h2)
             return h1 < h2 ? -1 : 1;
-        const arrA = this._elements;
-        const arrB = other._elements;
+        const arrA = this.#elements;
+        const arrB = other.#elements;
         const len = arrA.length;
         if (len !== arrB.length)
             return len - arrB.length;
         for (let i = 0; i < len; i++) {
-            const cmp = compare(arrA[i], arrB[i]);
-            if (cmp !== 0)
-                return cmp;
+            const diff = compare(arrA[i], arrB[i]);
+            if (diff !== 0)
+                return diff;
         }
         return 0;
     }
-    get size() { return this._elements.length; }
-    isEmpty() { return this._elements.length === 0; }
+    equals(other) { return this.compare(other) === 0; }
+    /**
+     * Checks if element exists.
+     * Uses Binary Search ($O(\log N)$) for larger sets, linear scan for small sets.
+     */
     has(element) {
-        const arr = this._elements;
+        const arr = this.#elements;
         const len = arr.length;
-        // Linear Scan (Prefetch-friendly for small sets)
-        if (len < 16) {
+        if (len < 10) { // Linear scan optimization
             for (let i = 0; i < len; i++) {
                 if (compare(arr[i], element) === 0)
                     return true;
             }
             return false;
         }
-        // Binary Search
         let low = 0, high = len - 1;
         while (low <= high) {
             const mid = (low + high) >>> 1;
@@ -219,91 +298,57 @@ class RecursiveSet {
         }
         return false;
     }
+    /**
+     * Adds an element.
+     * @throws if set is frozen.
+     * Complexity: $O(N)$ (Array splice).
+     */
     add(element) {
-        this._checkFrozen('add() to');
-        // Validation (Inlined for Performance)
-        if (typeof element === 'object' && element !== null) {
-            if (!(element instanceof RecursiveSet || element instanceof Tuple || Array.isArray(element))) {
-                throw new Error("Unsupported Type: Use Tuple, Array or RecursiveSet.");
-            }
-        }
-        else if (Number.isNaN(element)) {
-            throw new Error("NaN is not supported");
-        }
-        const arr = this._elements;
-        const len = arr.length;
-        // Optimization: Append to end (common in construction)
-        if (len > 0) {
-            const lastCmp = compare(arr[len - 1], element);
+        this.#checkFrozen('add() to');
+        const arr = this.#elements;
+        // Optimization: Check last element first (append is common)
+        if (arr.length > 0) {
+            const lastCmp = compare(arr[arr.length - 1], element);
             if (lastCmp < 0) {
                 arr.push(element);
-                this._hashCode = null;
+                this.#hashCode = null;
                 return this;
             }
             if (lastCmp === 0)
                 return this;
         }
-        else {
-            arr.push(element);
-            this._hashCode = null;
-            return this;
-        }
-        // Small Array Strategy
-        if (len < 16) {
-            for (let i = 0; i < len; i++) {
-                const cmp = compare(arr[i], element);
-                if (cmp === 0)
-                    return this;
-                if (cmp > 0) {
-                    arr.splice(i, 0, element);
-                    this._hashCode = null;
-                    return this;
-                }
-            }
-            arr.push(element); // Should be unreachable given append check, but safe fallback
-            return this;
-        }
-        // Large Array Strategy
-        let low = 0, high = len - 1, idx = 0;
+        let low = 0, high = arr.length - 1, idx = arr.length;
         while (low <= high) {
             const mid = (low + high) >>> 1;
             const cmp = compare(arr[mid], element);
             if (cmp === 0)
                 return this;
-            if (cmp < 0) {
-                idx = mid + 1;
+            if (cmp < 0)
                 low = mid + 1;
-            }
             else {
                 idx = mid;
                 high = mid - 1;
             }
         }
         arr.splice(idx, 0, element);
-        this._hashCode = null;
+        this.#hashCode = null;
         return this;
     }
+    /**
+     * Removes an element.
+     * @throws if set is frozen.
+     * Complexity: $O(N)$.
+     */
     remove(element) {
-        this._checkFrozen('remove() from');
-        const arr = this._elements;
-        const len = arr.length;
-        if (len < 16) {
-            for (let i = 0; i < len; i++) {
-                if (compare(arr[i], element) === 0) {
-                    arr.splice(i, 1);
-                    this._hashCode = null;
-                    return this;
-                }
-            }
-            return this;
-        }
-        let low = 0, high = len - 1;
+        this.#checkFrozen('remove() from');
+        const arr = this.#elements;
+        let low = 0, high = arr.length - 1;
         while (low <= high) {
             const mid = (low + high) >>> 1;
             const cmp = compare(arr[mid], element);
             if (cmp === 0) {
                 arr.splice(mid, 1);
-                this._hashCode = null;
+                this.#hashCode = null;
                 return this;
             }
             if (cmp < 0)
@@ -314,78 +359,84 @@ class RecursiveSet {
         return this;
     }
     clear() {
-        this._checkFrozen('clear()');
-        this._elements = [];
-        this._hashCode = 0;
+        this.#checkFrozen('clear()');
+        this.#elements = [];
+        this.#hashCode = 0;
         return this;
     }
     mutableCopy() {
         const s = new RecursiveSet();
-        s._elements = this._elements.slice();
+        s.#elements = this.#elements.slice();
         return s;
     }
     clone() { return this.mutableCopy(); }
+    // === OPTIMIZED SET OPERATIONS (Merge Scan) ===
+    /**
+     * Computes Union $A \cup B$.
+     * Implementation: Merge Scan.
+     * Complexity: $O(|A| + |B|)$.
+     */
     union(other) {
-        const s = new RecursiveSet();
-        const arrA = this._elements;
-        const arrB = other._elements;
-        if (arrA.length === 0)
-            return other.clone();
-        if (arrB.length === 0)
-            return this.clone();
+        const A = this.#elements;
+        const B = other.raw; // Efficient access via getter
         const res = [];
         let i = 0, j = 0;
-        const lenA = arrA.length, lenB = arrB.length;
+        const lenA = A.length, lenB = B.length;
         while (i < lenA && j < lenB) {
-            const cmp = compare(arrA[i], arrB[j]);
+            const cmp = compare(A[i], B[j]);
             if (cmp < 0)
-                res.push(arrA[i++]);
+                res.push(A[i++]);
             else if (cmp > 0)
-                res.push(arrB[j++]);
+                res.push(B[j++]);
             else {
-                res.push(arrA[i++]);
+                res.push(A[i++]);
                 j++;
             }
         }
         while (i < lenA)
-            res.push(arrA[i++]);
+            res.push(A[i++]);
         while (j < lenB)
-            res.push(arrB[j++]);
-        s._elements = res;
-        return s;
+            res.push(B[j++]);
+        return RecursiveSet.fromSortedUnsafe(res);
     }
+    /**
+     * Computes Intersection $A \cap B$.
+     * Implementation: Synchronous Scan.
+     * Complexity: $O(|A| + |B|)$.
+     */
     intersection(other) {
-        const s = new RecursiveSet();
-        const arrA = this._elements;
-        const arrB = other._elements;
+        const A = this.#elements;
+        const B = other.raw;
         const res = [];
         let i = 0, j = 0;
-        const lenA = arrA.length, lenB = arrB.length;
+        const lenA = A.length, lenB = B.length;
         while (i < lenA && j < lenB) {
-            const cmp = compare(arrA[i], arrB[j]);
+            const cmp = compare(A[i], B[j]);
             if (cmp < 0)
                 i++;
             else if (cmp > 0)
                 j++;
             else {
-                res.push(arrA[i++]);
+                res.push(A[i++]);
                 j++;
             }
         }
-        s._elements = res;
-        return s;
+        return RecursiveSet.fromSortedUnsafe(res);
     }
+    /**
+     * Computes Difference $A \setminus B$.
+     * Complexity: $O(|A| + |B|)$.
+     */
     difference(other) {
-        const s = new RecursiveSet();
-        const arrA = this._elements;
-        const arrB = other._elements;
+        const A = this.#elements;
+        const B = other.raw;
         const res = [];
         let i = 0, j = 0;
-        const lenA = arrA.length, lenB = arrB.length;
+        const lenA = A.length, lenB = B.length;
         while (i < lenA && j < lenB) {
-            const cmp = compare(arrA[i], arrB[j]);
+            const cmp = compare(A[i], B[j]);
             if (cmp < 0)
-                res.push(arrA[i++]);
+                res.push(A[i++]);
             else if (cmp > 0)
                 j++;
             else {
@@ -394,35 +445,62 @@ class RecursiveSet {
             }
         }
         while (i < lenA)
-            res.push(arrA[i++]);
-        s._elements = res;
-        return s;
+            res.push(A[i++]);
+        return RecursiveSet.fromSortedUnsafe(res);
     }
+    /**
+     * Computes Symmetric Difference $A \triangle B$.
+     * Complexity: $O(|A| + |B|)$.
+     */
     symmetricDifference(other) {
-        const s = new RecursiveSet();
-        const arrA = this._elements;
-        const arrB = other._elements;
+        const A = this.#elements;
+        const B = other.raw;
         const res = [];
         let i = 0, j = 0;
-        const lenA = arrA.length, lenB = arrB.length;
+        const lenA = A.length, lenB = B.length;
         while (i < lenA && j < lenB) {
-            const cmp = compare(arrA[i], arrB[j]);
+            const cmp = compare(A[i], B[j]);
             if (cmp < 0)
-                res.push(arrA[i++]);
+                res.push(A[i++]);
             else if (cmp > 0)
-                res.push(arrB[j++]);
+                res.push(B[j++]);
             else {
                 i++;
                 j++;
             }
         }
         while (i < lenA)
-            res.push(arrA[i++]);
+            res.push(A[i++]);
         while (j < lenB)
-            res.push(arrB[j++]);
-        s._elements = res;
-        return s;
+            res.push(B[j++]);
+        return RecursiveSet.fromSortedUnsafe(res);
+    }
+    /**
+     * Computes Cartesian Product $A \times B$.
+     * Complexity: $O(|A| \cdot |B| \cdot \log(|A| \cdot |B|))$ (due to sorting).
+     */
+    cartesianProduct(other) {
+        const result = [];
+        const arrA = this.#elements;
+        const arrB = other.raw;
+        const lenA = arrA.length;
+        const lenB = arrB.length;
+        for (let i = 0; i < lenA; i++) {
+            const a = arrA[i];
+            for (let j = 0; j < lenB; j++) {
+                result.push(new Tuple(a, arrB[j]));
+            }
+        }
+        // Hashes are not monotonic, so we MUST sort. 
+        result.sort(compare);
+        // But uniqueness is guaranteed mathematically, so use unsafe create
+        return RecursiveSet.fromSortedUnsafe(result);
     }
+    /**
+     * Computes the Power Set $\mathcal{P}(A)$.
+     * Complexity: $O(2^N)$.
+     * @throws if size > 20.
+     */
     powerset() {
         const n = this.size;
         if (n > 20)
@@ -430,33 +508,24 @@ class RecursiveSet {
         const subsets = [];
         const max = 1 << n;
         for (let i = 0; i < max; i++) {
-            const subset = new RecursiveSet();
+            const subsetElements = [];
             for (let j = 0; j < n; j++) {
                 if (i & (1 << j))
-                    subset._elements.push(this._elements[j]);
+                    subsetElements.push(this.#elements[j]);
             }
-            subsets.push(subset);
+            // Elements inside subset are already sorted -> Unsafe
+            subsets.push(RecursiveSet.fromSortedUnsafe(subsetElements));
         }
-        return new RecursiveSet(...subsets);
-    }
-    cartesianProduct(other) {
-        const result = new RecursiveSet();
-        const arrA = this._elements;
-        const arrB = other._elements;
-        for (const x of arrA) {
-            for (const y of arrB) {
-                result._elements.push(new Tuple(x, y));
-            }
-        }
-        return result;
+        // Subsets themselves need sorting
+        return RecursiveSet.fromArray(subsets);
     }
     isSubset(other) {
         if (this.size > other.size)
             return false;
         let i = 0, j = 0;
-        const arrA = this._elements, arrB = other._elements;
-        while (i < arrA.length && j < arrB.length) {
-            const cmp = compare(arrA[i], arrB[j]);
+        const A = this.#elements, B = other.raw;
+        while (i < A.length && j < B.length) {
+            const cmp = compare(A[i], B[j]);
             if (cmp < 0)
                 return false;
             if (cmp > 0)
@@ -466,27 +535,20 @@ class RecursiveSet {
                 j++;
             }
         }
-        return i === arrA.length;
+        return i === A.length;
     }
     isSuperset(other) { return other.isSubset(this); }
-    isProperSubset(other) { return this.isSubset(other) && this.size < other.size; }
-    equals(other) { return this.compare(other) === 0; }
-    toSet() { return new Set(this._elements); }
-    *[Symbol.iterator]() { yield* this._elements; }
-    toString() {
-        if (this.isEmpty())
-            return "∅";
-        const elementsStr = this._elements.map(el => {
-            if (Array.isArray(el))
-                return `[${el.join(', ')}]`;
-            return String(el);
-        });
-        return `{${elementsStr.join(', ')}}`;
-    }
+    /** Iterates over set elements in sorted order. */
+    *[Symbol.iterator]() { yield* this.#elements; }
+    /** Returns string representation e.g. "{1, 2, 3}". */
+    toString() { return `{${this.#elements.join(', ')}}`; }
+    /** Custom inspection for Node.js console to avoid printing internal state. */
     [Symbol.for('nodejs.util.inspect.custom')]() { return this.toString(); }
 }
 exports.RecursiveSet = RecursiveSet;
+// Exports
+/** Factory: Creates an empty RecursiveSet */
 function emptySet() { return new RecursiveSet(); }
+/** Factory: Creates a singleton RecursiveSet containing {element} */
 function singleton(element) { return new RecursiveSet(element); }
-function fromIterable(iterable) { return new RecursiveSet(...iterable); }
 //# sourceMappingURL=index.js.map