Add units, regex, numbers

Author: dy

README.md

@@ -77,6 +77,9 @@ fn()  // 1
 + `{ a; b }` — block scope
 + `let x`, `const x = 1`
 + `break`, `continue`, `return x`
++ `` `a ${x} b` `` — template literals
++ `/pattern/flags` — regex literals
++ `5px`, `10rem` — unit suffixes
 
 ```js
 import subscript from 'subscript/justin'
@@ -124,21 +127,41 @@ const fn = compile(['+', ['*', 'min', [,60]], [,'sec']])
 fn({min: 5}) // min*60 + "sec" == "300sec"
 
 // node kinds
-['+', a];         // unary operator `+a`
-['+', a, b];      // binary operator `a + b`
-['+', a, b, c];   // n-ary operator `a + b + c`
-['()', a];        // group operator `(a)`
-['()', a, b];     // access operator `a(b)`
-[, 'a'];          // literal value `'a'`
-'a';              // variable (from scope)
-null|empty;       // placeholder
-
-// eg.
-['()', 'a']       // (a)
-['()', 'a', null] // a()
-['()', 'a', 'b']  // a(b)
-['++', 'a']       // ++a
-['++','a', null]  // a++
+'a'                // identifier — variable from scope
+[, value]          // literal — [0] empty distinguishes from operator
+[op, a]            // unary — prefix operator
+[op, a, null]      // unary — postfix operator (null marks postfix)
+[op, a, b]         // binary
+[op, a, b, c]      // n-ary / ternary
+
+// operators
+['+', a, b]        // a + b
+['.', a, 'b']      // a.b — property access
+['[]', a, b]       // a[b] — bracket access
+['()', a]          // (a) — grouping
+['()', a, b]       // a(b) — function call
+['()', a, null]    // a() — call with no args
+
+// literals & structures
+[, 1]              // 1
+[, 'hello']        // "hello"
+['[]', [',', ...]] // [a, b] — array literal
+['{}', [':', ...]] // {a: b} — object literal
+
+// justin extensions
+['?', a, b, c]     // a ? b : c — ternary
+['=>', params, x]  // (a) => x — arrow function
+['...', a]         // ...a — spread
+
+// control flow (extra)
+['if', cond, then, else]
+['while', cond, body]
+['for', init, cond, step, body]
+
+// postfix example
+['++', 'a']        // ++a
+['++', 'a', null]  // a++
+['px', [,5]]       // 5px (unit suffix)
 ```
 
 ### Stringify

feature/number.js

@@ -1,14 +1,21 @@
-import { lookup, next, err, skip } from "../src/parse.js"
-import { cur, idx } from "../src/parse.js"
+import { lookup, next, err, skip, cur, idx } from "../src/parse.js"
 import { PERIOD, _0, _E, _e, _9 } from "../src/const.js"
 
 // Char codes for prefixes
 const _b = 98, _B = 66, _o = 111, _O = 79, _x = 120, _X = 88
 const _a = 97, _f = 102, _A = 65, _F = 70
+const PLUS = 43, MINUS = 45
+
+// Check if char at offset is digit or sign (valid after 'e')
+const isExpFollow = off => {
+  const c = cur.charCodeAt(idx + off)
+  return (c >= _0 && c <= _9) || c === PLUS || c === MINUS
+}
 
 // parse decimal number (with optional exponent)
+// Only consume 'e' if followed by digit or +/-
 const num = (a, _) => [, (
-  a = +next(c => (c === PERIOD) || (c >= _0 && c <= _9) || (c === _E || c === _e ? 2 : 0))
+  a = +next(c => (c === PERIOD) || (c >= _0 && c <= _9) || ((c === _E || c === _e) && isExpFollow(1) ? 2 : 0))
 ) != a ? err() : a]
 
 // .1

feature/regex.js

@@ -0,0 +1,55 @@
+/**
+ * Regex literals: /pattern/flags
+ * 
+ * AST:
+ *   /abc/gi  → [, /abc/gi]
+ * 
+ * Note: Disambiguates from division by context:
+ *   - `/` after value = division
+ *   - `/` at start or after operator = regex
+ */
+import * as P from '../src/parse.js'
+
+const { lookup, skip, err, next } = P
+const SLASH = 47, BSLASH = 92
+
+const regexFlags = c => c === 103 || c === 105 || c === 109 || c === 115 || c === 117 || c === 121 // g i m s u y
+
+// Store original division handler
+const divHandler = lookup[SLASH]
+
+// Override / to detect regex vs division
+lookup[SLASH] = (a, prec) => {
+  // If there's a left operand, it's division
+  if (a) return divHandler?.(a, prec)
+  
+  // No left operand = regex literal
+  skip() // consume opening /
+  
+  let pattern = '', c
+  while ((c = P.cur.charCodeAt(P.idx)) && c !== SLASH) {
+    if (c === BSLASH) {
+      // Escape sequence - include both chars
+      pattern += P.cur[P.idx]
+      skip()
+      if (!P.cur[P.idx]) err('Unterminated regex')
+      pattern += P.cur[P.idx]
+      skip()
+    } else {
+      pattern += P.cur[P.idx]
+      skip()
+    }
+  }
+  
+  if (!P.cur[P.idx]) err('Unterminated regex')
+  skip() // consume closing /
+  
+  // Parse flags
+  const flags = next(regexFlags)
+  
+  try {
+    return [, new RegExp(pattern, flags)]
+  } catch (e) {
+    err('Invalid regex: ' + e.message)
+  }
+}

feature/template.js

@@ -0,0 +1,62 @@
+/**
+ * Template string interpolation: `a ${expr} b`
+ * 
+ * AST:
+ *   `a ${x} b`  → ['`', [,'a '], 'x', [,' b']]
+ */
+import * as P from '../src/parse.js'
+import { operator, compile } from '../src/compile.js'
+
+const { lookup, skip, err, next, expr } = P
+const BACKTICK = 96, DOLLAR = 36, OBRACE = 123, CBRACE = 125, BSLASH = 92
+
+const escape = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' }
+
+// Parse template literal
+lookup[BACKTICK] = a => {
+  a && err('Unexpected template')
+  skip() // consume opening `
+  
+  const parts = []
+  let str = ''
+  
+  while (P.cur.charCodeAt(P.idx) !== BACKTICK) {
+    const c = P.cur.charCodeAt(P.idx)
+    if (!c) err('Unterminated template')
+    
+    // Escape sequence
+    if (c === BSLASH) {
+      skip()
+      const ec = P.cur[P.idx]
+      str += escape[ec] || ec
+      skip()
+    }
+    // Interpolation ${...}
+    else if (c === DOLLAR && P.cur.charCodeAt(P.idx + 1) === OBRACE) {
+      if (str) parts.push([, str])
+      str = ''
+      skip(); skip() // consume ${
+      parts.push(expr(0, CBRACE))
+    }
+    // Regular character
+    else {
+      str += P.cur[P.idx]
+      skip()
+    }
+  }
+  
+  skip() // consume closing `
+  if (str) parts.push([, str])
+  
+  // Optimize: if no interpolations, return plain string
+  if (parts.length === 0) return [, '']
+  if (parts.length === 1 && parts[0][0] === undefined) return parts[0]
+  
+  return ['`', ...parts]
+}
+
+// Compile template: concatenate parts
+operator('`', (...parts) => {
+  parts = parts.map(p => compile(p))
+  return ctx => parts.map(p => p(ctx)).join('')
+})

feature/unit.js

@@ -0,0 +1,58 @@
+/**
+ * Unit suffixes: 5px, 10rem, 2s, 500ms
+ * 
+ * AST:
+ *   5px   → ['px', [,5]]
+ *   2.5s  → ['s', [,2.5]]
+ * 
+ * Units are postfix operators — idiomatic to subscript's design.
+ * Inspired by piezo: https://github.com/dy/piezo
+ * 
+ * Usage:
+ *   import { unit } from 'subscript/feature/unit.js'
+ *   unit('px', 'em', 'rem', 's', 'ms')
+ */
+import * as P from '../src/parse.js'
+import { operator, compile } from '../src/compile.js'
+
+const { lookup, next, parse } = P
+
+// Unit registry
+const units = new Set
+
+// Register units with default evaluator
+export const unit = (...names) => names.forEach(name => {
+  units.add(name)
+  // Default: return { value, unit } object
+  operator(name, val => (val = compile(val), ctx => ({ value: val(ctx), unit: name })))
+})
+
+// Wrap number handler to check for unit suffix
+const wrapHandler = (charCode) => {
+  const original = lookup[charCode]
+  if (!original) return
+  
+  lookup[charCode] = (a, prec) => {
+    const result = original(a, prec)
+    if (!result) return result
+    
+    // Only numeric literals (not identifiers)
+    if (!Array.isArray(result) || result[0] !== undefined) return result
+    
+    // Try to consume unit suffix
+    const startIdx = P.idx
+    const u = next(c => parse.id(c) && !(c >= 48 && c <= 57))
+    
+    if (u && units.has(u)) return [u, result]
+    
+    // Not a unit - backtrack
+    if (u) P.idx = startIdx
+    
+    return result
+  }
+}
+
+// Wrap all number entry points (0-9 and .)
+const PERIOD = 46, _0 = 48, _9 = 57
+wrapHandler(PERIOD)
+for (let i = _0; i <= _9; i++) wrapHandler(i)

test/regex.js

@@ -0,0 +1,43 @@
+import test, { is, throws } from 'tst'
+import { parse, compile } from '../subscript.js'
+import '../feature/regex.js'
+
+const run = (code, ctx = {}) => compile(parse(code))(ctx)
+
+test('regex: basic', t => {
+  const ast = parse('/abc/')
+  is(ast[0], undefined)
+  is(ast[1] instanceof RegExp, true)
+  is(ast[1].source, 'abc')
+})
+
+test('regex: flags', t => {
+  is(parse('/abc/gi')[1].flags, 'gi')
+  is(parse('/test/m')[1].multiline, true)
+  is(parse('/test/i')[1].ignoreCase, true)
+})
+
+test('regex: escapes', t => {
+  is(parse('/a\\/b/')[1].source, 'a\\/b')
+  is(parse('/a\\nb/')[1].source, 'a\\nb')
+})
+
+test('regex: eval', t => {
+  is(run('/abc/.test("abc")'), true)
+  is(run('/abc/.test("def")'), false)
+  is(run('"hello world".match(/\\w+/g)'), ['hello', 'world'])
+})
+
+test('regex: division disambiguation', t => {
+  // Division when left operand exists
+  is(run('4 / 2'), 2)
+  is(run('a / b', { a: 10, b: 2 }), 5)
+  
+  // Regex when no left operand
+  is(run('/a/.test("a")'), true)
+})
+
+test('regex: in expressions', t => {
+  is(run('x.match(/\\d+/)', { x: 'abc123def' })[0], '123')
+  is(run('x.replace(/a/g, "b")', { x: 'aaa' }), 'bbb')
+})

test/template.js

@@ -0,0 +1,37 @@
+import test, { is, throws } from 'tst'
+import { parse, compile } from '../subscript.js'
+import '../feature/ternary.js'
+import '../feature/template.js'
+
+const run = (code, ctx = {}) => compile(parse(code))(ctx)
+
+test('template: basic', t => {
+  is(parse('`hello`'), [, 'hello'])
+  is(run('`hello`'), 'hello')
+})
+
+test('template: interpolation', t => {
+  is(parse('`a ${x} b`'), ['`', [, 'a '], 'x', [, ' b']])
+  is(run('`hello ${name}!`', { name: 'world' }), 'hello world!')
+  is(run('`${a} + ${b} = ${a + b}`', { a: 2, b: 3 }), '2 + 3 = 5')
+})
+
+test('template: expressions', t => {
+  is(run('`result: ${x * 2}`', { x: 5 }), 'result: 10')
+  is(run('`${a > b ? "yes" : "no"}`', { a: 5, b: 3 }), 'yes')
+})
+
+test('template: escapes', t => {
+  is(run('`a\\nb`'), 'a\nb')
+  is(run('`a\\tb`'), 'a\tb')
+  is(run('`\\${x}`'), '${x}')
+})
+
+test('template: empty', t => {
+  is(parse('``'), [, ''])
+  is(run('``'), '')
+})
+
+test('template: nested', t => {
+  is(run('`outer ${`inner ${x}`}`', { x: 1 }), 'outer inner 1')
+})

test/unit.js

@@ -0,0 +1,42 @@
+import test, { is, throws } from 'tst'
+import { parse, compile } from '../subscript.js'
+import { unit } from '../feature/unit.js'
+
+// Register units for tests
+unit('px', 'em', 'rem', 'vh', 'vw', 'pt', 's', 'ms', 'deg', 'rad')
+
+const run = (code, ctx = {}) => compile(parse(code))(ctx)
+
+test('unit: basic', t => {
+  is(parse('5px'), ['px', [, 5]])
+  is(parse('10rem'), ['rem', [, 10]])
+  is(parse('2.5s'), ['s', [, 2.5]])
+})
+
+test('unit: eval', t => {
+  is(run('5px'), { value: 5, unit: 'px' })
+  is(run('100vh'), { value: 100, unit: 'vh' })
+  is(run('500ms'), { value: 500, unit: 'ms' })
+})
+
+test('unit: CSS lengths', t => {
+  is(run('10em').unit, 'em')
+  is(run('50vw').unit, 'vw')
+  is(run('12pt').unit, 'pt')
+})
+
+test('unit: time', t => {
+  is(run('2s'), { value: 2, unit: 's' })
+  is(run('300ms'), { value: 300, unit: 'ms' })
+})
+
+test('unit: angles', t => {
+  is(run('90deg'), { value: 90, unit: 'deg' })
+  is(run('3.14rad'), { value: 3.14, unit: 'rad' })
+})
+
+test('unit: in expressions', t => {
+  // Units should not affect normal operations when not applied
+  is(run('5 + 3'), 8)
+  is(run('px', { px: 10 }), 10) // px as identifier
+})