The LIPI Manual.

<!-- Step 1: Include the engine -->
<script src="lipi.js"></script>

<!-- Step 2: Write LIPI code with Lipi.run() -->
<script>
  document.addEventListener('DOMContentLoaded', () => {
    Lipi.run(`
      log("Hello from LIPI!")
      let x = 10 + 5
      log("Result: " + x)
    `);
  });
</script>

# Your first LIPI program
let language = "LIPI"
let version  = 11.0
let ready    = true

log("Language: " + language)
log("Version:  " + version)
log("Ready:    " + ready)

# All five primitive types
let name    = "Ram"          # String
let score   = 98.5             # Number (integer or float)
let active  = true             # Boolean
let nothing = null             # Null
let pending = undefined        # Undefined

log(type(name))   # "string"
log(type(score))  # "number"
log(type(active)) # "boolean"
log(type(nothing))# "null"

# Hash comment — Python-style, can appear on its own line
let x = 10  # inline comment after a value token

// Double-slash comment — JavaScript-style
let y = 20  // also works inline

let name = "World"
let count = 3

# Standard concatenation
log("Hello, " + name + "!")

# Backtick interpolation (cleaner for complex strings)
log(`Hello, {name}! You have {count} messages.`)

# Escape sequences work in all string types
log("Line one\nLine two")
log("Tab:\there")

let n = 10

n += 5   # n = 15  (add and assign)
n -= 3   # n = 12  (subtract and assign)
n *= 2   # n = 24  (multiply and assign)
n //= 5  # n = 4   (floor-divide and assign)
n **= 3  # n = 64  (exponentiate and assign)
n %= 10  # n = 4   (modulo and assign)
log(n)

let i = 0
i++        # postfix increment: i = 1
i++        # i = 2
--i        # prefix decrement: i = 1
log(i)     # 1

let age    = 20
let status = "adult" if age >= 18 else "minor"
log(status) # "adult"

let score = 72
let grade = "A" if score >= 90 else "B" if score >= 70 else "C"
log(grade) # "B"

let temp = 22

if temp > 35 {
  log("Extreme heat warning")
} else if temp > 25 {
  log("Warm day")
} else if temp > 15 {
  log("Comfortable temperature")
} else {
  log("Cold conditions")
}

let user   = "Ram"
let role   = "admin"
let active = true

if active and role == "admin" {
  log("Access granted to " + user)
}

if role == "guest" or not active {
  log("Limited access")
} else {
  log("Full access")
}

let balance = 100

# Will pass — balance is positive
assert balance > 0, "Balance must be positive"

let items = [1, 2, 3]
assert len(items) == 3

log("All assertions passed")

let fuel = 5

while fuel > 0 {
  log("Fuel remaining: " + fuel)
  fuel--
  wait(200)
}
log("Tank empty.")

let planets = ["Mercury", "Venus", "Earth", "Mars"]

for planet in planets {
  log("Planet: " + planet)
}

let config = {host: "localhost", port: 8080, debug: true}

for key in config {
  log(key + " = " + config[key])
}

# Iterate 0..4
for i in 5 {
  log("i = " + i)
}

# range(start, end)  — does NOT include end
for n in range(1, 6) {
  log(n)
}

# range(start, end, step)
for x in range(0, 10, 2) {
  log(x) # 0, 2, 4, 6, 8
}

# break — exit the loop early
for i in 10 {
  if i == 4 { break }
  log("i = " + i) # logs 0, 1, 2, 3
}

# continue — skip the rest of this iteration
for n in range(1, 8) {
  if n % 2 == 0 { continue }
  log(n) # logs 1, 3, 5, 7
}

# Basic function with parameters and return
func add(a, b) {
  return a + b
}

# Functions can return any type
func greet(name) {
  return "Hello, " + name + "!"
}

# Functions without return implicitly return undefined
func printLine(msg) {
  log("[LOG] " + msg)
}

let sum = add(12, 8)
log(sum)                 # 20
log(greet("Ram"))     # "Hello, Ram!"
printLine("test")

func factorial(n) {
  if n <= 1 { return 1 }
  return n * factorial(n - 1)
}

for i in range(1, 8) {
  log(`{i}! = {factorial(i)}`)
}

func countdown(from) {
  let n = from
  while n > 0 {
    log("T-minus: " + n)
    wait(400)
    n--
  }
  log("🚀 Liftoff!")
}

countdown(5)

let scores = [95, 87, 62, 78, 91]

# Index access (zero-based)
log(scores[0])          # 95
log(scores[len(scores) - 1]) # 91 (last element)

# Mutation
scores[2] = 70
log(scores)

# Array size
log("Count: " + len(scores))

# Append / pop
append(scores, 100)
log(scores)
pop(scores)
log(scores)

let nums = [3, 1, 4, 1, 5, 9, 2, 6]

log(sum(nums))                   # 31
log(avg(nums))                   # 3.875
log(max(nums))                   # 9
log(min(nums))                   # 1
log(sort(nums))                  # [1, 1, 2, 3, 4, 5, 6, 9]
log(reverse(nums))               # reversed copy
log(includes(nums, 9))          # true
log(indexOf(nums, 4))           # 2
log(slice(nums, 2, 5))          # [4, 1, 5]
log(join(nums, ", "))            # "3, 1, 4, ..."

let user = {
  name:    "ram",
  age:     30,
  roles:   ["editor", "viewer"],
  address: { city: "Mumbai", zip: "400001" }
}

# Dot notation
log(user.name)
log(user.address.city)

# Bracket notation (dynamic key)
let field = "age"
log(user[field])

# Mutation
user.age = 31
user["email"] = "ram@example.com"

# Delete a property
delete user.address

# Enumerate keys
for key in user {
  log(`{key}: {user[key]}`)
}

let config = {host: "localhost", port: 3000, ssl: false}

log(keys(config))           # ["host", "port", "ssl"]
log(values(config))         # ["localhost", 3000, false]
log(len(config))            # 3
log(has(config, "port"))   # true
log(has(config, "auth"))   # false

# Merge two objects (non-destructive)
let override = {port: 443, ssl: true}
let final    = merge(config, override)
log(final)

let data = {name: "Ram", scores: [90, 85, 92]}

# Serialize to JSON string
let json = toJSON(data)
log(json)

# Parse back from string
let restored = fromJSON(json)
log(restored.name)

# Shorthand selector — compiles to document.getElementById("title")
let title = #page-title

# Always check if the element was found before using it
if title == null {
  log("Element not found!")
} else {
  log("Found: " + title.id)
}

# Select multiple elements by CSS class
let cards = queryAll(".card")
log("Found " + len(cards) + " cards")

let card = #my-card

# Content
card.innerText  = "Updated text"
card.innerHTML  = "<strong>Bold</strong> content"

# Style — standard CSS property names
card.style.backgroundColor = "#7c3aed"
card.style.fontSize         = "18px"
card.style.display          = "none"

# Style — LIPI shorthand aliases (same result)
card.style.bg      = "#7c3aed"   # backgroundColor
card.style.fg      = "white"      # color
card.style.size    = "18px"       # fontSize
card.style.radius  = "12px"       # borderRadius
card.style.shadow  = "0 4px 12px rgba(0,0,0,.4)"

let el = #status

# Text and HTML content helpers
setText(el, "Hello World")     # sets innerText safely
setHTML(el, "<em>italic</em>") # sets innerHTML

# Visibility
show(el)   # removes display:none
hide(el)   # sets display:none

# CSS class management
addClass(el, "active")
removeClass(el, "inactive")
toggleClass(el, "highlighted")

# Clear content
clear(el)

let btn   = #action-btn
let input = #text-input

# Click event
on btn.click {
  log("Button was clicked")
}

# Mouse enter/leave
on btn.mouseenter {
  btn.style.bg = "#5b21b6"
}
on btn.mouseleave {
  btn.style.bg = "#7c3aed"
}

# Input change
on input.input {
  log("Value: " + input.value)
}

let box   = #demo-box
let count = 0

on box.click {
  count++
  box.innerText = "Processing..."
  box.style.bg  = "#f59e0b"

  wait(500)

  box.innerText = "Done! (click " + count + ")"
  box.style.bg  = "#10b981"

  wait(800)
  box.style.bg  = "#7c3aed"
  box.innerText = "Click Me"
}

log("Starting process...")
wait(600)
log("Step 1 complete")
wait(600)
log("Step 2 complete")
wait(600)
log("All done! ✅")

# Cycle through a color palette with delays
let colors = ["#ef4444", "#f59e0b", "#10b981", "#3b82f6", "#8b5cf6"]
let box    = #demo-box

for c in colors {
  box.style.bg       = c
  box.innerText      = c
  wait(400)
}
box.innerText  = "Done"

let name = getInput("What is your name?")
log("Hello, " + name + "!")

let numStr = getInput("Enter a number:")
let num    = int(numStr)
log("Squared: " + (num ** 2))

log(abs(-42))            # 42
log(floor(3.9))          # 3
log(ceil(3.1))           # 4
log(round(3.567, 2))    # 3.57
log(sqrt(144))           # 12
log(pow(2, 10))          # 1024
log(max(10, 3, 7))      # 10
log(min(10, 3, 7))      # 3
log(random(1, 100))     # random integer in [1, 99]
log(random())            # float in [0, 1)

# Constants
log(PI)                  # 3.141592653589793
log(E)                   # 2.718281828459045

let msg = "  Hello, World!  "

log(trim(msg))              # "Hello, World!"
log(upper(msg))             # "  HELLO, WORLD!  "
log(lower(msg))             # "  hello, world!  "
log(replace(msg, "World", "LIPI"))  # "  Hello, LIPI!  "
log(len(msg))               # 18

let csv = "one,two,three"
let parts = split(csv, ",")
log(parts)                  # ["one", "two", "three"]
log(join(parts, " | "))    # "one | two | three"

log(startsWith(csv, "one")) # true
log(contains(csv, "two"))   # true
log(repeat("ab", 3))        # "ababab"

let data = [4, 8, 15, 16, 23, 42]

# filter: keep only even numbers (using JS arrow syntax)
let evens = filter(data, n => n % 2 == 0)
log(evens)  # [4, 8, 16, 42]

# map: double each value
let doubled = map(data, n => n * 2)
log(doubled)

# find: first value over 20
let big = find(data, n => n > 20)
log(big)    # 23

# int() — parse string to integer
let n = int("42")
log(n + 8)          # 50

# float() — parse string to float
let pi = float("3.14159")
log(round(pi, 2))   # 3.14

# str() — convert any value to string
let s = str(99)
log(type(s))         # "string"

# bool() — convert to boolean
log(bool(0))        # false
log(bool(""))       # false
log(bool("hello")) # true

# type() — returns type as string
log(type([1,2,3]))  # "array"
log(type(null))     # "null"
log(type(true))     # "boolean"

let cache = {}

func fib(n) {
  if n <= 1 { return n }
  if has(cache, str(n)) { return cache[str(n)] }
  let result = fib(n - 1) + fib(n - 2)
  cache[str(n)] = result
  return result
}

for i in range(1, 16) {
  log(`fib({i}) = {fib(i)}`)
}

let states = {
  idle:    {on_start: "running"},
  running: {on_pause: "paused",  on_stop: "idle", on_error: "error"},
  paused:  {on_resume: "running", on_stop: "idle"},
  error:   {on_reset: "idle"}
}

let current = "idle"

func dispatch(event) {
  let map = states[current]
  let key = "on_" + event
  if has(map, key) {
    let next = map[key]
    log(`[{current}] --{event}--> [{next}]`)
    current = next
  } else {
    log(`Invalid: '{event}' in state '{current}'`)
  }
}

dispatch("start")
dispatch("pause")
dispatch("stop")   # Invalid from paused
dispatch("resume")
dispatch("error")
dispatch("reset")
log("Final state: " + current)

func bubbleSort(arr) {
  let n      = len(arr)
  let sorted = copy(arr)
  let passes = 0

  for i in range(n) {
    let swapped = false
    for j in range(n - i - 1) {
      if sorted[j] > sorted[j + 1] {
        let tmp   = sorted[j]
        sorted[j] = sorted[j + 1]
        sorted[j + 1] = tmp
        swapped = true
      }
    }
    passes++
    if not swapped { break }
  }
  log(`Completed in {passes} passes`)
  return sorted
}

let data   = [64, 34, 25, 12, 22, 11, 90]
log("Input:  " + join(data, ", "))
let result = bubbleSort(data)
log("Output: " + join(result, ", "))

let heap   = {capacity: 32, used: 0, blocks: {}}
let nextId = 0

func alloc(size) {
  if heap.used + size > heap.capacity {
    log("ERR: Out of heap space!")
    return -1
  }
  let id = nextId
  nextId++
  heap.blocks[str(id)] = {size: size, id: id}
  heap.used += size
  log(`alloc(${size}) → block #${id}  [${heap.used}/${heap.capacity} used]`)
  return id
}

func free(id) {
  let key = str(id)
  if not has(heap.blocks, key) {
    log("ERR: Block #" + id + " not found")
    return
  }
  heap.used -= heap.blocks[key].size
  delete heap.blocks[key]
  log(`free(#${id})  [${heap.used}/${heap.capacity} used]`)
}

func status() {
  let count = len(heap.blocks)
  log(`--- Heap: ${heap.used}/${heap.capacity} bytes, ${count} blocks ---`)
}

let a = alloc(8)
let b = alloc(12)
let c = alloc(6)
status()
free(a)
free(b)
let d = alloc(18)
status()

let graph = {
  A: ["B", "C"],
  B: ["D", "E"],
  C: ["F"],
  D: [],
  E: ["F"],
  F: []
}

func bfs(start) {
  let visited = {}
  let queue   = [start]
  let order   = []

  visited[start] = true

  while len(queue) > 0 {
    let node = queue[0]
    queue       = slice(queue, 1)
    append(order, node)
    log("Visiting: " + node)

    for neighbor in graph[node] {
      if not has(visited, neighbor) {
        visited[neighbor] = true
        append(queue, neighbor)
      }
    }
  }
  return order
}

let path = bfs("A")
log("BFS order: " + join(path, " → "))

func simulate(label, steps) {
  log(`[{label}] Starting...`)
  let i = 0
  while i < steps {
    i++
    let pct = round((i / steps) * 100)
    let bar = repeat("█", i) + repeat("░", steps - i)
    log(`[{label}] {bar} {pct}%`)
    wait(150)
  }
  log(`[{label}] Complete ✓`)
}

simulate("Compile", 6)
simulate("Deploy", 4)