subscript 9.2.0 → 10.0.0

package/feature/op/arithmetic.js

@@ -0,0 +1,29 @@
+/**
+ * Arithmetic operators
+ *
+ * + - * / %
+ * Unary: + -
+ */
+import { binary, unary, operator, compile } from '../../parse.js';
+
+const ADD = 110, MULT = 120, PREFIX = 140;
+
+binary('+', ADD);
+binary('-', ADD);
+binary('*', MULT);
+binary('/', MULT);
+binary('%', MULT);
+
+unary('+', PREFIX);
+unary('-', PREFIX);
+
+// Compile
+operator('+', (a, b) => b !== undefined ?
+  (a = compile(a), b = compile(b), ctx => a(ctx) + b(ctx)) :
+  (a = compile(a), ctx => +a(ctx)));
+operator('-', (a, b) => b !== undefined ?
+  (a = compile(a), b = compile(b), ctx => a(ctx) - b(ctx)) :
+  (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)));
+operator('%', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) % b(ctx)));

package/feature/op/arrow.js

@@ -0,0 +1,33 @@
+/**
+ * Arrow function operator
+ *
+ * (a, b) => expr → arrow function
+ *
+ * Common in: JS, TS, Java, C#, Kotlin, Scala
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const ASSIGN = 20;
+
+binary('=>', ASSIGN, true);
+
+// Compile
+operator('=>', (a, b) => {
+  a = a[0] === '()' ? a[1] : a;
+  a = !a ? [] : a[0] === ',' ? a.slice(1) : [a];
+  let restIdx = -1, restName = null;
+  if (a.length && Array.isArray(a[a.length - 1]) && a[a.length - 1][0] === '...') {
+    restIdx = a.length - 1;
+    restName = a[restIdx][1];
+    a = a.slice(0, -1);
+  }
+  b = compile(b[0] === '{}' ? b[1] : b);
+  return (ctx = null) => {
+    ctx = Object.create(ctx);
+    return (...args) => {
+      a.forEach((p, i) => ctx[p] = args[i]);
+      if (restName) ctx[restName] = args.slice(restIdx);
+      return b(ctx);
+    };
+  };
+});

package/feature/op/assign-logical.js

@@ -0,0 +1,33 @@
+/**
+ * Logical/nullish assignment operators + destructuring
+ *
+ * ||= &&= ??= + destructuring support for let/const/var
+ */
+import { binary, operator, compile } from '../../parse.js';
+import { destructure } from '../destruct.js';
+import { isLval, prop } from '../access.js';
+
+const ASSIGN = 20;
+const err = msg => { throw Error(msg) };
+
+binary('||=', ASSIGN, true);
+binary('&&=', ASSIGN, true);
+binary('??=', ASSIGN, true);
+
+// Override = to support destructuring
+operator('=', (a, b) => {
+  // Handle let/const/var declarations: ['=', ['let', pattern], value]
+  if (Array.isArray(a) && (a[0] === 'let' || a[0] === 'const' || a[0] === 'var')) {
+    const pattern = a[1];
+    b = compile(b);
+    if (typeof pattern === 'string') return ctx => { ctx[pattern] = b(ctx); };
+    return ctx => destructure(pattern, b(ctx), ctx);
+  }
+  isLval(a) || err('Invalid assignment target');
+  return (b = compile(b), prop(a, (obj, path, ctx) => obj[path] = b(ctx)));
+});
+
+// Compile
+operator('||=', (a, b) => (isLval(a) || err('Invalid assignment target'), b = compile(b), prop(a, (o, k, ctx) => o[k] ||= b(ctx))));
+operator('&&=', (a, b) => (isLval(a) || err('Invalid assignment target'), b = compile(b), prop(a, (o, k, ctx) => o[k] &&= b(ctx))));
+operator('??=', (a, b) => (isLval(a) || err('Invalid assignment target'), b = compile(b), prop(a, (o, k, ctx) => o[k] ??= b(ctx))));

package/feature/op/assignment.js

@@ -0,0 +1,47 @@
+/**
+ * Assignment operators (C-family)
+ *
+ * = += -= *= /= %= |= &= ^= >>= <<=
+ * Note: **= is in pow.js, >>>= ||= &&= ??= are JS-specific (in assignment-js.js)
+ */
+import { binary, operator, compile } from '../../parse.js';
+
+const ASSIGN = 20;
+
+// Base assignment
+binary('=', ASSIGN, true);
+
+// Compound arithmetic
+binary('+=', ASSIGN, true);
+binary('-=', ASSIGN, true);
+binary('*=', ASSIGN, true);
+binary('/=', ASSIGN, true);
+binary('%=', ASSIGN, true);
+
+// Compound bitwise
+binary('|=', ASSIGN, true);
+binary('&=', ASSIGN, true);
+binary('^=', ASSIGN, true);
+binary('>>=', ASSIGN, true);
+binary('<<=', ASSIGN, true);
+
+// Simple assign helper for x, a.b, a[b], (x)
+const assign = (a, fn, obj, key) =>
+  typeof a === 'string' ? ctx => fn(ctx, a, ctx) :
+  a[0] === '.' ? (obj = compile(a[1]), key = a[2], ctx => fn(obj(ctx), key, ctx)) :
+  a[0] === '[]' && a.length === 3 ? (obj = compile(a[1]), key = compile(a[2]), ctx => fn(obj(ctx), key(ctx), ctx)) :
+  a[0] === '()' && a.length === 2 ? assign(a[1], fn) :  // unwrap parens: (x) = 1
+  (() => { throw Error('Invalid assignment target') })();
+
+// Compile
+operator('=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] = b(ctx))));
+operator('+=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] += b(ctx))));
+operator('-=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] -= b(ctx))));
+operator('*=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] *= b(ctx))));
+operator('/=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] /= b(ctx))));
+operator('%=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] %= b(ctx))));
+operator('|=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] |= b(ctx))));
+operator('&=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] &= b(ctx))));
+operator('^=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] ^= b(ctx))));
+operator('>>=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] >>= b(ctx))));
+operator('<<=', (a, b) => (b = compile(b), assign(a, (o, k, ctx) => o[k] <<= b(ctx))));

package/feature/op/bitwise-unsigned.js

@@ -0,0 +1,17 @@
+/**
+ * Unsigned right shift operators
+ *
+ * >>> >>>=
+ */
+import { binary, operator, compile } from '../../parse.js';
+import { isLval, prop } from '../access.js';
+
+const ASSIGN = 20, SHIFT = 100;
+const err = msg => { throw Error(msg) };
+
+binary('>>>', SHIFT);
+binary('>>>=', ASSIGN, true);
+
+// Compile
+operator('>>>', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) >>> b(ctx)));
+operator('>>>=', (a, b) => (isLval(a) || err('Invalid assignment target'), b = compile(b), prop(a, (o, k, ctx) => o[k] >>>= b(ctx))));

package/feature/op/bitwise.js

@@ -0,0 +1,29 @@
+/**
+ * Bitwise operators (C-family)
+ *
+ * | & ^ ~ >> <<
+ * Note: >>> is JS-specific (in bitwise-js.js)
+ */
+import { binary, unary, operator, compile } from '../../parse.js';
+
+const OR = 50, XOR = 60, AND = 70, SHIFT = 100, PREFIX = 140;
+
+// Base operators first (tried last in chain)
+binary('|', OR);
+binary('&', AND);
+binary('^', XOR);
+
+// Shifts (after < >)
+binary('>>', SHIFT);
+binary('<<', SHIFT);
+
+// Unary
+unary('~', PREFIX);
+
+// 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)));
+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/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);