subscript 10.3.6 → 10.4.1

package/README.md

@@ -58,7 +58,7 @@ let fn = jessie(`
 fn({})  // 120
 ```
 
-See [docs](./docs.md#presets) for full description.
+Each preset has a parse-only entry — `subscript/feature/{subscript,justin,jessie}` — that drops the runtime (~50% smaller) for consumers that only need the AST. See [docs](./docs.md#presets) for full description.
 
 
 ## Syntax tree
@@ -83,7 +83,7 @@ See [spec.md](./spec.md).
 
 ## Extension
 
-Add operators, literals or custom syntax:
+Add operators, literals or custom syntax. `binary`/`unary`/`token`/`keyword` register parsers; `operator` registers compilers — pair them as needed:
 
 ```js
 import justin, { binary, operator, compile } from 'subscript/justin.js'
@@ -98,6 +98,13 @@ operator('∩', (a, b) => (  // register compiler
 justin('[1,2,3] ∩ [2,3,4]')({})  // [2, 3]
 ```
 
+For parse-only consumers, register only the parse half:
+
+```js
+import { binary } from 'subscript/feature/justin.js'
+binary('∩', 80)
+```
+
 See [docs.md](./docs.md) for full API.
 
 

package/eval/access.js

@@ -0,0 +1,57 @@
+// Property access - eval half
+import { operator, compile } from '../parse.js';
+
+// Block prototype chain attacks
+export const unsafe = k => k?.[0] === '_' && k[1] === '_' || k === 'constructor' || k === 'prototype';
+
+const err = msg => { throw Error(msg) };
+operator('[]', (a, b) => {
+  // Array literal: [1,2,3] - b is strictly undefined (AST length 2)
+  if (b === undefined) {
+    a = !a ? [] : a[0] === ',' ? a.slice(1) : [a];
+    a = a.map(a => a == null ? (() => undefined) : a[0] === '...' ? (a = compile(a[1]), ctx => a(ctx)) : (a = compile(a), ctx => [a(ctx)]));
+    return ctx => a.flatMap(a => a(ctx));
+  }
+  // Member access: a[b]
+  if (b == null) err('Missing index');
+  a = compile(a); b = compile(b);
+  return ctx => { const k = b(ctx); return unsafe(k) ? undefined : a(ctx)[k]; };
+});
+operator('.', (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, unsafe(b) ? () => undefined : 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);
+  // 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)]);
+  // Inline call handling for x(), a.b(), a[b](), (x)()
+  return call(a, (obj, path, ctx) => obj[path](...args(ctx)));
+});
+
+// Left-value check (valid assignment target)
+export const isLval = n =>
+  typeof n === 'string' ||
+  (Array.isArray(n) && (
+    n[0] === '.' || n[0] === '?.' ||
+    (n[0] === '[]' && n.length === 3) || n[0] === '?.[]' ||
+    (n[0] === '()' && n.length === 2 && isLval(n[1])) ||
+    n[0] === '{}'
+  ));
+
+// Simple call helper (no optional chaining) - handles x(), a.b(), a[b](), (x)()
+const call = (a, fn, obj, path) => (
+  a == null ? err('Empty ()') :
+  a[0] === '()' && a.length == 2 ? call(a[1], fn) :
+  typeof a === 'string' ? ctx => fn(ctx, a, ctx) :
+  a[0] === '.' ? (obj = compile(a[1]), path = a[2], ctx => fn(obj(ctx), path, ctx)) :
+  a[0] === '?.' ? (obj = compile(a[1]), path = a[2], ctx => { const o = obj(ctx); return o == null ? undefined : fn(o, path, ctx); }) :
+  a[0] === '[]' && a.length === 3 ? (obj = compile(a[1]), path = compile(a[2]), ctx => fn(obj(ctx), path(ctx), ctx)) :
+  a[0] === '?.[]' ? (obj = compile(a[1]), path = compile(a[2]), ctx => { const o = obj(ctx); return o == null ? undefined : fn(o, path(ctx), ctx); }) :
+  (a = compile(a), ctx => fn([a(ctx)], 0, ctx))
+);
+
+// Export as prop for backward compatibility with other features
+export const prop = call;

package/eval/accessor.js

@@ -0,0 +1,19 @@
+// Object accessor properties (getters/setters) - eval half
+import { operator, compile } from '../parse.js';
+
+// Accessor marker for object property definitions
+export const ACC = Symbol('accessor');
+
+operator('get', (name, body) => {
+  body = body ? compile(body) : () => {};
+  return ctx => [[ACC, name, {
+    get: function() { const s = Object.create(ctx || {}); s.this = this; return body(s); }
+  }]];
+});
+
+operator('set', (name, param, body) => {
+  body = body ? compile(body) : () => {};
+  return ctx => [[ACC, name, {
+    set: function(v) { const s = Object.create(ctx || {}); s.this = this; s[param] = v; body(s); }
+  }]];
+});

package/eval/async.js

@@ -0,0 +1,13 @@
+// Async/await/yield - eval half
+import { operator, compile } from '../parse.js';
+
+operator('async', fn => {
+  const inner = compile(fn);
+  return ctx => {
+    const f = inner(ctx);
+    return async function(...args) { return f(...args); };
+  };
+});
+operator('await', a => (a = compile(a), async ctx => await a(ctx)));
+operator('yield', a => (a = a ? compile(a) : null, ctx => { throw { __yield__: a ? a(ctx) : undefined }; }));
+operator('yield*', a => (a = compile(a), ctx => { throw { __yield_all__: a(ctx) }; }));

package/eval/class.js

@@ -0,0 +1,35 @@
+// Class declarations and expressions - eval half
+import { operator, compile } from '../parse.js';
+
+const STATIC = Symbol('static');
+const err = msg => { throw Error(msg) };
+
+operator('instanceof', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) instanceof b(ctx)));
+operator('class', (name, base, body) => {
+  base = base ? compile(base) : null;
+  body = body ? compile(body) : null;
+  return ctx => {
+    const Parent = base ? base(ctx) : Object;
+    const cls = function(...args) {
+      if (!(this instanceof cls)) return err('Class constructor must be called with new');
+      const instance = base ? Reflect.construct(Parent, args, cls) : this;
+      if (cls.prototype.__constructor__) cls.prototype.__constructor__.apply(instance, args);
+      return instance;
+    };
+    Object.setPrototypeOf(cls.prototype, Parent.prototype);
+    Object.setPrototypeOf(cls, Parent);
+    if (body) {
+      const methods = Object.create(ctx);
+      methods['super'] = Parent;
+      const entries = body(methods);
+      const items = Array.isArray(entries) && typeof entries[0]?.[0] === 'string' ? entries : [];
+      for (const [k, v] of items) {
+        if (k === 'constructor') cls.prototype.__constructor__ = v;
+        else cls.prototype[k] = v;
+      }
+    }
+    if (name) ctx[name] = cls;
+    return cls;
+  };
+});
+operator('static', a => (a = compile(a), ctx => [[STATIC, a(ctx)]]));

package/eval/collection.js

@@ -0,0 +1,41 @@
+// Collection literals - eval half
+// Block vs object detection (jessie):
+//   ['{}', [';', ...]]     → ['{', body]     block with statements
+//   ['{}', ['let', ...]]   → ['{', body]     block with declaration
+//   ['{}', null]           → ['{}', null]    empty object {}
+//   ['{}', 'a']            → ['{}', 'a']     object shorthand {a}
+//   ['{}', [':', k, v]]    → ['{}', ...]     object literal
+import { operator, compile } from '../parse.js';
+import { ACC } from './accessor.js';
+
+// Object inner: null, string, or array starting with : , ... get set
+const isObject = a => a == null || typeof a === 'string' || [':', ',', '...', 'get', 'set'].includes(a[0]);
+
+operator('{}', (a, b) => {
+  if (b !== undefined) return;
+  // Block: not an object pattern
+  if (!isObject(a)) return compile(['{', a]);
+  // Object literal
+  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;
+  };
+});
+
+// Block statement - creates scope
+operator('{', body => {
+  body = body ? compile(body) : () => undefined;
+  return ctx => body(Object.create(ctx));
+});
+
+operator(':', (a, b) => (b = compile(b), Array.isArray(a) ?
+  (a = compile(a), ctx => [[a(ctx), b(ctx)]]) : ctx => [[a, b(ctx)]]));

package/eval/function.js

@@ -0,0 +1,37 @@
+// Function declarations and expressions - eval half
+import { operator, compile } from '../parse.js';
+import { RETURN } from './op/arrow.js';
+
+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 === RETURN) return e[0]; throw e; }
+    };
+    if (name) ctx[name] = fn;
+    return fn;
+  };
+});
+
+operator('function*', (name, params, body) => {
+  throw Error('Generator functions are not supported in evaluation');
+});

package/eval/if.js

@@ -0,0 +1,7 @@
+// If/else - eval half
+import { operator, compile } from '../parse.js';
+
+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/eval/jessie.js

@@ -0,0 +1,19 @@
+/**
+ * jessie - eval aggregator
+ * Runtime handlers for jessie dialect (must be paired with feature/jessie.js).
+ */
+import './justin.js';
+
+import './var.js';
+import './function.js';
+import './async.js';
+import './class.js';
+import './regex.js';
+
+import './if.js';
+import './loop.js';
+import './try.js';
+import './switch.js';
+
+import './module.js';
+import './accessor.js';

package/eval/justin.js

@@ -0,0 +1,21 @@
+/**
+ * justin - eval aggregator
+ * Runtime handlers for justin dialect (must be paired with feature/justin.js).
+ */
+import './subscript.js';
+
+import './op/identity.js';
+import './op/nullish.js';
+import './op/pow.js';
+import './op/membership.js';
+import './op/bitwise-unsigned.js';
+import './op/assign-logical.js';
+
+import './op/ternary.js';
+import './op/arrow.js';
+import './op/spread.js';
+import './op/optional.js';
+import './op/unary.js';
+
+import './collection.js';
+import './template.js';

package/eval/loop.js

@@ -0,0 +1,108 @@
+// Loops - eval half
+import { operator, compile } from '../parse.js';
+import { RETURN } from './op/arrow.js';
+import { destructure } from './var.js';
+
+export const BREAK = Symbol('break'), CONTINUE = Symbol('continue');
+
+operator('while', (cond, body) => {
+  cond = compile(cond); body = compile(body);
+  return ctx => {
+    let res;
+    while (cond(ctx)) try { res = body(ctx); } catch (e) {
+      if (e === BREAK) break;
+      if (e === CONTINUE) continue;
+      if (e === RETURN) return e[0];
+      throw e;
+    }
+    return res;
+  };
+});
+
+operator('do', (body, cond) => {
+  body = compile(body); cond = compile(cond);
+  return ctx => {
+    let res;
+    do try { res = body(ctx); } catch (e) {
+      if (e === BREAK) break;
+      if (e === CONTINUE) continue;
+      if (e === RETURN) return e[0];
+      throw e;
+    } 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 res;
+      for (init?.(ctx); cond(ctx); step?.(ctx)) try { res = body(ctx); } catch (e) {
+        if (e === BREAK) break;
+        if (e === CONTINUE) continue;
+        if (e === RETURN) return e[0];
+        throw e;
+      }
+      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 res;
+    const prev = isPattern ? null : ctx[name];
+    for (const val of iterable(ctx)) {
+      if (isPattern) destructure(name, val, ctx); else ctx[name] = val;
+      try { res = body(ctx); } catch (e) {
+        if (e === BREAK) break;
+        if (e === CONTINUE) continue;
+        if (e === RETURN) return e[0];
+        throw e;
+      }
+    }
+    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 res;
+    const prev = isPattern ? null : ctx[name];
+    for (const key in obj(ctx)) {
+      if (isPattern) destructure(name, key, ctx); else ctx[name] = key;
+      try { res = body(ctx); } catch (e) {
+        if (e === BREAK) break;
+        if (e === CONTINUE) continue;
+        if (e === RETURN) return e[0];
+        throw e;
+      }
+    }
+    if (!isPattern) ctx[name] = prev;
+    return res;
+  };
+};
+
+operator('break', () => () => { throw BREAK; });
+operator('continue', () => () => { throw CONTINUE; });
+operator('return', val => (val = val !== undefined ? compile(val) : null,
+  ctx => { throw (RETURN[0] = val?.(ctx), RETURN); }));

package/eval/module.js

@@ -0,0 +1,8 @@
+// Import/Export - eval stubs (parse-only 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/eval/op/arithmetic.js

@@ -0,0 +1,12 @@
+// Arithmetic operators - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/arrow.js

@@ -0,0 +1,35 @@
+// Arrow function operator - eval half
+import { operator, compile } from '../../parse.js';
+
+// RETURN: array to hold value - reused, no allocation per throw
+export const RETURN = [];
+
+operator('=>', (a, b) => {
+  // Normalize params: () → [], x → [x], (a, b) → [a, b]
+  a = a?.[0] === '()' ? a[1] : a;
+  const ps = !a ? [] : a[0] === ',' ? a.slice(1) : [a];
+  // Check for rest param
+  let restIdx = -1, restName = null;
+  const last = ps[ps.length - 1];
+  if (Array.isArray(last) && last[0] === '...') {
+    restIdx = ps.length - 1;
+    restName = last[1];
+    ps.length--;
+  }
+  // Arrow body: {} is always block (need parens for object: ({...}))
+  // Block body returns undefined unless explicit return
+  const isBlock = b?.[0] === '{}';
+  b = compile(isBlock ? ['{', b[1]] : b);
+  return ctx => (...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 || (ctx ? k in ctx : false)
+    });
+    try { const r = b(fnCtx); return isBlock ? undefined : r; }
+    catch (e) { if (e === RETURN) return e[0]; throw e; }
+  };
+});

package/eval/op/assign-logical.js

@@ -0,0 +1,23 @@
+// Logical/nullish assignment operators + destructuring assignment - eval half
+import { operator, compile } from '../../parse.js';
+import { destructure } from '../var.js';
+import { isLval, prop } from '../access.js';
+
+const err = msg => { throw Error(msg) };
+
+// 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)));
+});
+
+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/eval/op/assignment.js

@@ -0,0 +1,15 @@
+// Assignment operators (C-family) - eval half
+import { operator, compile } from '../../parse.js';
+
+// 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') })();
+
+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/eval/op/bitwise-unsigned.js

@@ -0,0 +1,8 @@
+// Unsigned right shift operators - eval half
+import { operator, compile } from '../../parse.js';
+import { isLval, prop } from '../access.js';
+
+const err = msg => { throw Error(msg) };
+
+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/eval/op/bitwise.js

@@ -0,0 +1,9 @@
+// Bitwise operators - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/comparison.js

@@ -0,0 +1,7 @@
+// Comparison operators - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/defer.js

@@ -0,0 +1,4 @@
+// Defer operator - eval half
+import { operator, compile } from '../../parse.js';
+
+operator('defer', a => (a = compile(a), ctx => { ctx.__deferred__ = ctx.__deferred__ || []; ctx.__deferred__.push(a); }));

package/eval/op/equality.js

@@ -0,0 +1,5 @@
+// Equality operators (base) - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/identity.js

@@ -0,0 +1,5 @@
+// Identity operators - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/increment.js

@@ -0,0 +1,13 @@
+// Increment/decrement operators - eval half
+// b=null means postfix, b=undefined means prefix
+import { operator, compile } from '../../parse.js';
+
+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) :
+  (() => { 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/eval/op/logical.js

@@ -0,0 +1,6 @@
+// Logical operators (base) - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/membership.js

@@ -0,0 +1,4 @@
+// Membership operator - eval half
+import { operator, compile } from '../../parse.js';
+
+operator('in', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) in b(ctx)));

package/eval/op/nullish.js

@@ -0,0 +1,4 @@
+// Nullish coalescing operator - eval half
+import { operator, compile } from '../../parse.js';
+
+operator('??', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) ?? b(ctx)));

package/eval/op/optional.js

@@ -0,0 +1,38 @@
+// Optional chaining operators - eval half
+import { operator, compile } from '../../parse.js';
+import { unsafe } from '../access.js';
+
+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/eval/op/pow.js

@@ -0,0 +1,8 @@
+// Exponentiation operator - eval half
+import { operator, compile } from '../../parse.js';
+import { isLval, prop } from '../access.js';
+
+const err = msg => { throw Error(msg) };
+
+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, (obj, path, ctx) => obj[path] **= b(ctx))));

package/eval/op/range.js

@@ -0,0 +1,13 @@
+// Range operators - eval half
+import { operator, compile } from '../../parse.js';
+
+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/eval/op/spread.js

@@ -0,0 +1,4 @@
+// Spread/rest operator - eval half (for arrays/objects spread)
+import { operator, compile } from '../../parse.js';
+
+operator('...', a => (a = compile(a), ctx => Object.entries(a(ctx))));