class EventEmitter {
  #listeners = new WeakMap();
  #registry = new FinalizationRegistry((label) => {
    console.log(`Cleaned up: ${label}`);
  });

  subscribe(target, callback) {
    if (!this.#listeners.has(target)) {
      this.#listeners.set(target, []);
    }
    this.#listeners.get(target).push(callback);
    this.#registry.register(target, target.name ?? "unknown");
  }

  emit(target) {
    const cbs = this.#listeners.get(target);
    if (cbs) cbs.forEach(cb => cb());
  }
}

const emitter = new EventEmitter();
let obj1 = { name: "sensor" };
let obj2 = { name: "timer" };

const ws = new WeakSet([obj1, obj2]);

emitter.subscribe(obj1, () => console.log("sensor fired"));
emitter.subscribe(obj2, () => console.log("timer fired"));
emitter.subscribe(obj1, () => console.log("sensor logged"));

emitter.emit(obj1);

console.log(ws.has(obj1));
obj1 = null;
console.log(ws.has({ name: "sensor" }));

const temperature = {
  celsius: 22,
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') {
      return this.celsius;
    }
    if (hint === 'string') {
      return `${this.celsius}°C`;
    }
    return this.celsius + 273.15;
  }
};

console.log(`Temp: ${temperature}`);
console.log(temperature + 0);
console.log(temperature * 2);
console.log(+temperature);

const a = 10n ** 3n;
const b = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
const c = b + 1n;

console.log(typeof a);
console.log(a === 1000n);
console.log(b === c);
console.log(5n / 2n);

const compose = (...fns) => fns.reduce((f, g) => (...args) => f(g(...args)));

const pipe = (...fns) => fns.reduce((f, g) => (...args) => g(f(...args)));

const double  = x => x * 2;
const addTen  = x => x + 10;
const square  = x => x * x;
const negate  = x => -x;

const transform1 = compose(negate, square, addTen, double);
const transform2 = pipe(double, addTen, square, negate);

const val = 3;

console.log(transform1(val), transform2(val));

const obj = {
  name: "Orion",
  greet() {
    const inner = () => {
      console.log(this.name);
    };
    inner();
  },
  greetRegular: function () {
    const inner = function () {
      console.log(this?.name ?? "undefined");
    };
    inner();
  },
};

obj.greet();
obj.greetRegular();

const operations = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b,
  multiply: (a, b) => a * b,
  divide: (a, b) => b !== 0 ? a / b : null,
};

const pipeline = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);

const double  = (x) => operations.multiply(x, 2);
const addTen  = (x) => operations.add(x, 10);
const halve   = (x) => operations.divide(x, 2);
const subtractThree = (x) => operations.subtract(x, 3);

const transform = pipeline(double, addTen, halve, subtractThree);

console.log(transform(5));

"use strict";

function createCounter() {
  let count = 0;

  return {
    increment() { count++; },
    getCount() { return count; },
    reset: function() { count = 0; }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.increment();

const { getCount, reset } = counter;

try {
  reset();
  console.log("After reset:", counter.getCount());
} catch (e) {
  console.log("Error:", e.message);
}

console.log("Direct call:", counter.getCount());

const obj = {
  name: "Quantum",
  regular: function () {
    return this.name;
  },
  arrow: () => {
    return this?.name;
  },
  nested: function () {
    const inner = () => this.name;
    return inner();
  },
};

console.log(obj.regular());
console.log(obj.arrow());
console.log(obj.nested());

const curry = (fn) => {
  const arity = fn.length;
  return function curried(...args) {
    if (args.length >= arity) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
};

const volume = (l, w, h) => l * w * h;
const curriedVolume = curry(volume);

const withLength5 = curriedVolume(5);
const withLength5Width3 = withLength5(3);

console.log(typeof withLength5);
console.log(typeof withLength5Width3);
console.log(withLength5Width3(4));
console.log(curriedVolume(2)(6)(7));