class Base {
  static log = [];
  static {
    Base.log.push('base-block');
  }
  static value = (() => { Base.log.push('base-field'); return 1; })();
}

class Derived extends Base {
  static {
    Derived.log.push('derived-block');
  }
  static value2 = (() => { Derived.log.push('derived-field'); return 2; })();
}

console.log(Derived.log.join(','));

async function* gen() {
  const x = yield 1;
  const y = yield x + 1;
  return x + y;
}

async function main() {
  const it = gen();
  const a = await it.next();
  const b = await it.next(10);
  const c = await it.next(20);
  console.log(`${a.value} ${b.value} ${c.value} ${c.done}`);
}

main();

const sym1 = Symbol('id');
const sym2 = Symbol('id');

const obj = {
  [sym1]: 'first',
  [sym2]: 'second',
  regular: 'value'
};

const s = Symbol.for('shared');
const s2 = Symbol.for('shared');

console.log(
  sym1 === sym2,
  Object.keys(obj).length,
  Reflect.ownKeys(obj).length,
  s === s2,
  sym1.toString()
);

function tag(strings, ...values) {
  return strings.raw.join('|') + '::' + values.join(',');
}

const a = 5, b = 10;
console.log(tag`Sum:\n${a + b} End`);

const a = -7 % 3;
const b = 7 % -3;
const c = 2 ** 3 ** 2;
const d = (2 ** 3) ** 2;
const e = 0.1 + 0.2;
console.log(a, b, c, d, e);

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 })
);