subscript 9.1.0 → 10.0.0

package/feature/op/comparison.js

@@ -0,0 +1,19 @@
+/**
+ * Comparison operators
+ *
+ * < > <= >=
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const COMP = 90;
+
+binary('<', COMP);
+binary('>', COMP);
+binary('<=', COMP);
+binary('>=', COMP);
+
+// Compile
+operator('>', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) > b(ctx)));
+operator('<', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) < b(ctx)));
+operator('>=', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) >= b(ctx)));
+operator('<=', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) <= b(ctx)));

package/feature/op/defer.js

@@ -0,0 +1,15 @@
+/**
+ * Defer operator
+ *
+ * defer expr: registers cleanup to run at scope exit
+ *
+ * Common in: Go, Swift, Zig
+ */
+import { unary, operator, compile } from '../../parse.js';
+
+const PREFIX = 140;
+
+unary('defer', PREFIX);
+
+// Compile
+operator('defer', a => (a = compile(a), ctx => { ctx.__deferred__ = ctx.__deferred__ || []; ctx.__deferred__.push(a); }));

package/feature/op/equality.js

@@ -0,0 +1,16 @@
+/**
+ * Equality operators (base)
+ *
+ * == !=
+ * For === !== see equality-strict.js
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const EQ = 80;
+
+binary('==', EQ);
+binary('!=', EQ);
+
+// Compile
+operator('==', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) == b(ctx)));
+operator('!=', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) != b(ctx)));

package/feature/op/identity.js

@@ -0,0 +1,15 @@
+/**
+ * Identity operators
+ *
+ * === !==
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const EQ = 80;
+
+binary('===', EQ);
+binary('!==', EQ);
+
+// Compile
+operator('===', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) === b(ctx)));
+operator('!==', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) !== b(ctx)));

package/feature/op/increment.js

@@ -0,0 +1,23 @@
+/**
+ * Increment/decrement operators
+ *
+ * ++ -- (prefix and postfix)
+ */
+import { token, expr, operator, compile } from '../../parse.js';
+
+const POSTFIX = 150;
+
+token('++', POSTFIX, a => a ? ['++', a, null] : ['++', expr(POSTFIX - 1)]);
+token('--', POSTFIX, a => a ? ['--', a, null] : ['--', expr(POSTFIX - 1)]);
+
+// Compile (b=null means postfix, b=undefined means prefix)
+// Simple prop helper for increment - handles x, a.b, a[b], (x)
+const inc = (a, fn, obj, key) =>
+  typeof a === 'string' ? ctx => fn(ctx, a) :
+  a[0] === '.' ? (obj = compile(a[1]), key = a[2], ctx => fn(obj(ctx), key)) :
+  a[0] === '[]' && a.length === 3 ? (obj = compile(a[1]), key = compile(a[2]), ctx => fn(obj(ctx), key(ctx))) :
+  a[0] === '()' && a.length === 2 ? inc(a[1], fn) :  // unwrap parens: (x)++
+  (() => { throw Error('Invalid increment target') })();
+
+operator('++', (a, b) => inc(a, b === null ? (o, k) => o[k]++ : (o, k) => ++o[k]));
+operator('--', (a, b) => inc(a, b === null ? (o, k) => o[k]-- : (o, k) => --o[k]));

package/feature/op/logical.js

@@ -0,0 +1,21 @@
+/**
+ * Logical operators (base)
+ *
+ * ! && ||
+ * For ?? see nullish.js
+ */
+import { binary, unary, operator, compile } from '../../parse.js';
+
+const LOR = 30, LAND = 40, PREFIX = 140;
+
+// ! must be registered before != and !==
+binary('!', PREFIX);
+unary('!', PREFIX);
+
+binary('||', LOR);
+binary('&&', LAND);
+
+// Compile
+operator('!', a => (a = compile(a), ctx => !a(ctx)));
+operator('||', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) || b(ctx)));
+operator('&&', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) && b(ctx)));

package/feature/op/membership.js

@@ -0,0 +1,17 @@
+/**
+ * Membership operator
+ *
+ * in: key in object
+ * of: for-of iteration (parsed as binary in for head)
+ *
+ * Note: instanceof is in class.js (jessie feature)
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const COMP = 90;
+
+binary('in', COMP);
+binary('of', COMP);
+
+// Compile
+operator('in', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) in b(ctx)));

package/feature/op/nullish.js

@@ -0,0 +1,13 @@
+/**
+ * Nullish coalescing operator (JS-specific)
+ *
+ * ??
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const LOR = 30;
+
+binary('??', LOR);
+
+// Compile
+operator('??', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) ?? b(ctx)));

package/feature/op/optional.js

@@ -0,0 +1,61 @@
+/**
+ * Optional chaining operators
+ *
+ * a?.b → optional member access
+ * a?.[x] → optional computed access
+ * a?.() → optional call
+ *
+ * Common in: JS, TS, Swift, Kotlin, C#
+ */
+import { token, expr, skip, space, operator, compile } from '../../parse.js';
+import { unsafe } from '../access.js';
+
+const ACCESS = 170;
+
+token('?.', ACCESS, (a, b) => {
+  if (!a) return;
+  const cc = space();
+  // Optional call: a?.()
+  if (cc === 40) { skip(); return ['?.()', a, expr(0, 41) || null]; }
+  // Optional computed: a?.[x]
+  if (cc === 91) { skip(); return ['?.[]', a, expr(0, 93)]; }
+  // Optional member: a?.b
+  b = expr(ACCESS);
+  return b ? ['?.', a, b] : void 0;
+});
+
+// Compile
+operator('?.', (a, b) => (a = compile(a), unsafe(b) ? () => undefined : ctx => a(ctx)?.[b]));
+operator('?.[]', (a, b) => (a = compile(a), b = compile(b), ctx => { const k = b(ctx); return unsafe(k) ? undefined : a(ctx)?.[k]; }));
+operator('?.()', (a, b) => {
+  const args = !b ? () => [] :
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) :
+    (b = compile(b), ctx => [b(ctx)]);
+
+  // Handle nested optional chain: a?.method?.() or a?.["method"]?.()
+  if (a[0] === '?.') {
+    const container = compile(a[1]);
+    const prop = a[2];
+    return unsafe(prop) ? () => undefined :
+      ctx => { const c = container(ctx); return c?.[prop]?.(...args(ctx)); };
+  }
+  if (a[0] === '?.[]') {
+    const container = compile(a[1]);
+    const prop = compile(a[2]);
+    return ctx => { const c = container(ctx); const p = prop(ctx); return unsafe(p) ? undefined : c?.[p]?.(...args(ctx)); };
+  }
+  // Handle a?.() where a is a.method or a[method] - need to bind this
+  if (a[0] === '.') {
+    const obj = compile(a[1]);
+    const prop = a[2];
+    return unsafe(prop) ? () => undefined :
+      ctx => { const o = obj(ctx); return o?.[prop]?.(...args(ctx)); };
+  }
+  if (a[0] === '[]' && a.length === 3) {
+    const obj = compile(a[1]);
+    const prop = compile(a[2]);
+    return ctx => { const o = obj(ctx); const p = prop(ctx); return unsafe(p) ? undefined : o?.[p]?.(...args(ctx)); };
+  }
+  const fn = compile(a);
+  return ctx => fn(ctx)?.(...args(ctx));
+});

package/feature/op/pow.js

@@ -0,0 +1,19 @@
+/**
+ * Exponentiation operator
+ *
+ * ** **=
+ *
+ * ES2016+, not in classic JS/C
+ */
+import { binary, operator, compile } from '../../parse.js';
+import { isLval, prop } from '../access.js';
+
+const EXP = 130, ASSIGN = 20;
+
+binary('**', EXP, true);
+binary('**=', ASSIGN, true);
+
+// Compile
+operator('**', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) ** b(ctx)));
+const err = msg => { throw Error(msg) };
+operator('**=', (a, b) => (isLval(a) || err('Invalid assignment target'), b = compile(b), prop(a, (obj, path, ctx) => obj[path] **= b(ctx))));

package/feature/op/range.js

@@ -0,0 +1,26 @@
+/**
+ * Range operators
+ *
+ * .. (inclusive range): 1..5 → [1,2,3,4,5]
+ * ..< (exclusive range): 1..<5 → [1,2,3,4]
+ *
+ * Common in: Swift, Kotlin, Rust, Ruby
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const COMP = 90;
+
+binary('..', COMP);
+binary('..<', COMP);
+
+// Compile
+operator('..', (a, b) => (a = compile(a), b = compile(b), ctx => {
+  const start = a(ctx), end = b(ctx), arr = [];
+  for (let i = start; i <= end; i++) arr.push(i);
+  return arr;
+}));
+operator('..<', (a, b) => (a = compile(a), b = compile(b), ctx => {
+  const start = a(ctx), end = b(ctx), arr = [];
+  for (let i = start; i < end; i++) arr.push(i);
+  return arr;
+}));

package/feature/op/spread.js

@@ -0,0 +1,15 @@
+/**
+ * Spread/rest operator
+ *
+ * ...x → spread in arrays/calls, rest in params
+ *
+ * Common in: JS, TS, Python (*args), Ruby (*splat)
+ */
+import { unary, operator, compile } from '../../parse.js';
+
+const PREFIX = 140;
+
+unary('...', PREFIX);
+
+// Compile (for arrays/objects spread)
+operator('...', a => (a = compile(a), ctx => Object.entries(a(ctx))));

package/feature/op/ternary.js

@@ -0,0 +1,15 @@
+/**
+ * Ternary conditional operator
+ *
+ * a ? b : c → conditional expression
+ *
+ * Common in: C, JS, Java, PHP, etc.
+ */
+import { token, expr, next, operator, compile } from '../../parse.js';
+
+const ASSIGN = 20;
+
+token('?', ASSIGN, (a, b, c) => a && (b = expr(ASSIGN - 1)) && next(c => c === 58) && (c = expr(ASSIGN - 1), ['?', a, b, c]));
+
+// Compile
+operator('?', (a, b, c) => (a = compile(a), b = compile(b), c = compile(c), ctx => a(ctx) ? b(ctx) : c(ctx)));

package/feature/op/type.js

@@ -0,0 +1,18 @@
+/**
+ * Type operators
+ *
+ * as: type cast/assertion (identity in JS)
+ * is: type check (instanceof in JS)
+ *
+ * Common in: TypeScript, Kotlin, Swift, C#
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const COMP = 90;
+
+binary('as', COMP);
+binary('is', COMP);
+
+// Compile (identity in JS)
+operator('as', (a, b) => (a = compile(a), ctx => a(ctx)));
+operator('is', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) instanceof b(ctx)));

package/feature/op/unary.js

@@ -0,0 +1,41 @@
+/**
+ * Unary keyword operators
+ *
+ * typeof x → type string
+ * void x → undefined
+ * delete x → remove property
+ * new X() → construct instance
+ *
+ * JS-specific keywords
+ */
+import { unary, operator, compile } from '../../parse.js';
+
+const PREFIX = 140;
+
+unary('typeof', PREFIX);
+unary('void', PREFIX);
+unary('delete', PREFIX);
+unary('new', PREFIX);
+
+// Compile
+operator('typeof', a => (a = compile(a), ctx => typeof a(ctx)));
+operator('void', a => (a = compile(a), ctx => (a(ctx), undefined)));
+operator('delete', a => {
+  if (a[0] === '.') {
+    const obj = compile(a[1]), key = a[2];
+    return ctx => delete obj(ctx)[key];
+  }
+  if (a[0] === '[]') {
+    const obj = compile(a[1]), key = compile(a[2]);
+    return ctx => delete obj(ctx)[key(ctx)];
+  }
+  return () => true;
+});
+operator('new', (call) => {
+  const target = compile(call?.[0] === '()' ? call[1] : call);
+  const args = call?.[0] === '()' ? call[2] : null;
+  const argList = !args ? () => [] :
+    args[0] === ',' ? (a => ctx => a.map(f => f(ctx)))(args.slice(1).map(compile)) :
+    (a => ctx => [a(ctx)])(compile(args));
+  return ctx => new (target(ctx))(...argList(ctx));
+});

package/feature/prop.js

@@ -0,0 +1,34 @@
+/**
+ * Minimal property access: a.b, a[b], f()
+ * For array literals, private fields, see member.js
+ */
+import { access, binary, group, operator, compile } from '../parse.js';
+
+const ACCESS = 170;
+
+// a[b] - computed member access only (no array literal support)
+access('[]', ACCESS);
+
+// a.b - dot member access
+binary('.', ACCESS);
+
+// (a) - grouping only (no sequences)
+group('()', ACCESS);
+
+// a(b,c,d), a() - function calls
+access('()', ACCESS);
+
+// Compile
+const err = msg => { throw Error(msg) };
+operator('[]', (a, b) => (b == null && err('Missing index'), a = compile(a), b = compile(b), ctx => a(ctx)[b(ctx)]));
+operator('.', (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, ctx => a(ctx)[b]));
+operator('()', (a, b) => {
+  // Group: (expr) - no second argument means grouping, not call
+  if (b === undefined) return a == null ? err('Empty ()') : compile(a);
+  // Function call: a(b,c)
+  const args = !b ? () => [] :
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) :
+    (b = compile(b), ctx => [b(ctx)]);
+  a = compile(a);
+  return ctx => a(ctx)(...args(ctx));
+});

package/feature/regex.js

@@ -0,0 +1,31 @@
+/**
+ * Regex literals: /pattern/flags
+ *
+ * AST:
+ *   /abc/gi  → [, /abc/gi]
+ *
+ * Note: Disambiguates from division by context:
+ *   - `/` after value = division (falls through to prev)
+ *   - `/` at start or after operator = regex
+ */
+import { token, skip, err, next, idx, cur } from '../parse.js';
+
+const PREFIX = 140, SLASH = 47, BSLASH = 92;
+
+const regexChar = c => c === BSLASH ? 2 : c && c !== SLASH;  // \x = 2 chars, else 1 until /
+const regexFlag = c => c === 103 || c === 105 || c === 109 || c === 115 || c === 117 || c === 121; // g i m s u y
+
+token('/', PREFIX, a => {
+  if (a) return; // has left operand = division, fall through
+
+  // Invalid regex start (quantifiers) or /= - fall through
+  const first = cur.charCodeAt(idx);
+  if (first === SLASH || first === 42 || first === 43 || first === 63 || first === 61) return;
+
+  const pattern = next(regexChar);
+  cur.charCodeAt(idx) === SLASH || err('Unterminated regex');
+  skip(); // consume closing /
+
+  try { return [, new RegExp(pattern, next(regexFlag))]; }
+  catch (e) { err('Invalid regex: ' + e.message); }
+});

package/feature/seq.js

@@ -0,0 +1,21 @@
+/**
+ * Sequence operators (C-family)
+ *
+ * , ; — returns last evaluated value
+ */
+import { nary, operator, compile } from '../parse.js';
+
+const STATEMENT = 5, SEQ = 10;
+
+// Sequences
+nary(',', SEQ);
+nary(';', STATEMENT, true);  // right-assoc to allow same-prec statements
+
+// Compile - returns last evaluated value
+const seq = (...args) => (args = args.map(compile), ctx => {
+  let r;
+  for (const arg of args) r = arg(ctx);
+  return r;
+});
+operator(',', seq);
+operator(';', seq);

package/feature/string.js

@@ -1,19 +1,27 @@
-import { skip, err, cur, idx, lookup } from '../src/parse.js'
-import { DQUOTE, QUOTE, BSLASH } from '../src/const.js'
+/**
+ * Strings with escape sequences
+ *
+ * Configurable via parse.string: { '"': true } or { '"': true, "'": true }
+ */
+import { parse, lookup, next, err, skip, idx, cur } from '../parse.js';
 
-const escape = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' },
-  string = q => (qc, c, str = '') => {
-    qc && err('Unexpected string') // must not follow another token
-    skip() // first quote
-    while (c = cur.charCodeAt(idx), c - q) {
-      if (c === BSLASH) skip(), c = skip(), str += escape[c] || c
-      else str += skip()
-    }
-    skip() || err('Bad string')
-    return [, str]
-  }
+const BSLASH = 92, DQUOTE = 34, SQUOTE = 39;
+const esc = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' };
 
+// Parse string with given quote char code
+const parseString = q => (a, _, s = '') => {
+  if (a || !parse.string?.[String.fromCharCode(q)]) return;
+  skip();
+  next(c => c - q && (c === BSLASH ? (s += esc[cur[idx + 1]] || cur[idx + 1], 2) : (s += cur[idx], 1)));
+  cur[idx] === String.fromCharCode(q) ? skip() : err('Bad string');
+  return [, s];
+};
 
-// "' with /
-lookup[DQUOTE] = string(DQUOTE)
-lookup[QUOTE] = string(QUOTE)
+// Register both quote chars (enabled via parse.string config)
+lookup[DQUOTE] = parseString(DQUOTE);
+lookup[SQUOTE] = parseString(SQUOTE);
+
+// Default: double quotes only
+parse.string = { '"': true };
+
+export { esc };

package/feature/switch.js

@@ -0,0 +1,48 @@
+// Switch/case/default
+// AST: ['switch', val, [';', ['case', test], stmts..., ['default'], stmts...]]
+import { expr, skip, space, parens, operator, compile } from '../parse.js';
+import { keyword, block } from './block.js';
+import { BREAK } from './loop.js';
+
+const STATEMENT = 5, ASSIGN = 20, COLON = 58;
+
+keyword('switch', STATEMENT + 1, () => (space(), ['switch', parens(), block()]));
+keyword('case', STATEMENT + 1, () => (space(), (c => (space() === COLON && skip(), ['case', c]))(expr(ASSIGN))));
+keyword('default', STATEMENT + 1, () => (space() === COLON && skip(), ['default']));
+
+// Compile
+operator('switch', (val, cases) => {
+  val = compile(val);
+  // Parse cases body: [';', ['case', test], stmts..., ['default'], stmts...]
+  if (!cases) return ctx => val(ctx);
+  const parsed = [];
+  const items = cases[0] === ';' ? cases.slice(1) : [cases];
+  let current = null;
+  for (const item of items) {
+    if (Array.isArray(item) && (item[0] === 'case' || item[0] === 'default')) {
+      if (current) parsed.push(current);
+      current = [item[0] === 'case' ? compile(item[1]) : null, []];
+    } else if (current) {
+      current[1].push(compile(item));
+    }
+  }
+  if (current) parsed.push(current);
+
+  return ctx => {
+    const v = val(ctx);
+    let matched = false, result;
+    for (const [test, stmts] of parsed) {
+      if (matched || test === null || test(ctx) === v) {
+        matched = true;
+        for (const stmt of stmts) {
+          try { result = stmt(ctx); }
+          catch (e) {
+            if (e?.type === BREAK) return e.value !== undefined ? e.value : result;
+            throw e;
+          }
+        }
+      }
+    }
+    return result;
+  };
+});

package/feature/template.js

@@ -0,0 +1,39 @@
+/**
+ * Template literals: `a ${x} b` → ['`', [,'a '], 'x', [,' b']]
+ * Tagged templates:  tag`...`  → ['``', 'tag', ...]
+ */
+import { parse, skip, err, expr, lookup, cur, idx, operator, compile } from '../parse.js';
+
+const ACCESS = 170, BACKTICK = 96, DOLLAR = 36, OBRACE = 123, BSLASH = 92;
+const esc = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' };
+
+// Parse template body after opening `
+const parseBody = () => {
+  const parts = [];
+  for (let s = '', c; (c = cur.charCodeAt(idx)) !== BACKTICK; )
+    !c ? err('Unterminated template') :
+    c === BSLASH ? (skip(), s += esc[cur[idx]] || cur[idx], skip()) :
+    c === DOLLAR && cur.charCodeAt(idx + 1) === OBRACE ? (s && parts.push([, s]), s = '', skip(2), parts.push(expr(0, 125))) :
+    (s += cur[idx], skip(), c = cur.charCodeAt(idx), c === BACKTICK && s && parts.push([, s]));
+  return skip(), parts;
+};
+
+const prev = lookup[BACKTICK];
+// Tagged templates: decline when ASI with newline (return undefined to let ASI handle)
+lookup[BACKTICK] = (a, prec) =>
+  a && prec < ACCESS ? (parse.asi && parse.newline ? void 0 : (skip(), ['``', a, ...parseBody()])) : // tagged
+  !a ? (skip(), (p => p.length < 2 && p[0]?.[0] === undefined ? p[0] || [,''] : ['`', ...p])(parseBody())) : // plain
+  prev?.(a, prec);
+
+// Compile
+operator('`', (...parts) => (parts = parts.map(compile), ctx => parts.map(p => p(ctx)).join('')));
+operator('``', (tag, ...parts) => {
+  tag = compile(tag);
+  const strings = [], exprs = [];
+  for (const p of parts) {
+    if (Array.isArray(p) && p[0] === undefined) strings.push(p[1]);
+    else exprs.push(compile(p));
+  }
+  const strs = Object.assign([...strings], { raw: strings });
+  return ctx => tag(ctx)(strs, ...exprs.map(e => e(ctx)));
+});

package/feature/try.js

@@ -0,0 +1,57 @@
+// try/catch/finally/throw statements
+// AST: ['catch', ['try', body], param, catchBody] or ['finally', inner, body]
+import { space, parse, parens, expr, operator, compile } from '../parse.js';
+import { keyword, infix, block } from './block.js';
+import { BREAK, CONTINUE, RETURN } from './loop.js';
+
+const STATEMENT = 5;
+
+keyword('try', STATEMENT + 1, () => ['try', block()]);
+infix('catch', STATEMENT + 1, a => (space(), ['catch', a, parens(), block()]));
+infix('finally', STATEMENT + 1, a => ['finally', a, block()]);
+
+keyword('throw', STATEMENT + 1, () => {
+  parse.asi && (parse.newline = false);
+  space();
+  if (parse.newline) throw SyntaxError('Unexpected newline after throw');
+  return ['throw', expr(STATEMENT)];
+});
+
+// Compile
+operator('try', tryBody => {
+  tryBody = tryBody ? compile(tryBody) : null;
+  return ctx => tryBody?.(ctx);
+});
+
+operator('catch', (tryNode, catchName, catchBody) => {
+  const tryBody = tryNode?.[1] ? compile(tryNode[1]) : null;
+  catchBody = catchBody ? compile(catchBody) : null;
+  return ctx => {
+    let result;
+    try {
+      result = tryBody?.(ctx);
+    } catch (e) {
+      if (e?.type === BREAK || e?.type === CONTINUE || e?.type === RETURN) throw e;
+      if (catchName !== null && catchBody) {
+        const had = catchName in ctx, orig = ctx[catchName];
+        ctx[catchName] = e;
+        try { result = catchBody(ctx); }
+        finally { had ? ctx[catchName] = orig : delete ctx[catchName]; }
+      } else if (catchName === null) throw e;
+    }
+    return result;
+  };
+});
+
+operator('finally', (inner, finallyBody) => {
+  inner = inner ? compile(inner) : null;
+  finallyBody = finallyBody ? compile(finallyBody) : null;
+  return ctx => {
+    let result;
+    try { result = inner?.(ctx); }
+    finally { finallyBody?.(ctx); }
+    return result;
+  };
+});
+
+operator('throw', val => (val = compile(val), ctx => { throw val(ctx); }));

package/feature/unit.js

@@ -0,0 +1,35 @@
+/**
+ * Unit suffixes: 5px, 10rem, 2s, 500ms
+ *
+ * AST:
+ *   5px   → ['px', [,5]]
+ *   2.5s  → ['s', [,2.5]]
+ *
+ * Usage:
+ *   import { unit } from 'subscript/feature/unit.js'
+ *   unit('px', 'em', 'rem', 's', 'ms')
+ */
+import { lookup, next, parse, idx, seek, operator, compile } from '../parse.js';
+
+const units = {};
+
+export const unit = (...names) => names.forEach(name => {
+  units[name] = 1;
+  operator(name, val => (val = compile(val), ctx => ({ value: val(ctx), unit: name })));
+});
+
+// Wrap number handler to check for unit suffix
+const wrapNum = cc => {
+  const orig = lookup[cc];
+  if (!orig) return;
+  lookup[cc] = (a, prec) => {
+    const r = orig(a, prec);
+    if (!r || r[0] !== undefined) return r;
+    const start = idx, u = next(c => parse.id(c) && !(c >= 48 && c <= 57));
+    return u && units[u] ? [u, r] : (u && seek(start), r);
+  };
+};
+
+// Wrap digit and period handlers
+for (let i = 48; i <= 57; i++) wrapNum(i);
+wrapNum(46);