JavaScript Statements, Reserved Words, Operators & Operator Precedence

// ❌ Using reserved words as variable names
let class   = "Math 101"; // SyntaxError
let return  = 5;          // SyntaxError
let if      = true;       // SyntaxError
let for     = 10;         // SyntaxError

"use strict";

let private = 5;     // SyntaxError in strict mode
let public  = true;  // SyntaxError in strict mode
let static  = {};    // SyntaxError in strict mode

// ❌ You CAN do this but NEVER should:
let undefined = "I redefined undefined!";
console.log(undefined); // "I redefined undefined!" — real undefined is hidden

let NaN = 42;
console.log(isNaN(NaN)); // false! — isNaN(42) is false

// ✅ Always treat these as read-only reserved words

// ❌ Shadowing built-ins — lose their functionality
let Math = { PI: 3 };     // Real Math object is now unreachable
let Array = [];            // Real Array constructor is gone!

// ✅ Pick different names
let mathUtils = { PI: 3.14159 };
let productList = [];

// Allowed — as object properties
let config = {
  class: "premium",      // ✅ Legal as a property key
  return: true,          // ✅ Legal as a property key
  default: "light"       // ✅ Legal as a property key
};

console.log(config.class);   // "premium"
console.log(config.return);  // true
console.log(config.default); // "light"

// But still confusing — prefer descriptive alternatives:
let config2 = {
  tier: "premium",          // Clearer
  redirectOnSuccess: true,  // Clearer
  defaultTheme: "light"     // Clearer
};

let result = 10 + 5; // + is the operator, 10 and 5 are operands, 15 is the result

console.log(10 % 3);  // 1  (10 = 3×3 + 1)
console.log(15 % 4);  // 3  (15 = 4×3 + 3)
console.log(20 % 5);  // 0  (20 = 5×4 + 0, perfectly divisible)

// Real-world use 1: Even/odd check
function isEven(n) { return n % 2 === 0; }
console.log(isEven(8));  // true
console.log(isEven(7));  // false

// Real-world use 2: Wrap around (circular indexing)
let items = ["A", "B", "C", "D"];
for (let i = 0; i < 10; i++) {
  console.log(items[i % items.length]); // A B C D A B C D A B
}

console.log(2 ** 10);   // 1024  (2 to the power of 10)
console.log(9 ** 0.5);  // 3     (square root of 9)
console.log(27 ** (1/3)); // 3   (cube root of 27)

let a = 5;
let b = a++; // Postfix: b gets the CURRENT value (5), THEN a increments
console.log(a); // 6
console.log(b); // 5 ← Got the old value

let c = 5;
let d = ++c; // Prefix: c increments FIRST, THEN d gets the NEW value
console.log(c); // 6
console.log(d); // 6 ← Got the new value

let balance = 10000;

balance += 5000;  // Deposit
console.log(balance); // 15000

balance -= 2000;  // Withdrawal
console.log(balance); // 13000

balance *= 1.05;  // 5% interest
console.log(balance); // 13650

// ||= : Assign only if current value is falsy
let username = "";
username ||= "Guest";
console.log(username); // "Guest" — because "" is falsy

let title = "Admin";
title ||= "User";
console.log(title); // "Admin" — because "Admin" is truthy (no assignment)

// ??= : Assign only if current value is null or undefined
let config = null;
config ??= { theme: "dark" };
console.log(config); // { theme: "dark" }

let settings = { theme: "light" };
settings ??= { theme: "dark" };
console.log(settings); // { theme: "light" } — not null/undefined, no assignment

// &&= : Assign only if current value is truthy
let user = { name: "Tunde", isAdmin: true };
user.isAdmin &&= false; // Only updates if isAdmin is currently truthy
console.log(user.isAdmin); // false

// == performs type coercion before comparing
console.log(0   == false);      // true  ← 0 coerced to false
console.log(1   == true);       // true  ← 1 coerced to true
console.log(""  == false);      // true  ← "" coerced to false
console.log("1" == 1);          // true  ← "1" coerced to 1
console.log(null == undefined); // true  ← special rule

// === never coerces — same type AND same value required
console.log(0   === false);     // false ← number vs boolean
console.log("1" === 1);         // false ← string vs number
console.log(null === undefined);// false ← different types

console.log("apple" < "banana"); // true  — a comes before b
console.log("Z" < "a");          // true  — uppercase letters come before lowercase in Unicode
console.log("10" > "9");         // false — "1" comes before "9" in string comparison!

// To compare numbers stored as strings, convert first:
console.log(Number("10") > Number("9")); // true ✅

let firstName = "Babatunde";
let lastName  = "Adewale";
let fullName  = firstName + " " + lastName;
console.log(fullName); // Babatunde Adewale

let message = "Hello";
message += ", world!"; // Same as: message = message + ", world!"
console.log(message);  // Hello, world!

// Old way — concatenation
let greeting = "Dear " + firstName + ",\nYour balance is ₦" + balance + ".";

// Modern way — template literals (much cleaner)
let greeting2 = `Dear ${firstName},
Your balance is ₦${balance}.`;

// Returns the FIRST FALSY value encountered, or the LAST value if all are truthy
console.log(true  && true);   // true   — both truthy, returns last: true
console.log(true  && false);  // false  — hits false, returns it
console.log(false && true);   // false  — hits false immediately, returns it
console.log(false && false);  // false  — hits false immediately

// With non-boolean values:
console.log(1 && 2 && 3);     // 3     — all truthy, returns last
console.log(1 && 0 && 3);     // 0     — 0 is falsy, returns it
console.log("hi" && null && "there"); // null — first falsy

// Real-world use — guard clauses:
let user = { name: "Tunde", address: { city: "Lagos" } };
let city = user && user.address && user.address.city;
console.log(city); // "Lagos" — only accesses .address if user exists

// Returns the FIRST TRUTHY value, or the LAST value if all are falsy
console.log(false || true);   // true
console.log(false || false);  // false — all falsy, returns last
console.log(0     || "hello");// "hello" — first truthy
console.log(""    || "Guest");// "Guest" — first truthy

// Real-world use — default values:
function createUser(name, role) {
  return {
    name: name || "Anonymous",   // Use "Anonymous" if name is falsy
    role: role || "viewer"       // Use "viewer" if role is falsy
  };
}

console.log(createUser("Tunde", "admin")); // { name: "Tunde", role: "admin" }
console.log(createUser("", ""));           // { name: "Anonymous", role: "viewer" }

// The problem with || for defaults:
let quantity = 0;      // User set quantity to 0 — legitimately empty
let display = quantity || 1; // Gets 1 — WRONG! 0 is a valid value
console.log(display); // 1 ← Bug: treats 0 as "no value"

// ?? solves this:
let display2 = quantity ?? 1; // Only uses 1 if quantity is null/undefined
console.log(display2); // 0 ← Correct!

// More comparisons:
console.log(0     ?? "default"); // 0        — 0 is not null/undefined
console.log(""    ?? "default"); // ""       — "" is not null/undefined
console.log(false ?? "default"); // false    — false is not null/undefined
console.log(null  ?? "default"); // "default"— null triggers ??
console.log(undefined ?? "def"); // "def"   — undefined triggers ??

console.log(!true);    // false
console.log(!false);   // true
console.log(!0);       // true  — 0 is falsy, so !0 is true
console.log(!"");      // true  — "" is falsy
console.log(!"hello"); // false — "hello" is truthy

// Double negation !! — converts any value to its boolean equivalent
console.log(!!"hello"); // true   — truthy value → true
console.log(!!0);       // false  — falsy value → false
console.log(!!null);    // false
console.log(!!{});      // true   — empty object is truthy

console.log(typeof 42);          // "number"
console.log(typeof 3.14);        // "number"
console.log(typeof NaN);         // "number" ← NaN is technically a number type
console.log(typeof "hello");     // "string"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object"  ← famous JavaScript bug
console.log(typeof {});          // "object"
console.log(typeof []);          // "object"  ← arrays are objects
console.log(typeof function(){}); // "function"
console.log(typeof Symbol());    // "symbol"
console.log(typeof 42n);         // "bigint"

let arr = [1, 2, 3];
let date = new Date();
let err  = new TypeError("oops");

console.log(arr  instanceof Array);     // true
console.log(arr  instanceof Object);    // true  — arrays are objects too
console.log(date instanceof Date);      // true
console.log(date instanceof Object);    // true
console.log(err  instanceof TypeError); // true
console.log(err  instanceof Error);     // true  — TypeError extends Error

// Use Array.isArray() to definitively check for arrays:
console.log(Array.isArray(arr));        // true
console.log(Array.isArray({}));         // false

5  in binary:  0101
3  in binary:  0011

5 & 3:         0001 = 1  (AND: 1 only where BOTH are 1)
5 | 3:         0111 = 7  (OR:  1 where EITHER is 1)
5 ^ 3:         0110 = 6  (XOR: 1 where bits DIFFER)
~5:          ...11111010 = -6 (all bits flipped, two's complement)
5 << 1:        1010 = 10 (shift left by 1 = multiply by 2)
5 >> 1:        0010 = 2  (shift right by 1 = floor divide by 2)

// Use bits as on/off flags (common in systems programming and game dev)
const READ    = 0b001; // 1
const WRITE   = 0b010; // 2
const EXECUTE = 0b100; // 4

// Grant permissions by OR-ing flags together:
let userPermissions = READ | WRITE; // 0b011 = 3

// Check a permission with AND:
console.log((userPermissions & READ)    > 0); // true  — has read
console.log((userPermissions & WRITE)   > 0); // true  — has write
console.log((userPermissions & EXECUTE) > 0); // false — no execute

// Fast even/odd check using bitwise AND:
console.log(7 & 1); // 1 — odd   (last bit is 1)
console.log(8 & 1); // 0 — even  (last bit is 0)

condition ? valueIfTrue : valueIfFalse

let age = 20;
let status = age >= 18 ? "adult" : "minor";
console.log(status); // "adult"

// Equivalent if...else:
let status2;
if (age >= 18) {
  status2 = "adult";
} else {
  status2 = "minor";
}

let stockCount = 0;
let availability = stockCount > 0 ? "In Stock" : "Out of Stock";
console.log(availability); // "Out of Stock"

let cartTotal = 15000;
let deliveryFee = cartTotal >= 20000 ? 0 : 1500;
console.log(`Delivery: ₦${deliveryFee}`); // Delivery: ₦1,500

// Nested ternary — use sparingly (readable up to 2 levels)
let score = 72;
let grade = score >= 90 ? "A"
          : score >= 80 ? "B"
          : score >= 70 ? "C"
          : score >= 60 ? "D"
          :               "F";
console.log(grade); // "C"

let user = {
  profile: {
    address: {
      city: "Lagos"
    }
  }
};

// ❌ Without optional chaining — crashes if any level is missing
console.log(user.profile.address.city);        // "Lagos" ✅
console.log(user.profile.address.postcode);    // undefined ✅
// But what if user.profile doesn't exist?
console.log(user.contact.phone);               // TypeError ❌

// ✅ With optional chaining — returns undefined instead of crashing
console.log(user?.profile?.address?.city);     // "Lagos"
console.log(user?.contact?.phone);             // undefined (no crash)
console.log(user?.profile?.address?.postcode); // undefined

// Works for method calls too:
let cart = null;
console.log(cart?.getTotal()); // undefined (no crash)

// Works for array indexing:
let items = null;
console.log(items?.[0]); // undefined (no crash)

let product = {
  id: 1,
  name: "Laptop",
  internalCode: "XYZ-99", // Should not be sent to the client
  price: 450000
};

delete product.internalCode;
console.log(product);
// Expected Output: { id: 1, name: "Laptop", price: 450000 }

// delete does NOT work on variables:
let x = 10;
delete x;       // Returns false (or throws in strict mode)
console.log(x); // 10 — still exists

let car = { brand: "Toyota", year: 2022 };

console.log("brand" in car);  // true
console.log("year"  in car);  // true
console.log("colour" in car); // false

// Works with arrays (checks index positions):
let fruits = ["mango", "pear", "guava"];
console.log(0 in fruits); // true  — index 0 exists
console.log(5 in fruits); // false — index 5 doesn't exist

// Useful for checking optional properties safely:
function displayCar(car) {
  if ("colour" in car) {
    console.log("Colour:", car.colour);
  } else {
    console.log("Colour not specified");
  }
}

console.log(void 0);          // undefined
console.log(void "anything"); // undefined
console.log(void (2 + 2));    // undefined

// Arrow function — avoid returning a value accidentally
button.addEventListener("click", () => void updateCounter());
// Without void, if updateCounter() returned a value, the listener would return it
// void ensures the listener always returns undefined

// Spreading into a function call
let numbers = [3, 1, 4, 1, 5, 9, 2, 6];
console.log(Math.max(...numbers)); // 9 — spreads array as individual args

// Spreading to copy and merge arrays
let fruits = ["mango", "pear"];
let veggies = ["carrot", "spinach"];
let allFood = [...fruits, ...veggies];
console.log(allFood); // ["mango", "pear", "carrot", "spinach"]

// Spreading to copy and merge objects
let defaults = { theme: "light", lang: "en",  fontSize: 14 };
let userPrefs = { theme: "dark",  fontSize: 16 };
let settings = { ...defaults, ...userPrefs };
console.log(settings);
// { theme: "dark", lang: "en", fontSize: 16 }
// userPrefs properties override defaults

// In for loops — initialise or update multiple variables
for (let i = 0, j = 10; i < 5; i++, j--) {
  console.log(i, j);
}
// Output: 0 10 | 1 9 | 2 8 | 3 7 | 4 6

// Standalone — evaluates all, returns last
let result = (5 + 3, 10 + 2, 7 * 3);
console.log(result); // 21 — only the last expression's value is kept

let result = 2 + 3 * 4;
// Is this (2 + 3) * 4 = 20?
// Or 2 + (3 * 4) = 14?

console.log(result); // 14 — multiplication has higher precedence than addition

let a = 10 - 3 - 2;
// Same precedence → left to right: (10 - 3) - 2 = 7 - 2 = 5
console.log(a); // 5

// Assignment is right-to-left:
let x, y, z;
x = y = z = 10;
// Evaluated right-to-left: z = 10 first, then y = z (10), then x = y (10)
console.log(x, y, z); // 10 10 10

// Exponentiation is right-to-left:
let b = 2 ** 3 ** 2;
// Right-to-left: 3 ** 2 = 9 first, then 2 ** 9 = 512
console.log(b); // 512  (not (2**3)**2 = 8**2 = 64)

let result = 100 - 5 * 2 ** 3 + 10 / 2;

// Step-by-step:
// 1. ** (level 16):    2 ** 3 = 8
//    Expression: 100 - 5 * 8 + 10 / 2
// 2. * and / (level 15, left-to-right):
//    5 * 8  = 40  → 100 - 40 + 10 / 2
//    10 / 2 = 5   → 100 - 40 + 5
// 3. - and + (level 14, left-to-right):
//    100 - 40 = 60 → 60 + 5 = 65

console.log(result); // 65

let age = 25;
let hasID = true;
let isEmployee = false;

let canEnter = age >= 18 && hasID || isEmployee;

// Step-by-step:
// 1. >= (level 12):     age >= 18 → true
//    Expression: true && hasID || isEmployee
// 2. && (level 7):      true && hasID → true && true → true
//    Expression: true || isEmployee
// 3. || (level 6):      true || false → true

console.log(canEnter); // true

let a = 5;
let b = 10;
let c = a += b * 2;

// Step-by-step:
// 1. * (level 15):     b * 2 = 20
// 2. += (level 4, right-to-left): a += 20 → a = 5 + 20 = 25
// 3. = (level 4, right-to-left): c = 25

console.log(a); // 25
console.log(c); // 25

// typeof has higher precedence than + (level 17 vs 14)
let result = typeof "hello" + " world";

// Step-by-step:
// 1. typeof (level 17):  typeof "hello" → "string"
// 2. + (level 14):       "string" + " world" → "string world"

console.log(result); // "string world"
// NOT typeof ("hello" + " world") which would be "string"

// Without parentheses — follows default precedence
let a = 2 + 3 * 4;      // 14 (multiplication first)
let b = 2 ** 3 ** 2;     // 512 (right-to-left)
let c = 5 - 3 - 1;       // 1   (left-to-right)

// With parentheses — explicit control
let a2 = (2 + 3) * 4;    // 20
let b2 = (2 ** 3) ** 2;  // 64
let c2 = 5 - (3 - 1);    // 3

// Real-world: tax calculation
let price = 1000;
let taxRate = 0.1;

// ❌ Wrong — tax is applied to only 1, not the full expression
let wrong = price * taxRate + 1;  // 1000 * 0.1 + 1 = 101 (taxRate + 1 was intended)

// ✅ Correct — parentheses make the intent explicit
let correct = price * (1 + taxRate); // 1000 * 1.1 = 1100

// Can be misleading without parentheses
let isAdmin   = false;
let isLoggedIn= true;
let isOwner   = true;

let canEdit = isAdmin || isLoggedIn && isOwner;
// && has higher precedence than ||
// Evaluated as: isAdmin || (isLoggedIn && isOwner)
// = false || (true && true) = false || true = true

// Is this what you intended?
// If you wanted (isAdmin || isLoggedIn) && isOwner — use parentheses!
let canEdit2 = (isAdmin || isLoggedIn) && isOwner;
// = (false || true) && true = true && true = true
// Same result here, but logic is different — matters when values change

// Already shown above, but worth repeating
console.log(typeof 10 + 20);   // "number20" — typeof runs first!
console.log(typeof (10 + 20)); // "number"   — parentheses control order

let n = 5;
let result = n++ * 2; // Postfix: uses 5 THEN increments
// = 5 * 2 = 10
// n is now 6

let m = 5;
let result2 = ++m * 2; // Prefix: increments THEN uses 6
// = 6 * 2 = 12
// m is now 6

console.log(result);  // 10
console.log(result2); // 12

// Ternary is right-associative
let x = true ? "a" : false ? "b" : "c";
// Evaluated right-to-left: true ? "a" : (false ? "b" : "c")
// = "a" (because condition is true)

// But if the first condition is false:
let y = false ? "a" : false ? "b" : "c";
// = false ? "a" : (false ? "b" : "c")
// = (false ? "b" : "c") = "c"

console.log(y); // "c"

// && short-circuits on first falsy value
let user = null;
let name = user && user.name; // user is null (falsy) → short-circuits → name = null
console.log(name); // null — user.name was never accessed (no TypeError!)

// || short-circuits on first truthy value
let cached = null;
let data = cached || fetchFromServer(); // cached is null → fetchFromServer() IS called
// If cached had a value, fetchFromServer() would NEVER run — performance benefit!

// Practical guard with && and precedence
let config = {
  database: {
    host: "localhost"
  }
};

// Without optional chaining — uses && short-circuit
let port = config && config.database && config.database.port;
console.log(port); // undefined — but no crash

// Modern equivalent with optional chaining (cleaner)
let port2 = config?.database?.port;
console.log(port2); // undefined

// Simple precedence-respecting calculation chain:
function applyOperator(op, a, b) {
  switch (op) {
    case "+": return a + b;
    case "-": return a - b;
    case "*": return a * b;
    case "/": return b !== 0 ? a / b : null; // Guard against division by zero
    case "%": return b !== 0 ? a % b : null;
    case "**": return a ** b;
    default:  return null;
  }
}

console.log(applyOperator("*", 5, 3));  // 15
console.log(applyOperator("/", 10, 0)); // null — safe!

"use strict";

const MathUtils = {

  // Operator metadata — precedence and associativity
  operators: {
    "+"  : { precedence: 14, assoc: "left",  fn: (a, b) => a + b  },
    "-"  : { precedence: 14, assoc: "left",  fn: (a, b) => a - b  },
    "*"  : { precedence: 15, assoc: "left",  fn: (a, b) => a * b  },
    "/"  : { precedence: 15, assoc: "left",  fn: (a, b) => b !== 0 ? a / b : (() => { throw new RangeError("Division by zero"); })() },
    "%"  : { precedence: 15, assoc: "left",  fn: (a, b) => a % b  },
    "**" : { precedence: 16, assoc: "right", fn: (a, b) => a ** b  }
  },

  // Evaluate a simple two-operand expression
  evaluate(a, operator, b) {
    let op = this.operators[operator];
    if (!op) throw new TypeError(`Unknown operator: "${operator}"`);

    try {
      return op.fn(a, b);
    } catch (error) {
      console.error("Evaluation error:", error.message);
      return null;
    }
  },

  // Compare precedence of two operators
  comparePrecedence(op1, op2) {
    let p1 = this.operators[op1]?.precedence ?? 0;
    let p2 = this.operators[op2]?.precedence ?? 0;

    if (p1 > p2) return `"${op1}" evaluates before "${op2}" (${p1} > ${p2})`;
    if (p1 < p2) return `"${op2}" evaluates before "${op1}" (${p2} > ${p1})`;
    return `"${op1}" and "${op2}" have equal precedence — use associativity rules`;
  },

  // Show step-by-step evaluation of a three-term expression
  explainEvaluation(a, op1, b, op2, c) {
    let prec1 = this.operators[op1]?.precedence ?? 0;
    let prec2 = this.operators[op2]?.precedence ?? 0;

    console.log(`\nExpression: ${a} ${op1} ${b} ${op2} ${c}`);

    if (prec1 >= prec2) {
      let intermediate = this.evaluate(a, op1, b);
      let result       = this.evaluate(intermediate, op2, c);
      console.log(`  Step 1: ${a} ${op1} ${b} = ${intermediate}`);
      console.log(`  Step 2: ${intermediate} ${op2} ${c} = ${result}`);
      console.log(`  Result: ${result}`);
      return result;
    } else {
      let intermediate = this.evaluate(b, op2, c);
      let result       = this.evaluate(a, op1, intermediate);
      console.log(`  Step 1: ${b} ${op2} ${c} = ${intermediate}`);
      console.log(`  Step 2: ${a} ${op1} ${intermediate} = ${result}`);
      console.log(`  Result: ${result}`);
      return result;
    }
  }
};

// Test the evaluator:
console.log(MathUtils.evaluate(10, "*", 5));    // 50
console.log(MathUtils.evaluate(10, "/", 0));    // null (with error message)
console.log(MathUtils.evaluate(2,  "**", 10));  // 1024

console.log(MathUtils.comparePrecedence("*", "+")); // * evaluates before +
console.log(MathUtils.comparePrecedence("+", "-")); // equal precedence

MathUtils.explainEvaluation(2, "+", 3, "*", 4);
// Step 1: 3 * 4 = 12
// Step 2: 2 + 12 = 14
// Result: 14

MathUtils.explainEvaluation(10, "-", 4, "-", 3);
// Step 1: 10 - 4 = 6
// Step 2: 6 - 3 = 3
// Result: 3

const CodeAnalyser = {

  // Current JS reserved words
  RESERVED_WORDS: new Set([
    "break","case","catch","class","const","continue","debugger","default",
    "delete","do","else","export","extends","false","finally","for","function",
    "if","import","in","instanceof","let","new","null","return","static",
    "super","switch","this","throw","true","try","typeof","var","void",
    "while","with","yield"
  ]),

  // Strict mode additions
  STRICT_RESERVED: new Set([
    "implements","interface","package","private","protected","public","static","let","yield"
  ]),

  // Dangerous (not reserved but should be avoided)
  DANGEROUS_NAMES: new Set([
    "undefined","NaN","Infinity","eval","arguments","name",
    "Math","JSON","Date","Array","Object","String","Number","Boolean",
    "Error","TypeError","ReferenceError","SyntaxError","RangeError",
    "parseInt","parseFloat","isNaN","isFinite"
  ]),

  checkIdentifier(name) {
    console.log(`\nChecking: "${name}"`);

    if (this.RESERVED_WORDS.has(name)) {
      console.error(`  ❌ RESERVED WORD — "${name}" is a JavaScript keyword. Will cause SyntaxError.`);
      return "reserved";
    }

    if (this.STRICT_RESERVED.has(name)) {
      console.warn(`  ⚠️  STRICT RESERVED — "${name}" cannot be used in strict mode.`);
      return "strict-reserved";
    }

    if (this.DANGEROUS_NAMES.has(name)) {
      console.warn(`  ⚠️  DANGEROUS — "${name}" shadows a global built-in. Avoid this.`);
      return "dangerous";
    }

    // Check naming convention
    if (/^[A-Z_]+$/.test(name)) {
      console.log(`  ✅ Valid — looks like a constant (UPPER_SNAKE_CASE).`);
    } else if (/^[A-Z]/.test(name)) {
      console.log(`  ✅ Valid — looks like a class name (PascalCase).`);
    } else if (/^[a-z]/.test(name)) {
      console.log(`  ✅ Valid — looks like a variable or function (camelCase).`);
    } else {
      console.warn(`  ⚠️  Valid but unconventional name — starts with "_" or digit?`);
    }

    return "valid";
  },

  checkMultiple(names) {
    console.log("=".repeat(40));
    console.log("IDENTIFIER AUDIT REPORT");
    console.log("=".repeat(40));

    let results = { reserved: 0, strictReserved: 0, dangerous: 0, valid: 0 };

    for (let name of names) {
      let result = this.checkIdentifier(name);
      if      (result === "reserved")        results.reserved++;
      else if (result === "strict-reserved") results.strictReserved++;
      else if (result === "dangerous")       results.dangerous++;
      else                                   results.valid++;
    }

    console.log("\n── Summary ──");
    console.log(`  Reserved word errors:  ${results.reserved}`);
    console.log(`  Strict mode warnings:  ${results.strictReserved}`);
    console.log(`  Dangerous shadowing:   ${results.dangerous}`);
    console.log(`  Valid identifiers:     ${results.valid}`);
    return results;
  }
};

// Test the checker:
CodeAnalyser.checkMultiple([
  "userName",      // valid
  "class",         // reserved word
  "static",        // strict reserved
  "NaN",           // dangerous
  "TAX_RATE",      // valid constant
  "BankAccount",   // valid class name
  "return",        // reserved word
  "calculateTotal" // valid function name
]);

// Full demonstration: parse a simple financial formula step by step
console.log("\n" + "=".repeat(50));
console.log("FINANCIAL FORMULA EVALUATOR");
console.log("=".repeat(50));

let price    = 450000;
let qty      = 2;
let taxRate  = 0.075;
let discount = 0.10;

// Formula: totalCost = price * qty * (1 - discount) * (1 + taxRate)
// Let's evaluate and explain each step

console.log(`\nFormula: ${price} * ${qty} * (1 - ${discount}) * (1 + ${taxRate})`);

let subtotal       = MathUtils.evaluate(price, "*", qty);
console.log(`Subtotal: ${price} * ${qty} = ₦${subtotal.toLocaleString()}`);

let discountFactor = 1 - discount; // 0.9
let discounted     = subtotal * discountFactor;
console.log(`After 10% discount: ₦${discounted.toLocaleString()}`);

let taxFactor      = 1 + taxRate; // 1.075
let finalTotal     = discounted * taxFactor;
console.log(`After 7.5% tax: ₦${finalTotal.toLocaleString()}`);

// Verify precedence understanding:
let manual = price * qty * (1 - discount) * (1 + taxRate);
console.assert(
  Math.abs(finalTotal - manual) < 0.01,
  "Step-by-step and direct calculation should match"
);
console.log(`\n✅ Verification passed: ₦${manual.toLocaleString()}`);
// Expected: ₦ 877,050

// Check the identifiers we used:
CodeAnalyser.checkMultiple(["price", "qty", "taxRate", "discount", "subtotal", "finalTotal"]);