subscript 9.1.0 → 10.0.0

package/feature/collection.js

@@ -0,0 +1,40 @@
+/**
+ * Collection literals: arrays and objects (Justin feature)
+ *
+ * [a, b, c]
+ * {a: 1, b: 2}
+ * {a, b} (shorthand)
+ */
+import { group, binary, operator, compile } from '../parse.js';
+import { ACC } from './accessor.js';
+
+const ASSIGN = 20, TOKEN = 200;
+
+// [a,b,c]
+group('[]', TOKEN);
+
+// {a:1, b:2, c:3}
+group('{}', TOKEN);
+
+// a: b (colon operator for object properties)
+binary(':', ASSIGN - 1, true);
+
+// Compile
+operator('{}', (a, b) => {
+  if (b !== undefined) return;
+  a = !a ? [] : a[0] !== ',' ? [a] : a.slice(1);
+  const props = a.map(p => compile(typeof p === 'string' ? [':', p, p] : p));
+  return ctx => {
+    const obj = {}, acc = {};
+    for (const e of props.flatMap(f => f(ctx))) {
+      if (e[0] === ACC) {
+        const [, n, desc] = e;
+        acc[n] = { ...acc[n], ...desc, configurable: true, enumerable: true };
+      } else obj[e[0]] = e[1];
+    }
+    for (const n in acc) Object.defineProperty(obj, n, acc[n]);
+    return obj;
+  };
+});
+operator(':', (a, b) => (b = compile(b), Array.isArray(a) ?
+  (a = compile(a), ctx => [[a(ctx), b(ctx)]]) : ctx => [[a, b(ctx)]]));

package/feature/comment.js

@@ -1,7 +1,26 @@
-import { SPACE, STAR, PREC_TOKEN } from "../src/const.js"
-import { token, skip, next, cur, idx, expr } from "../src/parse.js"
+/** Configurable comments via parse.comment = { start: end } */
+import { parse, cur, idx, seek } from '../parse.js';
 
-// /**/, //
-// FIXME: try replacing with group
-token('/*', PREC_TOKEN, (a, prec) => (next(c => c !== STAR && cur.charCodeAt(idx + 1) !== 47), skip(2), a || expr(prec) || []))
-token('//', PREC_TOKEN, (a, prec) => (next(c => c >= SPACE), a || expr(prec) || []))
+const SPACE = 32, space = parse.space;
+
+// Default C-style comments
+parse.comment ??= { '//': '\n', '/*': '*/' };
+
+// Cached array: [[start, end, firstCharCode], ...]
+let comments;
+
+parse.space = () => {
+  if (!comments) comments = Object.entries(parse.comment).map(([s, e]) => [s, e, s.charCodeAt(0)]);
+  for (var cc; (cc = space()); ) {
+    for (var j = 0, c; c = comments[j++]; ) {
+      if (cc === c[2] && cur.substr(idx, c[0].length) === c[0]) {
+        var i = idx + c[0].length;
+        if (c[1] === '\n') while (cur.charCodeAt(i) >= SPACE) i++;
+        else { while (cur[i] && cur.substr(i, c[1].length) !== c[1]) i++; if (cur[i]) i += c[1].length; }
+        seek(i); cc = 0; break;
+      }
+    }
+    if (cc) return cc;
+  }
+  return cc;
+};

package/feature/destruct.js

@@ -0,0 +1,33 @@
+/**
+ * Destructuring patterns and binding
+ *
+ * Handles: [a, b] = arr, {x, y} = obj, [a, ...rest] = arr, {x = default} = obj
+ */
+import { compile } from '../parse.js';
+
+// Destructure value into context
+export const destructure = (pattern, value, ctx) => {
+  if (typeof pattern === 'string') { ctx[pattern] = value; return; }
+  const [op, ...items] = pattern;
+  if (op === '{}') {
+    for (const item of items) {
+      let key, binding, def;
+      if (item[0] === '=') [, [, key, binding], def] = item;
+      else [, key, binding] = item;
+      let val = value[key];
+      if (val === undefined && def) val = compile(def)(ctx);
+      destructure(binding, val, ctx);
+    }
+  } else if (op === '[]') {
+    let i = 0;
+    for (const item of items) {
+      if (item === null) { i++; continue; }
+      if (Array.isArray(item) && item[0] === '...') { ctx[item[1]] = value.slice(i); break; }
+      let binding = item, def;
+      if (Array.isArray(item) && item[0] === '=') [, binding, def] = item;
+      let val = value[i++];
+      if (val === undefined && def) val = compile(def)(ctx);
+      destructure(binding, val, ctx);
+    }
+  }
+};

package/feature/function.js

@@ -0,0 +1,44 @@
+// Function declarations and expressions
+import { space, next, parse, parens, expr, operator, compile } from '../parse.js';
+import { RETURN } from './loop.js';
+import { keyword, block } from './block.js';
+
+const TOKEN = 200;
+
+keyword('function', TOKEN, () => {
+  space();
+  const name = next(parse.id);
+  name && space();
+  return ['function', name, parens() || null, block()];
+});
+
+// Compile
+operator('function', (name, params, body) => {
+  body = body ? compile(body) : () => undefined;
+  // Normalize params: null → [], 'x' → ['x'], [',', 'a', 'b'] → ['a', 'b']
+  const ps = !params ? [] : params[0] === ',' ? params.slice(1) : [params];
+  // Check for rest param
+  let restName = null, restIdx = -1;
+  const last = ps[ps.length - 1];
+  if (Array.isArray(last) && last[0] === '...') {
+    restIdx = ps.length - 1;
+    restName = last[1];
+    ps.length--;
+  }
+  return ctx => {
+    const fn = (...args) => {
+      const l = {};
+      ps.forEach((p, i) => l[p] = args[i]);
+      if (restName) l[restName] = args.slice(restIdx);
+      const fnCtx = new Proxy(l, {
+        get: (l, k) => k in l ? l[k] : ctx[k],
+        set: (l, k, v) => ((k in l ? l : ctx)[k] = v, true),
+        has: (l, k) => k in l || k in ctx
+      });
+      try { return body(fnCtx); }
+      catch (e) { if (e?.type === RETURN) return e.value; throw e; }
+    };
+    if (name) ctx[name] = fn;
+    return fn;
+  };
+});

package/feature/group.js

@@ -1,12 +1,41 @@
-import { err, nary, group } from '../src/parse.js'
-import { compile, operator } from '../src/compile.js'
-import { PREC_ACCESS, PREC_GROUP, PREC_SEQ, PREC_STATEMENT } from '../src/const.js'
-
-// (a,b,c), (a)
-// FIXME: try raising group precedence (it causes conflict in ?. though)
-group('()', PREC_ACCESS)
-operator('()', (a, b) => b === undefined && (!a && err('Empty ()'), compile(a)))
-
-const last = (...args) => (args = args.map(compile), ctx => args.map(arg => arg(ctx)).pop())
-nary(',', PREC_SEQ), operator(',', last)
-nary(';', PREC_STATEMENT, true), operator(';', last)
+import { nary, group, operator, compile } from '../parse.js';
+import { BREAK, CONTINUE } from './loop.js';
+import { prop } from './access.js';
+
+const STATEMENT = 5, SEQ = 10, ACCESS = 170;
+
+// (a,b,c), (a) — uses ACCESS to avoid conflict with ?.
+group('()', ACCESS);
+
+// Sequences
+nary(',', SEQ);
+nary(';', STATEMENT, true);  // right-assoc to allow same-prec statements
+
+// Compile
+const err = msg => { throw Error(msg) };
+operator('()', (a, b) => {
+  // Group: (expr) - no second argument means grouping, not call
+  if (b === undefined) return a == null ? err('Empty ()') : compile(a);
+  // Validate: no sparse arguments in calls
+  const hasSparse = n => n?.[0] === ',' && n.slice(1).some(a => a == null || hasSparse(a));
+  if (hasSparse(b)) err('Empty argument');
+  const args = !b ? () => [] :
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) :
+    (b = compile(b), ctx => [b(ctx)]);
+  return prop(a, (obj, path, ctx) => obj[path](...args(ctx)), true);
+});
+
+// sequence returns last evaluated value; catches BREAK/CONTINUE and attaches result
+const seq = (...args) => (args = args.map(compile), ctx => {
+  let r;
+  for (const arg of args) {
+    try { r = arg(ctx); }
+    catch (e) {
+      if (e?.type === BREAK || e?.type === CONTINUE) { e.value = r; throw e; }
+      throw e;
+    }
+  }
+  return r;
+});
+operator(',', seq);
+operator(';', seq);

package/feature/if.js

@@ -0,0 +1,28 @@
+// If/else statement - else consumed internally
+import { space, skip, parens, word, idx, seek, operator, compile } from '../parse.js';
+import { body, keyword } from './block.js';
+
+const STATEMENT = 5, SEMI = 59;
+
+// Check for `else` after optional semicolon
+const checkElse = () => {
+  const from = idx;
+  if (space() === SEMI) skip();
+  space();
+  if (word('else')) return skip(4), true;
+  return seek(from), false;
+};
+
+// if (cond) body [else body] - self-contained
+keyword('if', STATEMENT + 1, () => {
+  space();
+  const node = ['if', parens(), body()];
+  if (checkElse()) node.push(body());
+  return node;
+});
+
+// Compile
+operator('if', (cond, body, alt) => {
+  cond = compile(cond); body = compile(body); alt = alt !== undefined ? compile(alt) : null;
+  return ctx => cond(ctx) ? body(ctx) : alt?.(ctx);
+});

package/feature/literal.js

@@ -0,0 +1,13 @@
+/**
+ * Literal values
+ *
+ * true, false, null, undefined, NaN, Infinity
+ */
+import { literal } from '../parse.js';
+
+literal('true', true);
+literal('false', false);
+literal('null', null);
+literal('undefined', undefined);
+literal('NaN', NaN);
+literal('Infinity', Infinity);

package/feature/loop.js

@@ -0,0 +1,123 @@
+// Loops: while, do-while, for, for await, break, continue, return
+import { expr, skip, space, parse, word, parens, cur, idx, operator, compile } from '../parse.js';
+import { body, keyword } from './block.js';
+import { destructure } from './destruct.js';
+
+// Control flow symbols
+export const BREAK = Symbol('break'), CONTINUE = Symbol('continue'), RETURN = Symbol('return');
+
+// Loop body executor - catches control flow and returns status
+export const loop = (body, ctx) => {
+  try { return { v: body(ctx) }; }
+  catch (e) {
+    if (e?.type === BREAK) return { b: 1 };
+    if (e?.type === CONTINUE) return { c: 1 };
+    if (e?.type === RETURN) return { r: 1, v: e.value };
+    throw e;
+  }
+};
+
+const STATEMENT = 5, CBRACE = 125, SEMI = 59;
+
+keyword('while', STATEMENT + 1, () => (space(), ['while', parens(), body()]));
+keyword('do', STATEMENT + 1, () => (b => (space(), skip(5), space(), ['do', b, parens()]))(body()));
+
+// for / for await
+keyword('for', STATEMENT + 1, () => {
+  space();
+  // for await (x of y)
+  if (word('await')) {
+    skip(5);
+    space();
+    return ['for await', parens(), body()];
+  }
+  return ['for', parens(), body()];
+});
+
+keyword('break', STATEMENT + 1, () => ['break']);
+keyword('continue', STATEMENT + 1, () => ['continue']);
+keyword('return', STATEMENT + 1, () => {
+  parse.asi && (parse.newline = false);
+  space();
+  const c = cur.charCodeAt(idx);
+  return !c || c === CBRACE || c === SEMI || parse.newline ? ['return'] : ['return', expr(STATEMENT)];
+});
+
+// Compile
+operator('while', (cond, body) => {
+  cond = compile(cond); body = compile(body);
+  return ctx => {
+    let r, res;
+    while (cond(ctx)) if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    return res;
+  };
+});
+
+operator('do', (body, cond) => {
+  body = compile(body); cond = compile(cond);
+  return ctx => {
+    let r, res;
+    do { if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v; } while (cond(ctx));
+    return res;
+  };
+});
+
+operator('for', (head, body) => {
+  // Normalize head: [';', init, cond, step] or single expr (for-in/of)
+  if (Array.isArray(head) && head[0] === ';') {
+    let [, init, cond, step] = head;
+    init = init ? compile(init) : null;
+    cond = cond ? compile(cond) : () => true;
+    step = step ? compile(step) : null;
+    body = compile(body);
+    return ctx => {
+      let r, res;
+      for (init?.(ctx); cond(ctx); step?.(ctx))
+        if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+      return res;
+    };
+  }
+  // For-in/of: head is ['in', lhs, rhs] or ['of', lhs, rhs]
+  if (Array.isArray(head) && (head[0] === 'in' || head[0] === 'of')) {
+    let [op, lhs, rhs] = head;
+    // Extract name from declaration: ['let', 'x'] → 'x'
+    if (Array.isArray(lhs) && (lhs[0] === 'let' || lhs[0] === 'const' || lhs[0] === 'var')) lhs = lhs[1];
+    if (op === 'in') return forIn(lhs, rhs, body);
+    if (op === 'of') return forOf(lhs, rhs, body);
+  }
+});
+
+const forOf = (name, iterable, body) => {
+  iterable = compile(iterable); body = compile(body);
+  const isPattern = Array.isArray(name);
+  return ctx => {
+    let r, res;
+    const prev = isPattern ? null : ctx[name];
+    for (const val of iterable(ctx)) {
+      if (isPattern) destructure(name, val, ctx); else ctx[name] = val;
+      if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    }
+    if (!isPattern) ctx[name] = prev;
+    return res;
+  };
+};
+
+const forIn = (name, obj, body) => {
+  obj = compile(obj); body = compile(body);
+  const isPattern = Array.isArray(name);
+  return ctx => {
+    let r, res;
+    const prev = isPattern ? null : ctx[name];
+    for (const key in obj(ctx)) {
+      if (isPattern) destructure(name, key, ctx); else ctx[name] = key;
+      if ((r = loop(body, ctx)).b) break; else if (r.r) return r.v; else if (!r.c) res = r.v;
+    }
+    if (!isPattern) ctx[name] = prev;
+    return res;
+  };
+};
+
+operator('break', () => () => { throw { type: BREAK }; });
+operator('continue', () => () => { throw { type: CONTINUE }; });
+operator('return', val => (val = val !== undefined ? compile(val) : null,
+  ctx => { throw { type: RETURN, value: val?.(ctx) }; }));

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,13 +1,48 @@
-import { lookup, next, skip, err, 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';
 
-// parse number
-const num = (a, _) => [, (
-  a = +next(c => (c === PERIOD) || (c >= _0 && c <= _9) || (c === _E || c === _e ? 2 : 0))
-) != a ? err() : a]
+const PERIOD = 46, _0 = 48, _9 = 57, _E = 69, _e = 101, PLUS = 43, MINUS = 45;
+const _a = 97, _f = 102, _A = 65, _F = 70;
 
-// .1
-lookup[PERIOD] = a => !a && num()
+// 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];
 
-// 0-9
-for (let i = _0; i <= _9; i++) lookup[i] = a => a ? err() : 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)
+};
+
+// Default: no prefixes
+parse.number = null;
+
+// .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;
+  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();
+};

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)));