subscript 10.3.6 → 10.4.0

package/feature/jessie.js

@@ -0,0 +1,32 @@
+/**
+ * jessie - parse aggregator
+ * Practical JS subset. No eval - import 'subscript/eval/jessie.js' for runtime.
+ */
+import './justin.js';
+
+// JS source compatibility
+import './unicode.js';
+
+// Statement features
+import './var.js';
+import './function.js';
+import './async.js';
+import './class.js';
+import './regex.js';
+
+// Control flow
+import './if.js';
+import './loop.js';
+import './try.js';
+import './switch.js';
+import './statement.js';  // debugger, with, labeled statements
+
+// Module system
+import './module.js';
+import './accessor.js';
+
+// Shebang line + Automatic Semicolon Insertion
+import './shebang.js';
+import './asi.js';
+
+export * from '../parse.js';

package/feature/justin.js

@@ -0,0 +1,36 @@
+/**
+ * justin - parse aggregator
+ * JSON superset expression language. No eval - import 'subscript/eval/justin.js' for runtime.
+ */
+import './subscript.js';
+import { parse } from '../parse.js';
+
+// Add single quotes
+parse.string["'"] = true;
+
+// Add hex, binary, octal prefixes
+parse.number = { '0x': 16, '0b': 2, '0o': 8 };
+
+import './comment.js';
+
+// Extended operators
+// Note: assignment (=) is in subscript, must come BEFORE identity (===)
+import './op/identity.js';         // === !==
+import './op/nullish.js';          // ??
+import './op/pow.js';              // ** **=
+import './op/membership.js';       // in (instanceof is in jessie/class.js)
+import './op/bitwise-unsigned.js'; // >>> >>>=
+import './op/assign-logical.js';   // ||= &&= ??=
+
+// JS-specific operators (ternary, arrow, spread, optional chaining, typeof/void/delete/new)
+import './literal.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';
+
+export * from '../parse.js';

package/feature/loop.js

@@ -1,10 +1,6 @@
-// Loops: while, do-while, for, for await, break, continue, return
-import { expr, skip, space, parse, word, keyword, parens, cur, idx, operator, compile, next, seek } from '../parse.js';
-import { RETURN } from './op/arrow.js';
+// Loops: while, do-while, for, for await, break, continue, return - parse half
+import { expr, skip, space, parse, word, keyword, parens, cur, idx, next, seek } from '../parse.js';
 import { body } from './if.js';
-import { destructure } from './var.js';
-
-export const BREAK = Symbol('break'), CONTINUE = Symbol('continue');
 
 const STATEMENT = 5, CBRACE = 125, SEMI = 59;
 
@@ -57,106 +53,3 @@ keyword('return', STATEMENT + 1, () => {
   const c = space();
   return !c || c === CBRACE || c === SEMI || parse.newline ? ['return'] : ['return', expr(STATEMENT)];
 });
-
-// Compile - inline try/catch, use JS break/continue directly
-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/feature/module.js

@@ -1,7 +1,6 @@
 /**
- * Import/Export with contextual 'from' operator
+ * Import/Export with contextual 'from' operator - parse half
  *
- * AST:
  *   import './x.js'              → ['import', path]
  *   import X from './x.js'       → ['import', ['from', 'X', path]]
  *   import { a, b } from './x'   → ['import', ['from', ['{}', ...], path]]
@@ -34,11 +33,3 @@ keyword('export', STATEMENT, () => (space(), ['export', expr(STATEMENT)]));
 
 // default: prefix for export default (NOT switch default: which has colon)
 keyword('default', SEQ + 1, () => space() !== 58 && (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/op/arithmetic.js

@@ -1,10 +1,10 @@
 /**
- * Arithmetic operators
+ * Arithmetic operators - parse half
  *
  * + - * / %
  * Unary: + -
  */
-import { binary, unary, operator, compile } from '../../parse.js';
+import { binary, unary } from '../../parse.js';
 
 const ADD = 110, MULT = 120, PREFIX = 140;
 
@@ -16,14 +16,3 @@ 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

@@ -1,46 +1,10 @@
 /**
- * Arrow function operator
+ * Arrow function operator - parse half
  *
  * (a, b) => expr → arrow function
- *
- * Common in: JS, TS, Java, C#, Kotlin, Scala
  */
-import { binary, operator, compile } from '../../parse.js';
-
-// RETURN: array to hold value - reused, no allocation per throw
-export const RETURN = [];
+import { binary } from '../../parse.js';
 
 const ASSIGN = 20;
 
 binary('=>', ASSIGN, true);
-
-// Compile
-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/feature/op/assign-logical.js

@@ -1,33 +1,12 @@
 /**
- * Logical/nullish assignment operators + destructuring
+ * Logical/nullish assignment operators - parse half
  *
- * ||= &&= ??= + destructuring support for let/const/var
+ * ||= &&= ??=
  */
-import { binary, operator, compile } from '../../parse.js';
-import { destructure } from '../var.js';
-import { isLval, prop } from '../access.js';
+import { binary } from '../../parse.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

@@ -1,26 +1,10 @@
 /**
- * Assignment operators (C-family)
+ * Assignment operators (C-family) - parse half
  *
  * = += -= *= /= %= |= &= ^= >>= <<=
- * Note: **= is in pow.js, >>>= ||= &&= ??= are JS-specific (in assignment-js.js)
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } 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

@@ -1,17 +1,11 @@
 /**
- * Unsigned right shift operators
+ * Unsigned right shift operators - parse half
  *
  * >>> >>>=
  */
-import { binary, operator, compile } from '../../parse.js';
-import { isLval, prop } from '../access.js';
+import { binary } from '../../parse.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

@@ -1,29 +1,17 @@
 /**
- * Bitwise operators (C-family)
+ * Bitwise operators - parse half
  *
  * | & ^ ~ >> <<
- * Note: >>> is JS-specific (in bitwise-js.js)
  */
-import { binary, unary, operator, compile } from '../../parse.js';
+import { binary, unary } 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

@@ -1,9 +1,9 @@
 /**
- * Comparison operators
+ * Comparison operators - parse half
  *
  * < > <= >=
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } from '../../parse.js';
 
 const COMP = 90;
 
@@ -11,9 +11,3 @@ 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

@@ -1,15 +1,10 @@
 /**
- * Defer operator
+ * Defer operator - parse half
  *
  * defer expr: registers cleanup to run at scope exit
- *
- * Common in: Go, Swift, Zig
  */
-import { unary, operator, compile } from '../../parse.js';
+import { unary } 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

@@ -1,16 +1,11 @@
 /**
- * Equality operators (base)
+ * Equality operators (base) - parse half
  *
  * == !=
- * For === !== see equality-strict.js
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } 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

@@ -1,15 +1,11 @@
 /**
- * Identity operators
+ * Identity operators - parse half
  *
  * === !==
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } 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

@@ -1,23 +1,11 @@
 /**
- * Increment/decrement operators
+ * Increment/decrement operators - parse half
  *
  * ++ -- (prefix and postfix)
  */
-import { token, expr, operator, compile } from '../../parse.js';
+import { token, expr } 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

@@ -1,10 +1,9 @@
 /**
- * Logical operators (base)
+ * Logical operators (base) - parse half
  *
  * ! && ||
- * For ?? see nullish.js
  */
-import { binary, unary, operator, compile } from '../../parse.js';
+import { binary, unary } from '../../parse.js';
 
 const LOR = 30, LAND = 40, PREFIX = 140;
 
@@ -13,8 +12,3 @@ 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

@@ -1,17 +1,12 @@
 /**
- * Membership operator
+ * Membership operator - parse half
  *
  * 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';
+import { binary } 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

@@ -1,13 +1,10 @@
 /**
- * Nullish coalescing operator (JS-specific)
+ * Nullish coalescing operator - parse half
  *
  * ??
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } 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

@@ -1,14 +1,11 @@
 /**
- * Optional chaining operators
+ * Optional chaining operators - parse half
  *
  * 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';
+import { token, expr, skip, space } from '../../parse.js';
 
 const ACCESS = 170;
 
@@ -23,39 +20,3 @@ token('?.', ACCESS, (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

@@ -1,19 +1,11 @@
 /**
- * Exponentiation operator
+ * Exponentiation operator - parse half
  *
  * ** **=
- *
- * ES2016+, not in classic JS/C
  */
-import { binary, operator, compile } from '../../parse.js';
-import { isLval, prop } from '../access.js';
+import { binary } from '../../parse.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))));