recursive-set 1.0.0 → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @module recursive-set
+ * A mutable recursive set implementation enforcing Cantor's ZFC axioms
+ */
+/**
+ * RecursiveSet: Mutable set with arbitrary nesting depth
+ *
+ * Enforced ZFC Axioms (as class invariants):
+ * - Extensionality: Sets with same elements are equal
+ * - Foundation (Regularity): No membership cycles allowed
+ * - Power Set: Can construct 𝒫(A) for any set A
+ * - Union: Can construct A ∪ B for any sets A, B
+ * - Pairing: Can construct {a, b} for any elements a, b
+ */
+export declare class RecursiveSet<T = any> {
+    private _elements;
+    constructor(...elements: Array<T | RecursiveSet<T>>);
+    /**
+     * Internal: Add element with cycle detection (Foundation axiom)
+     */
+    private _addElement;
+    /**
+     * Check if adding element would violate Foundation axiom
+     */
+    private _wouldCreateCycle;
+    /**
+     * Verify class invariants (Design by Contract)
+     */
+    private _checkInvariants;
+    /**
+     * Add element to this set (Pairing axiom)
+     * @returns this for method chaining
+     */
+    add(element: T | RecursiveSet<T>): this;
+    /**
+     * Remove element from this set
+     * @returns this for method chaining
+     */
+    remove(element: T | RecursiveSet<T>): this;
+    /**
+     * Remove all elements
+     * @returns this for method chaining
+     */
+    clear(): this;
+    /**
+     * Union of two sets (Union axiom)
+     * Returns A ∪ B
+     */
+    union(other: RecursiveSet<T>): RecursiveSet<T>;
+    /**
+     * Intersection of two sets
+     * Returns A ∩ B
+     */
+    intersection(other: RecursiveSet<T>): RecursiveSet<T>;
+    /**
+     * Set difference
+     * Returns A \ B (elements in A but not in B)
+     */
+    difference(other: RecursiveSet<T>): RecursiveSet<T>;
+    /**
+     * Symmetric difference
+     * Returns A △ B (elements in either but not both)
+     */
+    symmetricDifference(other: RecursiveSet<T>): RecursiveSet<T>;
+    /**
+     * Power set construction (Power Set axiom)
+     * Returns 𝒫(A) - set of all subsets
+     */
+    powerset(): RecursiveSet<RecursiveSet<T>>;
+    /**
+     * Cartesian product
+     * Returns A × B as set of ordered pairs {{a}, {a,b}}
+     */
+    cartesianProduct<U>(other: RecursiveSet<U>): RecursiveSet<RecursiveSet<T | U>>;
+    /**
+     * Check membership (∈)
+     */
+    has(element: T | RecursiveSet<T>): boolean;
+    /**
+     * Check if subset (⊆)
+     */
+    isSubset(other: RecursiveSet<T>): boolean;
+    /**
+     * Check if superset (⊇)
+     */
+    isSuperset(other: RecursiveSet<T>): boolean;
+    /**
+     * Check if proper subset (⊂)
+     */
+    isProperSubset(other: RecursiveSet<T>): boolean;
+    /**
+     * Check if empty set
+     */
+    isEmpty(): boolean;
+    /**
+     * Structural equality (Extensionality axiom)
+     * Two sets are equal iff they have the same elements
+     */
+    equals(other: RecursiveSet<T>): boolean;
+    /**
+     * Cardinality |A|
+     */
+    get size(): number;
+    /**
+     * Convert to native Set (shallow)
+     */
+    toSet(): Set<T | RecursiveSet<T>>;
+    /**
+     * Iterate over elements
+     */
+    [Symbol.iterator](): Iterator<T | RecursiveSet<T>>;
+    /**
+     * Pretty print with mathematical notation
+     */
+    toString(): string;
+}
+/**
+ * Create empty set (Null Set axiom)
+ */
+export declare function emptySet<T = any>(): RecursiveSet<T>;
+/**
+ * Create singleton set
+ */
+export declare function singleton<T>(element: T): RecursiveSet<T>;
+/**
+ * Create set from iterable
+ */
+export declare function fromIterable<T>(iterable: Iterable<T>): RecursiveSet<T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,GAAG,GAAG;IAC7B,OAAO,CAAC,SAAS,CAA2B;gBAEhC,GAAG,QAAQ,EAAE,KAAK,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAQnD;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;;OAGG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAMvC;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAK1C;;;OAGG;IACH,KAAK,IAAI,IAAI;IAOb;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAM9C;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAUrD;;;OAGG;IACH,UAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAUnD;;;OAGG;IACH,mBAAmB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;IAI5D;;;OAGG;IACH,QAAQ,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAmBzC;;;OAGG;IACH,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAmB9E;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAI1C;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IASzC;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAI3C;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAI/C;;OAEG;IACH,OAAO,IAAI,OAAO;IAMlB;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAyBvC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,KAAK,IAAI,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAIjC;;OAEG;IACF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAInD;;OAEG;IACH,QAAQ,IAAI,MAAM;CAqBrB;AAID;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,KAAK,YAAY,CAAC,CAAC,CAAC,CAEnD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAExD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAEtE"}

package/{src/index.ts → dist/index.js}

@@ -1,344 +1,299 @@
-/**
- * @module recursive-set
- * A mutable recursive set implementation enforcing Cantor's ZFC axioms
- */
-
-/**
- * RecursiveSet: Mutable set with arbitrary nesting depth
- * 
- * Enforced ZFC Axioms (as class invariants):
- * - Extensionality: Sets with same elements are equal
- * - Foundation (Regularity): No membership cycles allowed
- * - Power Set: Can construct 𝒫(A) for any set A
- * - Union: Can construct A ∪ B for any sets A, B
- * - Pairing: Can construct {a, b} for any elements a, b
- */
-export class RecursiveSet<T = any> {
-    private _elements: Set<T | RecursiveSet<T>>;
-    
-    constructor(...elements: Array<T | RecursiveSet<T>>) {
-        this._elements = new Set();
-        for (const el of elements) {
-            this._addElement(el);
-        }
-        this._checkInvariants();
-    }
-    
-    /**
-     * Internal: Add element with cycle detection (Foundation axiom)
-     */
-    private _addElement(el: T | RecursiveSet<T>): void {
-        if (el instanceof RecursiveSet) {
-            if (this._wouldCreateCycle(el)) {
-                throw new Error(
-                    "Foundation axiom violated: adding this element would create a membership cycle"
-                );
-            }
-        }
-        this._elements.add(el);
-    }
-    
-    /**
-     * Check if adding element would violate Foundation axiom
-     */
-    private _wouldCreateCycle(element: RecursiveSet<T>): boolean {
-        const visited = new Set<RecursiveSet<any>>();
-        const toCheck: RecursiveSet<any>[] = [element];
-        
-        while (toCheck.length > 0) {
-            const current = toCheck.pop()!;
-            if (current === this) {
-                return true;
-            }
-            if (visited.has(current)) {
-                continue;
-            }
-            visited.add(current);
-            
-            for (const el of current._elements) {
-                if (el instanceof RecursiveSet) {
-                    toCheck.push(el);
-                }
-            }
-        }
-        return false;
-    }
-    
-    /**
-     * Verify class invariants (Design by Contract)
-     */
-    private _checkInvariants(): void {
-        // Extensionality: enforced by Set semantics
-        // Foundation: enforced by _wouldCreateCycle
-        // Well-definedness: enforced by TypeScript type system
-        
-        // Additional runtime checks can be added here
-        if (process.env.NODE_ENV === 'development') {
-            // More expensive checks only in development
-        }
-    }
-    
-    // === Mutable Operations ===
-    
-    /**
-     * Add element to this set (Pairing axiom)
-     * @returns this for method chaining
-     */
-    add(element: T | RecursiveSet<T>): this {
-        this._addElement(element);
-        this._checkInvariants();
-        return this;
-    }
-    
-    /**
-     * Remove element from this set
-     * @returns this for method chaining
-     */
-    remove(element: T | RecursiveSet<T>): this {
-        this._elements.delete(element);
-        return this;
-    }
-    
-    /**
-     * Remove all elements
-     * @returns this for method chaining
-     */
-    clear(): this {
-        this._elements.clear();
-        return this;
-    }
-    
-    // === Immutable Operations (return new sets) ===
-    
-    /**
-     * Union of two sets (Union axiom)
-     * Returns A ∪ B
-     */
-    union(other: RecursiveSet<T>): RecursiveSet<T> {
-        const result = new RecursiveSet<T>();
-        result._elements = new Set([...this._elements, ...other._elements]);
-        return result;
-    }
-    
-    /**
-     * Intersection of two sets
-     * Returns A ∩ B
-     */
-    intersection(other: RecursiveSet<T>): RecursiveSet<T> {
-        const result = new RecursiveSet<T>();
-        for (const el of this._elements) {
-            if (other.has(el)) {
-                result._elements.add(el);
-            }
-        }
-        return result;
-    }
-    
-    /**
-     * Set difference
-     * Returns A \ B (elements in A but not in B)
-     */
-    difference(other: RecursiveSet<T>): RecursiveSet<T> {
-        const result = new RecursiveSet<T>();
-        for (const el of this._elements) {
-            if (!other.has(el)) {
-                result._elements.add(el);
-            }
-        }
-        return result;
-    }
-    
-    /**
-     * Symmetric difference
-     * Returns A △ B (elements in either but not both)
-     */
-    symmetricDifference(other: RecursiveSet<T>): RecursiveSet<T> {
-        return this.union(other).difference(this.intersection(other));
-    }
-    
-    /**
-     * Power set construction (Power Set axiom)
-     * Returns 𝒫(A) - set of all subsets
-     */
-    powerset(): RecursiveSet<RecursiveSet<T>> {
-        const elements = Array.from(this._elements);
-        const subsets: RecursiveSet<T>[] = [];
-        
-        // Generate all 2^n subsets
-        const n = elements.length;
-        for (let i = 0; i < (1 << n); i++) {
-            const subset = new RecursiveSet<T>();
-            for (let j = 0; j < n; j++) {
-                if (i & (1 << j)) {
-                    subset._elements.add(elements[j]);
-                }
-            }
-            subsets.push(subset);
-        }
-        
-        return new RecursiveSet<RecursiveSet<T>>(...subsets);
-    }
-    
-    /**
-     * Cartesian product
-     * Returns A × B as set of ordered pairs {{a}, {a,b}}
-     */
-    cartesianProduct<U>(other: RecursiveSet<U>): RecursiveSet<RecursiveSet<T | U>> {
-        const pairs: RecursiveSet<T | U>[] = [];
-        
-        for (const x of this._elements) {
-            for (const y of other._elements) {
-                // Kuratowski ordered pair: (x,y) := {{x}, {x,y}}
-                const pair = new RecursiveSet<T | U>(
-                    new RecursiveSet<T | U>(x),
-                    new RecursiveSet<T | U>(x, y)
-                );
-                pairs.push(pair);
-            }
-        }
-        
-        return new RecursiveSet<RecursiveSet<T | U>>(...pairs);
-    }
-    
-    // === Predicates ===
-    
-    /**
-     * Check membership (∈)
-     */
-    has(element: T | RecursiveSet<T>): boolean {
-        return this._elements.has(element);
-    }
-    
-    /**
-     * Check if subset (⊆)
-     */
-    isSubset(other: RecursiveSet<T>): boolean {
-        for (const el of this._elements) {
-            if (!other.has(el)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    
-    /**
-     * Check if superset (⊇)
-     */
-    isSuperset(other: RecursiveSet<T>): boolean {
-        return other.isSubset(this);
-    }
-    
-    /**
-     * Check if proper subset (⊂)
-     */
-    isProperSubset(other: RecursiveSet<T>): boolean {
-        return this.isSubset(other) && !this.equals(other);
-    }
-    
-    /**
-     * Check if empty set
-     */
-    isEmpty(): boolean {
-        return this._elements.size === 0;
-    }
-    
-    // === Extensionality (Equality) ===
-    
-    /**
-     * Structural equality (Extensionality axiom)
-     * Two sets are equal iff they have the same elements
-     */
-    equals(other: RecursiveSet<T>): boolean {
-        if (this._elements.size !== other._elements.size) {
-            return false;
-        }
-        
-        for (const el of this._elements) {
-            if (el instanceof RecursiveSet) {
-                // Deep comparison for nested sets
-                let found = false;
-                for (const otherEl of other._elements) {
-                    if (otherEl instanceof RecursiveSet && el.equals(otherEl)) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) return false;
-            } else {
-                if (!other.has(el)) return false;
-            }
-        }
-        return true;
-    }
-    
-    // === Utility ===
-    
-    /**
-     * Cardinality |A|
-     */
-    get size(): number {
-        return this._elements.size;
-    }
-    
-    /**
-     * Convert to native Set (shallow)
-     */
-    toSet(): Set<T | RecursiveSet<T>> {
-        return new Set(this._elements);
-    }
-    
-    /**
-     * Iterate over elements
-     */
-    *[Symbol.iterator](): Iterator<T | RecursiveSet<T>> {
-        yield* this._elements;
-    }
-    
-    /**
-     * Pretty print with mathematical notation
-     */
-    toString(): string {
-        if (this.isEmpty()) {
-            return "∅";
-        }
-        
-        const elements = Array.from(this._elements).map(el => {
-            if (el instanceof RecursiveSet) {
-                return el.toString();
-            }
-            return String(el);
-        });
-        
-        return `{${elements.join(", ")}}`;
-    }
-    
-    /**
-     * For console.log
-     */
-    [Symbol.for('nodejs.util.inspect.custom')](): string {
-        return this.toString();
-    }
-}
-
-// === Helper Functions ===
-
-/**
- * Create empty set (Null Set axiom)
- */
-export function emptySet<T = any>(): RecursiveSet<T> {
-    return new RecursiveSet<T>();
-}
-
-/**
- * Create singleton set
- */
-export function singleton<T>(element: T): RecursiveSet<T> {
-    return new RecursiveSet<T>(element);
-}
-
-/**
- * Create set from iterable
- */
-export function fromIterable<T>(iterable: Iterable<T>): RecursiveSet<T> {
-    return new RecursiveSet<T>(...iterable);
-}
+/**
+ * @module recursive-set
+ * A mutable recursive set implementation enforcing Cantor's ZFC axioms
+ */
+/**
+ * RecursiveSet: Mutable set with arbitrary nesting depth
+ *
+ * Enforced ZFC Axioms (as class invariants):
+ * - Extensionality: Sets with same elements are equal
+ * - Foundation (Regularity): No membership cycles allowed
+ * - Power Set: Can construct 𝒫(A) for any set A
+ * - Union: Can construct A ∪ B for any sets A, B
+ * - Pairing: Can construct {a, b} for any elements a, b
+ */
+export class RecursiveSet {
+    _elements;
+    constructor(...elements) {
+        this._elements = new Set();
+        for (const el of elements) {
+            this._addElement(el);
+        }
+        this._checkInvariants();
+    }
+    /**
+     * Internal: Add element with cycle detection (Foundation axiom)
+     */
+    _addElement(el) {
+        if (el instanceof RecursiveSet) {
+            if (this._wouldCreateCycle(el)) {
+                throw new Error("Foundation axiom violated: adding this element would create a membership cycle");
+            }
+        }
+        this._elements.add(el);
+    }
+    /**
+     * Check if adding element would violate Foundation axiom
+     */
+    _wouldCreateCycle(element) {
+        const visited = new Set();
+        const toCheck = [element];
+        while (toCheck.length > 0) {
+            const current = toCheck.pop();
+            if (current === this) {
+                return true;
+            }
+            if (visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            for (const el of current._elements) {
+                if (el instanceof RecursiveSet) {
+                    toCheck.push(el);
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Verify class invariants (Design by Contract)
+     */
+    _checkInvariants() {
+        // Extensionality: enforced by Set semantics
+        // Foundation: enforced by _wouldCreateCycle
+        // Well-definedness: enforced by TypeScript type system
+        // Additional runtime checks can be added here
+        if (process.env.NODE_ENV === 'development') {
+            // More expensive checks only in development
+        }
+    }
+    // === Mutable Operations ===
+    /**
+     * Add element to this set (Pairing axiom)
+     * @returns this for method chaining
+     */
+    add(element) {
+        this._addElement(element);
+        this._checkInvariants();
+        return this;
+    }
+    /**
+     * Remove element from this set
+     * @returns this for method chaining
+     */
+    remove(element) {
+        this._elements.delete(element);
+        return this;
+    }
+    /**
+     * Remove all elements
+     * @returns this for method chaining
+     */
+    clear() {
+        this._elements.clear();
+        return this;
+    }
+    // === Immutable Operations (return new sets) ===
+    /**
+     * Union of two sets (Union axiom)
+     * Returns A ∪ B
+     */
+    union(other) {
+        const result = new RecursiveSet();
+        result._elements = new Set([...this._elements, ...other._elements]);
+        return result;
+    }
+    /**
+     * Intersection of two sets
+     * Returns A ∩ B
+     */
+    intersection(other) {
+        const result = new RecursiveSet();
+        for (const el of this._elements) {
+            if (other.has(el)) {
+                result._elements.add(el);
+            }
+        }
+        return result;
+    }
+    /**
+     * Set difference
+     * Returns A \ B (elements in A but not in B)
+     */
+    difference(other) {
+        const result = new RecursiveSet();
+        for (const el of this._elements) {
+            if (!other.has(el)) {
+                result._elements.add(el);
+            }
+        }
+        return result;
+    }
+    /**
+     * Symmetric difference
+     * Returns A △ B (elements in either but not both)
+     */
+    symmetricDifference(other) {
+        return this.union(other).difference(this.intersection(other));
+    }
+    /**
+     * Power set construction (Power Set axiom)
+     * Returns 𝒫(A) - set of all subsets
+     */
+    powerset() {
+        const elements = Array.from(this._elements);
+        const subsets = [];
+        // Generate all 2^n subsets
+        const n = elements.length;
+        for (let i = 0; i < (1 << n); i++) {
+            const subset = new RecursiveSet();
+            for (let j = 0; j < n; j++) {
+                if (i & (1 << j)) {
+                    subset._elements.add(elements[j]);
+                }
+            }
+            subsets.push(subset);
+        }
+        return new RecursiveSet(...subsets);
+    }
+    /**
+     * Cartesian product
+     * Returns A × B as set of ordered pairs {{a}, {a,b}}
+     */
+    cartesianProduct(other) {
+        const pairs = [];
+        for (const x of this._elements) {
+            for (const y of other._elements) {
+                // Kuratowski ordered pair: (x,y) := {{x}, {x,y}}
+                const pair = new RecursiveSet(new RecursiveSet(x), new RecursiveSet(x, y));
+                pairs.push(pair);
+            }
+        }
+        return new RecursiveSet(...pairs);
+    }
+    // === Predicates ===
+    /**
+     * Check membership (∈)
+     */
+    has(element) {
+        return this._elements.has(element);
+    }
+    /**
+     * Check if subset (⊆)
+     */
+    isSubset(other) {
+        for (const el of this._elements) {
+            if (!other.has(el)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if superset (⊇)
+     */
+    isSuperset(other) {
+        return other.isSubset(this);
+    }
+    /**
+     * Check if proper subset (⊂)
+     */
+    isProperSubset(other) {
+        return this.isSubset(other) && !this.equals(other);
+    }
+    /**
+     * Check if empty set
+     */
+    isEmpty() {
+        return this._elements.size === 0;
+    }
+    // === Extensionality (Equality) ===
+    /**
+     * Structural equality (Extensionality axiom)
+     * Two sets are equal iff they have the same elements
+     */
+    equals(other) {
+        if (this._elements.size !== other._elements.size) {
+            return false;
+        }
+        for (const el of this._elements) {
+            if (el instanceof RecursiveSet) {
+                // Deep comparison for nested sets
+                let found = false;
+                for (const otherEl of other._elements) {
+                    if (otherEl instanceof RecursiveSet && el.equals(otherEl)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    return false;
+            }
+            else {
+                if (!other.has(el))
+                    return false;
+            }
+        }
+        return true;
+    }
+    // === Utility ===
+    /**
+     * Cardinality |A|
+     */
+    get size() {
+        return this._elements.size;
+    }
+    /**
+     * Convert to native Set (shallow)
+     */
+    toSet() {
+        return new Set(this._elements);
+    }
+    /**
+     * Iterate over elements
+     */
+    *[Symbol.iterator]() {
+        yield* this._elements;
+    }
+    /**
+     * Pretty print with mathematical notation
+     */
+    toString() {
+        if (this.isEmpty()) {
+            return "∅";
+        }
+        const elements = Array.from(this._elements).map(el => {
+            if (el instanceof RecursiveSet) {
+                return el.toString();
+            }
+            return String(el);
+        });
+        return `{${elements.join(", ")}}`;
+    }
+    /**
+     * For console.log
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
+}
+// === Helper Functions ===
+/**
+ * Create empty set (Null Set axiom)
+ */
+export function emptySet() {
+    return new RecursiveSet();
+}
+/**
+ * Create singleton set
+ */
+export function singleton(element) {
+    return new RecursiveSet(element);
+}
+/**
+ * Create set from iterable
+ */
+export function fromIterable(iterable) {
+    return new RecursiveSet(...iterable);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "recursive-set",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Mutable recursive sets with ZFC axioms for TypeScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
+    "prepublishOnly": "npm run build",
     "build": "tsc",
     "watch": "tsc --watch",
     "clean": "rm -rf dist",
@@ -31,15 +35,15 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/<USERNAME>/recursive-set.git"
+    "url": "git+https://github.com/cstrerath/recursive-set.git"
   },
   "bugs": {
-    "url": "https://github.com/<USERNAME>/recursive-set/issues"
+    "url": "https://github.com/cstrerath/recursive-set/issues"
   },
-  "homepage": "https://github.com/<USERNAME>/recursive-set#readme",
+  "homepage": "https://github.com/cstrerath/recursive-set#readme",
   "devDependencies": {
     "@types/node": "^20.0.0",
     "tsx": "^4.20.6",
     "typescript": "^5.6.0"
   }
-}
+}

package/test.ts

@@ -1,115 +0,0 @@
-import { RecursiveSet } from './src/index.js';
-
-console.log('=== RecursiveSet Test Suite ===\n');
-
-// ============================================================================
-// Test 1: Basic FSM State Sets
-// ============================================================================
-console.log('--- Test 1: Basic State Sets ---');
-const q0 = "q0";
-const q1 = "q1";
-const q2 = "q2";
-const q3 = "q3";
-
-const eqClass1 = new RecursiveSet(q0, q1);
-const eqClass2 = new RecursiveSet(q2, q3);
-console.log(`Equivalence class 1: ${eqClass1}`);
-console.log(`Equivalence class 2: ${eqClass2}`);
-console.log();
-
-// ============================================================================
-// Test 2: Sets of Sets (Equivalence Classes)
-// ============================================================================
-console.log('--- Test 2: Sets of Sets ---');
-const eqClasses = new RecursiveSet(eqClass1, eqClass2);
-console.log(`Equivalence classes: ${eqClasses}`);
-console.log();
-
-// ============================================================================
-// Test 3: Mutability - Adding Elements
-// ============================================================================
-console.log('--- Test 3: Mutability ---');
-const eqClass3 = new RecursiveSet("q4");
-eqClasses.add(eqClass3);
-console.log(`After adding {q4}: ${eqClasses}`);
-console.log();
-
-// ============================================================================
-// Test 4: Extensionality (Structural Equality)
-// ============================================================================
-console.log('--- Test 4: Extensionality Axiom ---');
-const eqClass1_copy = new RecursiveSet("q0", "q1");
-console.log(`eqClass1: ${eqClass1}`);
-console.log(`eqClass1_copy: ${eqClass1_copy}`);
-console.log(`Are they equal? ${eqClass1.equals(eqClass1_copy)}`);
-console.log();
-
-// ============================================================================
-// Test 5: Empty Set Handling
-// ============================================================================
-console.log('--- Test 5: Empty Set ---');
-const emptyClass = new RecursiveSet();
-const eqClassesWithEmpty = new RecursiveSet(eqClass1, emptyClass);
-console.log(`With empty class: ${eqClassesWithEmpty}`);
-console.log();
-
-// ============================================================================
-// Test 6: Deep Nesting
-// ============================================================================
-console.log('--- Test 6: Deep Nesting ---');
-const nested = new RecursiveSet(eqClasses, eqClassesWithEmpty);
-console.log(`Nested structure: ${nested}`);
-console.log();
-
-// ============================================================================
-// Test 7: Set Operations
-// ============================================================================
-console.log('--- Test 7: Set Operations ---');
-const difference = eqClasses.difference(new RecursiveSet(eqClass2));
-console.log(`eqClasses - {eqClass2} = ${difference}`);
-
-const union = eqClass1.union(eqClass2);
-console.log(`eqClass1 ∪ eqClass2 = ${union}`);
-
-const intersection = new RecursiveSet(q0, q1, q2).intersection(new RecursiveSet(q1, q2, q3));
-console.log(`{q0, q1, q2} ∩ {q1, q2, q3} = ${intersection}`);
-console.log();
-
-// ============================================================================
-// Test 8: Power Set
-// ============================================================================
-console.log('--- Test 8: Power Set ---');
-const small = new RecursiveSet(1, 2);
-const power = small.powerset();
-console.log(`𝒫({1, 2}) = ${power}`);
-console.log();
-
-// ============================================================================
-// Test 9: Foundation Axiom (Cycle Detection)
-// ============================================================================
-console.log('--- Test 9: Foundation Axiom ---');
-try {
-    const circular = new RecursiveSet(1, 2);
-    circular.add(circular);
-    console.log('❌ ERROR: Cycle should have been detected!');
-} catch (e: any) {
-    console.log(`✓ Cycle detected: ${e.message}`);
-}
-console.log();
-
-// ============================================================================
-// Test 10: Subset Relations
-// ============================================================================
-console.log('--- Test 10: Subset Relations ---');
-const setA = new RecursiveSet(1, 2, 3);
-const setB = new RecursiveSet(1, 2);
-console.log(`A = ${setA}`);
-console.log(`B = ${setB}`);
-console.log(`B ⊆ A? ${setB.isSubset(setA)}`);
-console.log(`A ⊆ B? ${setA.isSubset(setB)}`);
-console.log();
-
-// ============================================================================
-// Summary
-// ============================================================================
-console.log('=== All Tests Completed Successfully ✓ ===');

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",                  /* Modern JavaScript */
-    "module": "ES2022",                  /* ESM modules */
-    "lib": ["ES2022"],                   /* Available APIs */
-    "outDir": "./dist",                  /* Compiled JS output directory */
-    "rootDir": "./src",                  /* TypeScript source files */
-    "declaration": true,                 /* Generate .d.ts type files */
-    "declarationMap": true,              /* Source maps for types */
-    "sourceMap": true,                   /* Source maps for debugging */
-    "strict": true,                      /* Enable all strict checks */
-    "esModuleInterop": true,             /* Better module compatibility */
-    "skipLibCheck": true,                /* Faster compilation */
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node"           /* Node.js module resolution */
-  },
-  "include": ["src/**/*"],               /* Files to compile */
-  "exclude": ["node_modules", "dist"]    /* Files to ignore */
-}