async function main() {
  const settled = await Promise.allSettled([
    Promise.resolve(1),
    Promise.reject('err'),
  ]);
  const statuses = settled.map(s => s.status).join(',');

  let anyResult;
  try {
    await Promise.any([Promise.reject('a'), Promise.reject('b')]);
  } catch (err) {
    anyResult = `${err.name}:${err.errors.join(',')}`;
  }

  console.log(statuses, anyResult);
}

main();

const output = [];
output.push(typeof foo);
try {
  output.push(typeof bar);
} catch (e) {
  output.push(e.message);
}
var foo = () => 'foo';
let bar = () => 'bar';
console.log(output.join(' | '));

const arr = [1, [2, 3], [4, [5, 6]]];
const a = arr.flat();
const b = arr.flat(Infinity);
const c = arr.flatMap(x => Array.isArray(x) ? x : [x, x]);
console.log(a, b, c);

function* inner() {
  const x = yield 1;
  yield x + 1;
  return 100;
}

function* outer() {
  const result = yield* inner();
  yield result;
}

const g = outer();
console.log(g.next().value, g.next(10).value, g.next().value, g.next().value);

const obj = {
  value: 42,
  getValue: function() {
    return this.value;
  }
};

const unboundGetValue = obj.getValue;
const boundGetValue = unboundGetValue.bind(obj);
const boundTwice = boundGetValue.bind({ value: 100 });

console.log(
  boundGetValue(),
  boundTwice(),
  unboundGetValue.call({ value: 7 }),
  obj.getValue.apply({ value: 99 })
);

class EventBus {
  #listeners = new Map();
  on(event, cb) {
    if (!this.#listeners.has(event)) this.#listeners.set(event, []);
    this.#listeners.get(event).push(cb);
    return this;
  }
  emit(event, ...args) {
    const cbs = this.#listeners.get(event) || [];
    return cbs.map(cb => cb(...args));
  }
}

const bus = new EventBus();
bus.on('data', x => x * 2).on('data', x => x + 1);
const results = bus.emit('data', 5);
console.log(results, bus.emit('missing', 1));