static MinByAndValue<T>(list: T[], fn: (T: T) => number): { obj: T, value: number } | null {

  static MinByAndValue<T>(
    list: T[],
    fn: (T: T) => number
  ): { obj: T; value: number } | null {

    return lowestT === null || lowestValue === null ? null : { obj: lowestT, value: lowestValue };

    return lowestT === null || lowestValue === null
      ? null
      : { obj: lowestT, value: lowestValue };

      return key(a) - key(b)

      return key(a) - key(b);

    const re = new RegExp(Object.keys(mapObj).join('|'), 'gi')

    const re = new RegExp(Object.keys(mapObj).join("|"), "gi");

    return str.replace(re, matched => {
      return mapObj[matched.toLowerCase()]

    return str.replace(re, (matched) => {
      return mapObj[matched.toLowerCase()];

      }

      };

    }

    };

      'Jan',
      'Feb',
      'Mar',
      'Apr',
      'May',
      'Jun',
      'Jul',
      'Aug',
      'Sep',
      'Oct',
      'Nov',
      'Dec',
    ][d.getMonth()]

      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec",
    ][d.getMonth()];

    return `${monthName} ${d.getDate()}, ${('00' + d.getHours()).substr(-2)}:${(
      '00' + d.getMinutes()
    ).substr(-2)}:${('00' + d.getSeconds()).substr(-2)}`;

    return `${monthName} ${d.getDate()}, ${("00" + d.getHours()).substr(-2)}:${(
      "00" + d.getMinutes()
    ).substr(-2)}:${("00" + d.getSeconds()).substr(-2)}`;

    let result: T[] = []

    let result: T[] = [];

      result = result.concat(obj)

      result = result.concat(obj);

    return result

    return result;

  public static PadString(string: string, length: number, intersperse = "", character = " ") {

  public static PadString(
    string: string,
    length: number,
    intersperse = "",
    character = " "
  ) {

export type Const<T> = T extends Function ? T : {
  readonly [P in keyof T]: T[P] extends { [k: string]: any } ? Const<T[P]> : T[P];
}

export type Const<T> = T extends Function
  ? T
  : {
      readonly [P in keyof T]: T[P] extends { [k: string]: any }
        ? Const<T[P]>
        : T[P];
    };

      throw new Error("Error, called more than twice with same id: " + k + " , callback the first time was : " + assertOnlyCalledOnceData[k]);

      throw new Error(
        "Error, called more than twice with same id: " +
          k +
          " , callback the first time was : " +
          assertOnlyCalledOnceData[k]
      );

    const stacktrace = new Error().stack!

    const stacktrace = new Error().stack!;

 * 

 *

  private _factory: () => T

  private _factory: () => T;

  constructor(factory: () => T) {

  constructor(
    factory: () => T,
    // structure?: T extends { [key: string]: any } ? T : void
  ) {

  public wasConstructed(): boolean {
    return this._wasConstructed;
  }

export function LazyProxy<
  T extends { [key: string]: any } | { [i: number]: any }
>(factory: () => T): Const<T> {
  return (new Proxy(new Lazy(factory), {
    get: (target, property, receiver) => {
      if (property === "toJSON") {
        return () => {
          if (target.wasConstructed()) {
            return target.get();
          } else {
            return "[Object Lazy]";
          }
        };
      }
      const targetValue = target.get();
      return Reflect.get(targetValue, property);
    },
    ownKeys: (target) => {
      const targetValue = target.get();
      return Reflect.ownKeys(targetValue);
    },
    getOwnPropertyDescriptor: (target, property) => {
      /**
       * https://stackoverflow.com/questions/40352613/why-does-object-keys-and-object-getownpropertynames-produce-different-output
       */
      return Object.getOwnPropertyDescriptor(target.get(), property);
      
    },
    has: (target, property) => {
      // This is called when iterating over array i.e. array.forEach()
      return property in target.get()
    }
  }) as unknown) as Const<T>;
}

  let reds = [color1 & 0xFF0000, color2 & 0xFF0000];
  let blues = [color1 & 0x0000FF, color2 & 0x0000FF];
  let greens = [color1 & 0x00FF00, color2 & 0x00FF00];
  let out = Math.round(reds[0] / (0x010000) * reds[1] / (0xFFFFFF)) * 0x010000;
  out += Math.round(greens[0] / 0x000100 * greens[1] / 0x00FF00) * 0x000100;
  out += Math.round(blues[0] * blues[1] / 0x0000FF);

  let reds = [color1 & 0xff0000, color2 & 0xff0000];
  let blues = [color1 & 0x0000ff, color2 & 0x0000ff];
  let greens = [color1 & 0x00ff00, color2 & 0x00ff00];
  let out = Math.round(((reds[0] / 0x010000) * reds[1]) / 0xffffff) * 0x010000;
  out += Math.round(((greens[0] / 0x000100) * greens[1]) / 0x00ff00) * 0x000100;
  out += Math.round((blues[0] * blues[1]) / 0x0000ff);

export function enumKeys<T extends string>(enm: { [key in T]: T }) : T[] {

export function enumKeys<T extends string>(enm: { [key in T]: T }): T[] {

// }

// }