return this.clone();

    let n = new HashSet<K>();
    n._values = this._values.clone()
    return n;

export function updaterGenerator2Helper<T, W>(_dataObject: T, dataUpdater: UpdaterFn2<T, W>, wholeDataObject: W): UpdaterGeneratorType2<T, W> {

function updaterGenerator2Helper<T, W>(dataObject: T, dataUpdater: UpdaterFn2<T, W>): UpdaterGeneratorType2<T, W> {

  if (typeof _dataObject !== "object") return updaters;

  if (typeof dataObject !== "object") return updaters;

    const dataObject: T = _dataObject;

          dataUpdater((oldData) => {

          dataUpdater((oldData: T, wholeData: W) => {

              [key]: (newValueOrCallback as ((prev: T[typeof key], whole: W) => T[typeof key]))(oldData[key], wholeDataObject),

              [key]: (newValueOrCallback as ((prev: T[typeof key], whole: W) => T[typeof key]))(oldData[key], wholeData),

          dataUpdater((oldData) => ({ ...oldData, [key]: newValueOrCallback }));

          dataUpdater((oldData, wholeData) => ({ ...oldData, [key]: newValueOrCallback }));

      updaters[key] = (updaterGenerator2Helper<T[typeof key], W>(dataObject[key], keyUpdater, wholeDataObject) as unknown as (typeof updaters)[typeof key]);

      updaters[key] = (updaterGenerator2Helper<T[typeof key], W>(dataObject[key], keyUpdater) as unknown as (typeof updaters)[typeof key]);

export function updaterGenerator2<T>(dataObject: T, dataUpdater: UpdaterFn<T>): UpdaterGeneratorType2<T> {
  const dataUpdater2 = (arg: UpdaterFnParam2<T, T>) => {
    if (typeof arg === 'function') {
      dataUpdater((prev) => {

export function updaterGenerator2<T>(dataObject: T, setState: UpdaterFn<T>): UpdaterGeneratorType2<T> {
  const dataUpdater2 = (stateCallbackFunction: UpdaterFnParam2<T, T>) => {
    if (typeof stateCallbackFunction === 'function') {
      setState((prev: T) => {

        return (arg as ((prev: T, prevWhole: T) => T))(prev, prev);

        return (stateCallbackFunction as ((prev: T, prevWhole: T) => T))(prev, prev);

      dataUpdater(arg);

      setState(stateCallbackFunction);

  return updaterGenerator2Helper<T, T>(dataObject, dataUpdater2, dataObject);

  return updaterGenerator2Helper<T, T>(dataObject, dataUpdater2);

/**
 * Usage:
 * class RenderedChunk {
 *  constructor(stateUpdaterQueue) {
 *    this.nodes = 0...10.map(i => new RenderedPointNode({texture, new NodeRef(i), stateUpdaterQueue}))
 *    // this.nodes[0].render({ some, stuff })
 *    this.nodes[0] should listen to gameState.playerUI.selectedPointNode and allocatedPointNodes, and
 *    updating gameState.playerUI.selectedPointNode or gameState.playerSave.allocatedPointNodes or their 
 *       parents should trigger queueing of the rerender
 *    or rather, rerendering
 *  }
 * }
 */

    // this.container.x = node.x * RenderedChunkConstants.SPACING_PX;
    // this.container.y = node.y * RenderedChunkConstants.SPACING_PX;

        console.log({ prevGameState });