function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    const value = values[i - 1];
    const formatted =
      typeof value === "number"
        ? `[${value.toFixed(2)}]`
        : `<${String(value).toUpperCase()}>`;
    return result + formatted + str;
  });
}

const item = "sword";
const qty = 3;
const price = 9.5;

const output = highlight`You bought ${qty} ${item}s for $${price} each.`;
console.log(output);

const inventory = [
  { name: "sword", type: "weapon", power: 85 },
  { name: "shield", type: "armor", power: 60 },
  { name: "bow", type: "weapon", power: 72 },
  { name: "helmet", type: "armor", power: 45 },
  { name: "dagger", type: "weapon", power: 91 },
];

const result = inventory
  .filter(item => item.type === "weapon")
  .map(item => ({ ...item, power: item.power * 1.1 }))
  .sort((a, b) => b.power - a.power)
  .reduce((acc, item, index) => {
    acc[index === 0 ? "best" : "rest"] ??= [];
    if (index === 0) acc.best = item.name;
    else acc.rest.push(item.name);
    return acc;
  }, {});

console.log(result.best, result.rest);

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

const store = new Proxy({ xRay: 5, score: 3 }, handler);

store.level = 4;

console.log(store.xRay);
console.log(store.score);
console.log(store.level);
console.log("xRay" in store);
console.log("score" in store);
console.log(store.missing);

const inventory = {
  warehouse: {
    shelves: [
      { id: 'A1', items: ['bolts', 'nuts', 'washers'] },
      { id: 'B2', items: ['hammers', 'wrenches'] },
    ],
    manager: { name: 'Carlos', shift: 'night' },
  },
};

const {
  warehouse: {
    shelves: [{ items: [firstItem, , thirdItem] }, { id: shelfId }],
    manager: { name, shift = 'day' },
  },
} = inventory;

console.log(`${name} | ${shift} | ${shelfId} | ${firstItem} | ${thirdItem}`);

async function fetchData(id) {
  if (id <= 0) throw new Error("Invalid ID");
  return { id, value: id * 10 };
}

async function process() {
  const results = await Promise.allSettled([
    fetchData(1),
    fetchData(-1),
    fetchData(3),
  ]);

  results.forEach(({ status, value, reason }) => {
    if (status === "fulfilled") {
      console.log(`✅ ${value.id}: ${value.value}`);
    } else {
      console.log(`❌ ${reason.message}`);
    }
  });
}

process();

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

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(negate, square, addTen, double);

console.log(transform1(3));
console.log(transform2(3));

const setA = new Set([1, 2, 3, 4, 5]);
const setB = new Set([3, 4, 5, 6, 7]);

const union = new Set([...setA, ...setB]);

const intersection = new Set([...setA].filter(x => setB.has(x)));

const differenceAB = new Set([...setA].filter(x => !setB.has(x)));

const symmetricDiff = new Set(
  [...setA, ...setB].filter(x => !(setA.has(x) && setB.has(x)))
);

console.log([...union].join(','));
console.log([...intersection].join(','));
console.log([...differenceAB].join(','));
console.log([...symmetricDiff].join(','));