subscript 9.2.0 → 10.0.1

package/feature/module.js

@@ -0,0 +1,42 @@
+/**
+ * Import/Export with contextual 'from' operator
+ *
+ * AST:
+ *   import './x.js'              → ['import', path]
+ *   import X from './x.js'       → ['import', ['from', 'X', path]]
+ *   import { a, b } from './x'   → ['import', ['from', ['{}', ...], path]]
+ *   import * as X from './x.js'  → ['import', ['from', ['as', '*', X], path]]
+ *   export { a } from './x'      → ['export', ['from', ['{}', ...], path]]
+ *   export const x = 1           → ['export', decl]
+ */
+import { token, expr, space, lookup, skip } from '../parse.js';
+import { keyword } from './block.js';
+
+const STATEMENT = 5, SEQ = 10, STAR = 42;
+
+// * as prefix in import context (import * as X)
+const prevStar = lookup[STAR];
+lookup[STAR] = (a, prec) => !a ? (skip(), '*') : prevStar?.(a, prec);
+
+// 'from' as contextual binary - only after import-like LHS (not = or ,), false in prefix for identifier fallback
+token('from', SEQ + 1, a => !a ? false : a[0] !== '=' && a[0] !== ',' && (space(), ['from', a, expr(SEQ + 1)]));
+
+// 'as' for aliasing: * as X, { a as b }. False in prefix for identifier fallback
+token('as', SEQ + 2, a => !a ? false : (space(), ['as', a, expr(SEQ + 2)]));
+
+// import: prefix that parses specifiers + from + path
+keyword('import', STATEMENT, () => (space(), ['import', expr(SEQ)]));
+
+// export: prefix for declarations or re-exports (use STATEMENT to capture const/let/function)
+keyword('export', STATEMENT, () => (space(), ['export', expr(STATEMENT)]));
+
+// default: prefix for export default
+keyword('default', SEQ + 1, () => (space(), ['default', expr(SEQ)]));
+
+// Compile stubs - import/export are parse-only (no runtime semantics)
+import { operator, compile } from '../parse.js';
+operator('import', () => () => undefined);
+operator('export', () => () => undefined);
+operator('from', (a, b) => () => undefined);
+operator('as', (a, b) => () => undefined);
+operator('default', (a) => compile(a));

package/feature/number.js

@@ -1,45 +1,48 @@
-import { lookup, next, err, skip } from "../src/parse.js"
-import { cur, idx } from "../src/parse.js"
-import { PERIOD, _0, _E, _e, _9 } from "../src/const.js"
+/**
+ * Numbers with configurable prefix notation
+ *
+ * Configurable via parse.number: { '0x': 16, '0b': 2, '0o': 8 }
+ */
+import { parse, lookup, next, err, skip, idx, cur } from '../parse.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 PERIOD = 46, _0 = 48, _9 = 57, _E = 69, _e = 101, PLUS = 43, MINUS = 45;
+const _a = 97, _f = 102, _A = 65, _F = 70;
 
-// parse decimal number (with optional exponent)
-const num = (a, _) => [, (
-  a = +next(c => (c === PERIOD) || (c >= _0 && c <= _9) || (c === _E || c === _e ? 2 : 0))
-) != a ? err() : a]
+// Decimal number - check for .. range operator (don't consume . if followed by .)
+const num = a => [, (
+  a = +next(c =>
+    // . is decimal only if NOT followed by another . (range operator)
+    (c === PERIOD && cur.charCodeAt(idx + 1) !== PERIOD) ||
+    (c >= _0 && c <= _9) ||
+    ((c === _E || c === _e) && ((c = cur.charCodeAt(idx + 1)) >= _0 && c <= _9 || c === PLUS || c === MINUS) ? 2 : 0)
+  )
+) != a ? err() : a];
 
-// .1
-lookup[PERIOD] = a => !a && num()
+// Char test for prefix base
+const charTest = {
+  2: c => c === 48 || c === 49,
+  8: c => c >= 48 && c <= 55,
+  16: c => (c >= _0 && c <= _9) || (c >= _a && c <= _f) || (c >= _A && c <= _F)
+};
 
-// 1-9 (non-zero starts decimal)
-for (let i = _0 + 1; i <= _9; i++) lookup[i] = a => a ? err() : num()
+// Default: no prefixes
+parse.number = null;
 
-// 0 - check for prefix (0b, 0o, 0x) or plain decimal
+// .1 (but not .. range)
+lookup[PERIOD] = a => !a && cur.charCodeAt(idx + 1) !== PERIOD && num();
+
+// 0-9: check parse.number for prefix config
+for (let i = _0; i <= _9; i++) lookup[i] = a => a ? void 0 : num();
 lookup[_0] = a => {
-  if (a) return err()
-  const nextChar = cur.charCodeAt(idx + 1)
-  
-  // Binary: 0b
-  if (nextChar === _b || nextChar === _B) {
-    skip(); skip() // consume '0b'
-    const s = next(c => c === 48 || c === 49) // 0 or 1
-    return [, parseInt(s, 2)]
-  }
-  // Octal: 0o
-  if (nextChar === _o || nextChar === _O) {
-    skip(); skip() // consume '0o'
-    const s = next(c => c >= 48 && c <= 55) // 0-7
-    return [, parseInt(s, 8)]
-  }
-  // Hex: 0x
-  if (nextChar === _x || nextChar === _X) {
-    skip(); skip() // consume '0x'
-    const s = next(c => (c >= _0 && c <= _9) || (c >= _a && c <= _f) || (c >= _A && c <= _F))
-    return [, parseInt(s, 16)]
+  if (a) return;
+  const cfg = parse.number;
+  if (cfg) {
+    for (const [pre, base] of Object.entries(cfg)) {
+      if (pre[0] === '0' && cur[idx + 1]?.toLowerCase() === pre[1]) {
+        skip(2);
+        return [, parseInt(next(charTest[base]), base)];
+      }
+    }
   }
-  
-  return num()
-}
+  return num();
+};

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,26 @@
+/**
+ * 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;
+
+// Register all assignment operators
+'= += -= *= /= %= |= &= ^= >>= <<='.split(' ').map(op => binary(op, 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) :
+  (() => { throw Error('Invalid assignment target') })();
+
+// Compile - use Function to generate operator implementations
+const ops = { '=': (o,k,v)=>o[k]=v, '+=': (o,k,v)=>o[k]+=v, '-=': (o,k,v)=>o[k]-=v, '*=': (o,k,v)=>o[k]*=v,
+  '/=': (o,k,v)=>o[k]/=v, '%=': (o,k,v)=>o[k]%=v, '|=': (o,k,v)=>o[k]|=v, '&=': (o,k,v)=>o[k]&=v,
+  '^=': (o,k,v)=>o[k]^=v, '>>=': (o,k,v)=>o[k]>>=v, '<<=': (o,k,v)=>o[k]<<=v };
+for (const op in ops) operator(op, (a, b) => (b = compile(b), assign(a, (o, k, ctx) => ops[op](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));
+});