clone(): HashSet<K> {
    return this.clone();
  }

  clone(): HashMap<K, V> {
    let n = new HashMap<K, V>();
    n._values = { ...this._values };
    return n;
  }

  }
  clone(): KeyedHashMap<K, V> {
    let n = new KeyedHashMap<K, V>();
    n._kvalues = { ...this._kvalues };
    return n;

}
type UpdaterFnParam2<T, W> = T | ((prev: T, prevWhole: W) => T);
type UpdaterFn2<T, W> = (arg: UpdaterFnParam2<T, W>) => void;
type UpdaterGeneratorType2<T, W = T> = {
  [k in keyof T]: ((T[k] extends { [kkt: string]: any } ? UpdaterGeneratorType2<T[k], W> : {}) & {
    getUpdater: () => UpdaterFn2<T[k], T>,
    set: UpdaterFn2<T[k], T>,
    update: UpdaterFn2<T[k], T>,
  })
} & {
  getUpdater: () => UpdaterFn2<T, W>,
  set: UpdaterFn2<T, W>,
  update: UpdaterFn2<T, W>,
}
function isObject(o: any): o is { [x: string]: any } {
  return (typeof o === "object");

export function updaterGenerator2Helper<T, W>(_dataObject: T, dataUpdater: UpdaterFn2<T, W>, wholeDataObject: W): UpdaterGeneratorType2<T, W> {
  const updaters: UpdaterGeneratorType2<T, W> = {} as any;
  updaters.getUpdater = () => dataUpdater;
  updaters.set = dataUpdater;
  updaters.update = dataUpdater;
  // if (typeof _dataObject !== "object") return updaters;
  if (!isObject(_dataObject)) return updaters;
  else {
    const dataObject: T = _dataObject;
    const keys: (keyof T)[] = Object.keys(dataObject) as any;
    keys.forEach((key: (keyof T)) => {
      if (key === "set" || key === "getUpdater" || key === "update") {
        throw Error(`Invalid key in updaterGenerator: ${key} conflicts with reserved keywords set, update, getUpdater.`);
      }
      function keyUpdater(newValueOrCallback: UpdaterFnParam2<T[typeof key], W>) {
        if (typeof newValueOrCallback === "function") {
          dataUpdater((oldData) => {
            const newData = {
              ...oldData,
              [key]: (newValueOrCallback as ((prev: T[typeof key], whole: W) => T[typeof key]))(oldData[key], wholeDataObject),
            };
            return newData;
          });
        } else {
          dataUpdater((oldData) => ({ ...oldData, [key]: newValueOrCallback }));
        }
      }
      updaters[key] = (updaterGenerator2Helper<T[typeof key], W>(dataObject[key], keyUpdater, wholeDataObject) as unknown as (typeof updaters)[typeof key]);
    });
    return updaters;
  }
}
export function updaterGenerator2<T>(dataObject: T, dataUpdater: UpdaterFn<T>): UpdaterGeneratorType2<T> {
  const dataUpdater2 = (arg: UpdaterFnParam2<T, T>) => {
    if (typeof arg === 'function') {
      dataUpdater((prev) => {
        // if T is a function type already, typescript correctly notifies us that this will fail
        return (arg as ((prev: T, prevWhole: T) => T))(prev, prev);
      })
    } else {
      dataUpdater(arg);
    }
  };
  return updaterGenerator2Helper<T, T>(dataObject, dataUpdater2, dataObject);
}

    this.container.position = PixiPointFrom(props.position);
    // this.app.ticker.add(() => {
    //   textFpsHud.text = this.fpsTracker.getFpsString() + " FPS\n" + this.fpsTracker.getUpsString() + " UPS\n" + 
    //   this.app.screen.width + "x" + this.app.screen.height;
    // })
    // textFpsHud.x = this.app.screen.width;
    // this.onResize.push(() => { textFpsHud.x = this.app.screen.width; });
    // textFpsHud.anchor.x = 1; // right justify

    // textFpsHud.x = 0;
    // textFpsHud.y = 0;
    // this.fixedCameraStage.addChild(textFpsHud);

    this.renderSelf(props)