const flags = {
  READ:    0b0001,
  WRITE:   0b0010,
  EXECUTE: 0b0100,
  DELETE:  0b1000,
};

const userPermissions  = flags.READ | flags.WRITE | flags.EXECUTE;
const adminPermissions = userPermissions | flags.DELETE;

const canDelete  = (adminPermissions & flags.DELETE)  !== 0;
const canExecute = (userPermissions  & flags.EXECUTE) !== 0;
const readOnly   = userPermissions   ^ flags.WRITE;

console.log(canDelete, canExecute, readOnly, adminPermissions >> 1);

const team = {
  name: "Alpha",
  members: ["Carlos", "Diana", "Eve"],

  listMembers() {
    return this.members.map(function (member) {
      return `${this.name}: ${member}`;
    });
  },

  listMembersArrow() {
    return this.members.map((member) => {
      return `${this.name}: ${member}`;
    });
  },
};

console.log(team.listMembers()[0]);
console.log(team.listMembersArrow()[0]);

function makeCounter(start = 0, step = 1) {
  let count = start;
  const history = [];

  return {
    increment() {
      count += step;
      history.push(count);
      return this;
    },
    decrement() {
      count -= step;
      history.push(count);
      return this;
    },
    getHistory: () => history,
    getCount: () => count,
  };
}

const counter = makeCounter(10, 3);
counter.increment().increment().decrement();

console.log(counter.getCount());
console.log(counter.getHistory());

const inventory = new Map([
  ["sword", { qty: 3, value: 150 }],
  ["shield", { qty: 1, value: 200 }],
  ["potion", { qty: 5, value: 30 }],
]);

const upgraded = new Map(
  [...inventory.entries()]
    .filter(([, item]) => item.value >= 100)
    .map(([key, item]) => [key, { ...item, value: item.value * 2 }])
);

console.log(upgraded.size);
console.log(upgraded.get("sword").value);
console.log(upgraded.has("potion"));
console.log([...upgraded.keys()].join(", "));

const log = [];

const handler = {
  set(target, key, value) {
    log.push(`set:${key}=${value}`);
    target[key] = value;
    return true;
  },
  get(target, key) {
    log.push(`get:${key}`);
    return target[key];
  }
};

const state = new Proxy({}, handler);

state.count = 0;
state.count = state.count + 1;
state.count = state.count + 1;

console.log(log.join(" | "));

const obj = {
  name: "Nikola",
  greetArrow: () => {
    return `Hello, ${this?.name ?? "stranger"}!`;
  },
  greetRegular() {
    return `Hello, ${this.name}!`;
  },
  greetNested() {
    const inner = () => `Hi, ${this.name}!`;
    return inner();
  }
};

console.log(obj.greetArrow());
console.log(obj.greetRegular());
console.log(obj.greetNested());

const a = 9007199254740991n;
const b = BigInt(Number.MAX_SAFE_INTEGER);

console.log(a === b);
console.log(a + 1n);
console.log(typeof a);
console.log(a === 9007199254740991);

const config = {
  timeout: 0,
  retries: null,
  host: "",
  port: undefined,
  debug: false,
};

const timeout = config.timeout ?? 3000;
const retries = config.retries ?? 5;
const host = config.host ?? "localhost";
const port = config.port ?? 8080;
const debug = config.debug ?? true;

console.log(timeout, retries, host, port, debug);

"use strict";

function createCounter() {
  let count = 0;

  return {
    increment() { count++; },
    get value() { return count; },
    toString() { return `Counter: ${count}`; }
  };
}

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

try {
  counter.value = 99;
} catch (e) {
  console.log(`${e.constructor.name}: ${counter}`);
}