Weak{Set,Map}.prototype.clone() -- does anybody see any obvious problem with the idea?

My use case is that I need an immutable weakset. For Set it's easy (just do new Set(oldSet).add(newElement)), but for weak collections it's quite complex to do it and it involves manually duplicating the contents in a list of WeakRefs

My ClonableWeakSet implementation:

class ClonableWeakSet extends WeakSet {
  #contents = [];
    
  #indexes = new WeakMap();

  #cleanup = new FinalizationRegistry(() => {
    if (Math.random() < 0.1) this.#compact();
  });

  #compact() {
    let oldIndex = 0, newIndex = 0;
    while (oldIndex < this.#contents.length) {
      const obj = this.#contents[oldIndex]?.deref();
      if (obj !== undefined) {
        this.#contents[newIndex] = this.#contents[oldIndex];
        this.#indexes.set(obj, newIndex);
        newIndex++;
      }
      oldIndex++;
    }
    this.#contents.length = newIndex;
  }

  add(value) {
    super.add(value);
    if (!this.#indexes.has(value)) {
      this.#indexes.set(value, this.#contents.length);
      this.#contents.push(new WeakRef(value))
      this.#cleanup.register(value);
    }
    return this;
  }

  delete(value) {
    const res = super.delete(value);
    if (this.#indexes.has(value)) {
      this.#contents[this.#indexes.get(value)] = null;
      this.#indexes.delete(value);
      this.#cleanup.unregister(value);
    }
    return res;
  }

  clone() {
    const cloned = new ClonableWeakSet();
    this.#contents.forEach(ref => {
      const obj = ref.deref();
      if (obj !== undefined) cloned.add(obj);
    });
    return cloned;
  }
}