const config = {
  version: 1,
  settings: { theme: "dark", fontSize: 14 },
  tags: ["beta", "v1"],
};

Object.seal(config);
Object.freeze(config.settings);

config.version = 99;
config.newProp = "ignored";
delete config.tags;

config.settings.theme = "light";
config.settings.newKey = "ignored";

config.tags.push("v2");
config.tags[0] = "stable";

console.log(
  config.version,
  config.newProp,
  config.settings.theme,
  config.tags
);

"use strict";

function createCounter() {
  let count = 0;

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

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

const { value, reset } = counter;
reset();

console.log(counter.value, value);

const delay = (val) => Promise.resolve(val);

async function pipeline(input) {
  const result = await delay(input)
    .then((v) => v * 2)
    .then((v) => v + 10)
    .then((v) => {
      if (v > 20) throw new Error(`Too large: ${v}`);
      return v;
    })
    .catch((e) => `Caught: ${e.message}`)
    .then((v) => (typeof v === "string" ? v.toUpperCase() : v * 3));

  return result;
}

Promise.all([pipeline(4), pipeline(8)]).then(([a, b]) => {
  console.log(a);
  console.log(b);
});

const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      return Reflect.get(target, prop, receiver) * 2;
    }
    return `${prop} not found`;
  },
  set(target, prop, value) {
    if (typeof value !== "number") {
      throw new TypeError("Only numbers allowed");
    }
    target[prop] = value + 10;
    return true;
  },
  has(target, prop) {
    return prop.startsWith("x") ? false : prop in target;
  },
};

const obj = new Proxy({ score: 5, xp: 100 }, handler);

obj.level = 3;
console.log(obj.score);
console.log(obj.level);
console.log("xp" in obj);
console.log("score" in obj);
console.log(obj.rank);

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(2));
console.log(curriedVolume(4)(6)(2));

function checkTDZ() {
  console.log(typeof undeclaredVar);

  try {
    console.log(typeof letVar);
  } catch (e) {
    console.log(`Caught: ${e.constructor.name}`);
  }

  let letVar = "initialized";

  const result = (() => {
    let x = 10;
    return function () {
      let x = x + 5;
      return x;
    };
  })();

  try {
    console.log(result());
  } catch (e) {
    console.log(`Caught: ${e.constructor.name}`);
  }
}

checkTDZ();

const str = "  Hello, World!  ";

const result = str
  .trim()
  .split(", ")
  .map((word, i) => {
    return i === 0
      ? word.toUpperCase()
      : word.replace(/!$/, "").split("").reverse().join("") + "?";
  })
  .join(" | ");

const [first, ...rest] = result.split(" | ");
const final = `${first} | ${rest.join(" & ")}`;

console.log(final);

const p1 = new Promise((resolve) => {
  console.log("A");
  resolve("B");
});

const p2 = p1.then((val) => {
  console.log(val);
  return "C";
});

p2.then((val) => {
  console.log(val);
});

console.log("D");