subscript 10.3.6 → 10.4.1

package/eval/op/ternary.js

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

package/eval/op/type.js

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

@@ -0,0 +1,24 @@
+// Unary keyword operators - eval half
+import { operator, compile } from '../../parse.js';
+
+operator('typeof', a => (a = compile(a), ctx => typeof a(ctx)));
+operator('void', a => (a = compile(a), ctx => (a(ctx), undefined)));
+operator('delete', a => {
+  if (a[0] === '.') {
+    const obj = compile(a[1]), key = a[2];
+    return ctx => delete obj(ctx)[key];
+  }
+  if (a[0] === '[]') {
+    const obj = compile(a[1]), key = compile(a[2]);
+    return ctx => delete obj(ctx)[key(ctx)];
+  }
+  return () => true;
+});
+operator('new', (call) => {
+  const target = compile(call?.[0] === '()' ? call[1] : call);
+  const args = call?.[0] === '()' ? call[2] : null;
+  const argList = !args ? () => [] :
+    args[0] === ',' ? (a => ctx => a.map(f => f(ctx)))(args.slice(1).map(compile)) :
+    (a => ctx => [a(ctx)])(compile(args));
+  return ctx => new (target(ctx))(...argList(ctx));
+});

package/eval/prop.js

@@ -0,0 +1,16 @@
+// Minimal property access - eval half
+import { operator, compile } from '../parse.js';
+
+const err = msg => { throw Error(msg) };
+operator('[]', (a, b) => (b == null && err('Missing index'), a = compile(a), b = compile(b), ctx => a(ctx)[b(ctx)]));
+operator('.', (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, ctx => a(ctx)[b]));
+operator('()', (a, b) => {
+  // Group: (expr) - no second argument means grouping, not call
+  if (b === undefined) return a == null ? err('Empty ()') : compile(a);
+  // Function call: a(b,c)
+  const args = !b ? () => [] :
+    b[0] === ',' ? (b = b.slice(1).map(compile), ctx => b.map(arg => arg(ctx))) :
+    (b = compile(b), ctx => [b(ctx)]);
+  a = compile(a);
+  return ctx => a(ctx)(...args(ctx));
+});

package/eval/regex.js

@@ -0,0 +1,7 @@
+// Regex literals - eval half: ['//', pattern, flags?] → RegExp
+import { operator } from '../parse.js';
+
+operator('//', (a, b) => {
+  const re = new RegExp(a, b || '');
+  return () => re;
+});

package/eval/seq.js

@@ -0,0 +1,10 @@
+// Sequence operators - eval half: returns last evaluated value
+import { operator, compile } from '../parse.js';
+
+const seq = (...args) => (args = args.map(compile), ctx => {
+  let r;
+  for (const arg of args) r = arg(ctx);
+  return r;
+});
+operator(',', seq);
+operator(';', seq);

package/eval/subscript.js

@@ -0,0 +1,15 @@
+/**
+ * subscript - eval aggregator
+ * Runtime handlers for subscript dialect (must be paired with feature/subscript.js).
+ */
+
+import './op/assignment.js';
+import './op/logical.js';
+import './op/bitwise.js';
+import './op/comparison.js';
+import './op/equality.js';
+import './op/arithmetic.js';
+import './op/increment.js';
+
+import './seq.js';
+import './access.js';

package/eval/switch.js

@@ -0,0 +1,27 @@
+// Switch - eval half
+import { operator, compile } from '../parse.js';
+import { BREAK } from './loop.js';
+
+operator('switch', (val, ...cases) => {
+  val = compile(val);
+  if (!cases.length) return ctx => val(ctx);
+
+  cases = cases.map(c => [
+    c[0] === 'case' ? compile(c[1]) : null,
+    (c[0] === 'case' ? c[2] : c[1])?.[0] === ';'
+      ? (c[0] === 'case' ? c[2] : c[1]).slice(1).map(compile)
+      : (c[0] === 'case' ? c[2] : c[1]) ? [compile(c[0] === 'case' ? c[2] : c[1])] : []
+  ]);
+
+  return ctx => {
+    const v = val(ctx);
+    let matched = false, r;
+    for (const [test, stmts] of cases)
+      if (matched || test === null || test(ctx) === v)
+        for (matched = true, i = 0; i < stmts.length; i++)
+          try { r = stmts[i](ctx); }
+          catch (e) { if (e === BREAK) return r; throw e; }
+    var i;
+    return r;
+  };
+});

package/eval/template.js

@@ -0,0 +1,14 @@
+// Template literals - eval half
+import { operator, compile } from '../parse.js';
+
+operator('`', (...parts) => (parts = parts.map(compile), ctx => parts.map(p => p(ctx)).join('')));
+operator('``', (tag, ...parts) => {
+  tag = compile(tag);
+  const strings = [], exprs = [];
+  for (const p of parts) {
+    if (Array.isArray(p) && p[0] === undefined) strings.push(p[1]);
+    else exprs.push(compile(p));
+  }
+  const strs = Object.assign([...strings], { raw: strings });
+  return ctx => tag(ctx)(strs, ...exprs.map(e => e(ctx)));
+});

package/eval/try.js

@@ -0,0 +1,36 @@
+// try/catch/finally/throw - eval half
+import { operator, compile } from '../parse.js';
+import { RETURN } from './op/arrow.js';
+import { BREAK, CONTINUE } from './loop.js';
+
+operator('try', (tryBody, ...clauses) => {
+  tryBody = tryBody ? compile(tryBody) : null;
+
+  let catchClause = clauses.find(c => c?.[0] === 'catch');
+  let finallyClause = clauses.find(c => c?.[0] === 'finally');
+
+  const catchParam = catchClause?.[1];
+  const catchBody = catchClause?.[2] ? compile(catchClause[2]) : null;
+  const finallyBody = finallyClause?.[1] ? compile(finallyClause[1]) : null;
+
+  return ctx => {
+    let result;
+    try {
+      result = tryBody?.(ctx);
+    } catch (e) {
+      if (e === BREAK || e === CONTINUE || e === RETURN) throw e;
+      if (catchParam !== null && catchParam !== undefined && catchBody) {
+        const had = catchParam in ctx, orig = ctx[catchParam];
+        ctx[catchParam] = e;
+        try { result = catchBody(ctx); }
+        finally { had ? ctx[catchParam] = orig : delete ctx[catchParam]; }
+      } else if (!catchBody) throw e;
+    }
+    finally {
+      finallyBody?.(ctx);
+    }
+    return result;
+  };
+});
+
+operator('throw', val => (val = compile(val), ctx => { throw val(ctx); }));

package/eval/unit.js

@@ -0,0 +1,10 @@
+// Unit suffixes - eval half
+import { operator, compile } from '../parse.js';
+import { unit as parseUnit } from '../feature/unit.js';
+
+export const unit = (...names) => {
+  parseUnit(...names);
+  names.forEach(name =>
+    operator(name, val => (val = compile(val), ctx => ({ value: val(ctx), unit: name })))
+  );
+};

package/eval/var.js

@@ -0,0 +1,69 @@
+// Variable declarations: let, const, var - eval half
+import { operator, compile } from '../parse.js';
+
+// Flatten comma into array: [',', a, b, c] → [a, b, c]
+const flatten = items => items[0]?.[0] === ',' ? items[0].slice(1) : items;
+
+// Destructure value into context
+export const destructure = (pattern, value, ctx) => {
+  if (typeof pattern === 'string') { ctx[pattern] = value; return; }
+  const [op, ...raw] = pattern;
+  const items = flatten(raw);
+  if (op === '{}') {
+    const used = [];
+    for (const item of items) {
+      // Rest: {...rest}
+      if (Array.isArray(item) && item[0] === '...') {
+        const rest = {};
+        for (const k in value) if (!used.includes(k)) rest[k] = value[k];
+        ctx[item[1]] = rest;
+        break;
+      }
+      let key, binding, def;
+      // Shorthand: {x} → item is 'x'
+      // With default: {x = 1} → ['=', 'x', default]
+      // Rename: {x: y} → [':', 'x', 'y']
+      if (typeof item === 'string') { key = binding = item }
+      else if (item[0] === '=') { typeof item[1] === 'string' ? (key = binding = item[1]) : ([, key, binding] = item[1]); def = item[2] }
+      else { [, key, binding] = item }
+      used.push(key);
+      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);
+    }
+  }
+};
+
+const varOp = (...decls) => {
+  decls = decls.map(d => {
+    // Just identifier: let x
+    if (typeof d === 'string') return ctx => { ctx[d] = undefined; };
+    // Assignment: let x = 1
+    if (d[0] === '=') {
+      const [, pattern, val] = d;
+      const v = compile(val);
+      if (typeof pattern === 'string') return ctx => { ctx[pattern] = v(ctx); };
+      return ctx => destructure(pattern, v(ctx), ctx);
+    }
+    return compile(d);
+  });
+  return ctx => { for (const d of decls) d(ctx); };
+};
+operator('let', varOp);
+operator('const', varOp);
+// var just declares the variable (assignment handled by = operator)
+operator('var', name => (typeof name === 'string'
+  ? ctx => { ctx[name] = undefined; }
+  : () => {}));

package/feature/access.js

@@ -1,11 +1,8 @@
 /**
- * Property access: a.b, a[b], a(b), [1,2,3]
+ * Property access: a.b, a[b], a(b), [1,2,3] - parse half
  * For private fields (#x), see class.js
  */
-import { access, binary, operator, compile } from '../parse.js';
-
-// Block prototype chain attacks
-export const unsafe = k => k?.[0] === '_' && k[1] === '_' || k === 'constructor' || k === 'prototype';
+import { access, binary } from '../parse.js';
 
 const ACCESS = 170;
 
@@ -17,56 +14,3 @@ binary('.', ACCESS);
 
 // a(b,c,d), a()
 access('()', ACCESS);
-
-// Compile
-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/feature/accessor.js

@@ -1,14 +1,10 @@
 /**
- * Object accessor properties (getters/setters)
+ * Object accessor properties (getters/setters) - parse half
  *
- * AST:
  *   { get x() { body } }         → ['{}', ['get', 'x', body]]
  *   { set x(v) { body } }        → ['{}', ['set', 'x', 'v', body]]
  */
-import { token, expr, skip, space, next, parse, cur, idx, operator, compile } from '../parse.js';
-
-// Accessor marker for object property definitions
-export const ACC = Symbol('accessor');
+import { token, expr, skip, space, next, parse, cur, idx } from '../parse.js';
 
 const ASSIGN = 20;
 const OPAREN = 40, CPAREN = 41, OBRACE = 123, CBRACE = 125;
@@ -45,18 +41,3 @@ token('(', ASSIGN - 1, a => {
   skip();
   return [':', a, ['=>', ['()', params], expr(0, CBRACE) || null]];
 });
-
-// Compile
-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/feature/asi.js

@@ -1,32 +1,76 @@
-// ASI: newline at `;` precedence level triggers nary `;`
+// ASI: layered onto parser via hooks.
+// Parser core has no awareness of `;`, newlines, or block ends — everything
+// dialect-specific (statement separator, line-break-sensitive call/access,
+// `}` as implicit terminator) lives here.
 import { parse, prec, cur, idx, seek } from '../parse.js';
 
-// Set prec.asi before importing to customize (default: prec[';'])
+const SPACE = 32, LF = 10, SEMI = 59, BLOCK_END = 125, BRACKET = 91, PAREN = 40;
+// prec.asi customizable before importing (default: prec[';']).
 const lvl = prec.asi ?? prec[';'];
 
-const SPACE = 32, LF = 10, SEMI = 59, space = parse.space;
+// Cache pristine parse.space / parse.step on first load so re-imports REPLACE
+// (not chain) — otherwise `prec.asi=0; await import('./asi.js?v=disabled')`
+// would leave previous ASI layers active.
+const baseSpace = parse._baseSpace ??= parse.space;
+const baseStep = parse._baseStep ??= parse.step;
 
-const lineBreak = (i = idx, c) => {
+// LF immediately preceding the next non-space at i (used to detect `;\n`).
+const hasLineBreak = (i, c) => {
   while ((c = cur.charCodeAt(i)) <= SPACE) {
     if (c === LF) return true;
     i++;
   }
+  return false;
+};
+
+// True iff an LF immediately precedes idx (only whitespace between).
+// Computed on demand — robust against nested expr() calls eating the LF.
+const lineBreak = (i = idx, c) => {
+  while (i-- > 0 && (c = cur.charCodeAt(i)) <= SPACE) if (c === LF) return true;
+  return false;
 };
 
-parse.space = () => {
-  let cc;
-  while ((cc = space()) === SEMI && lineBreak(idx + 1)) {
-    seek(idx + 1);
-    parse.newline = true;
+// Override space: scan whitespace region for LFs (parse.js's space is
+// LF-agnostic), and swallow `;\n` runs into ASI machinery (avoids deep nary `;`
+// recursion on long files). parse.semi records that a hard terminator was
+// consumed, so the surrounding expression knows to terminate.
+parse.space = (cc, from) => {
+  for (;;) {
+    from = idx;
+    cc = baseSpace();
+    while (from < idx) if (cur.charCodeAt(from++) === LF) { parse.newline = true; break; }
+    if (cc === SEMI && hasLineBreak(idx + 1)) {
+      seek(idx + 1);
+      parse.newline = parse.semi = true;
+      continue;
+    }
+    return cc;
   }
-  return cc;
+};
+
+// Sub-expression boundary: clear sticky flags on entry so outer state
+// doesn't bleed into `(...)`, `[...]`, `{...}`. Top-level parse() also calls
+// this with no args.
+parse.enter = () => parse.newline = parse.semi = false;
+
+// `}` closes a block — outer context sees an implicit newline.
+parse.exit = (p, end) => { if (end === BLOCK_END) parse.newline = true; };
+
+// Wrap iteration step: bail at high prec when `;\n` consumed; fire ASI before
+// `[`/`(` on a new line; fire ASI when no operator continues across newline.
+parse.step = (a, p, cc, expr) => {
+  if (parse.semi && p >= lvl) return false;
+  if (a && (parse.semi || ((cc === BRACKET || cc === PAREN) && lineBreak()))) return asi(a, p, expr) ?? null;
+  const nl = parse.newline;
+  return baseStep(a, p, cc, expr) ?? (a && nl ? asi(a, p, expr) ?? null : null);
 };
 
 let asiDepth = 0;
 const MAX_ASI_DEPTH = 100;
 
-parse.asi = (a, p, expr, b, items) => {
+const asi = parse.asi = (a, p, expr, b, items) => {
   if (p >= lvl || asiDepth >= MAX_ASI_DEPTH) return;
+  parse.semi = false;
   // Bail if the inner expr didn't actually consume anything. Without this, a
   // lookup handler that returns a non-array sentinel (e.g. switch.js's
   // `reserve` flagging `case`/`default` inside a switch body) lets expr return

package/feature/async.js

@@ -1,5 +1,5 @@
-// Async/await/yield: async function, async arrow, await, yield expressions
-import { unary, expr, skip, space, keyword, cur, idx, word, operator, compile } from '../parse.js';
+// Async/await/yield: async function, async arrow, await, yield expressions - parse half
+import { unary, expr, skip, space, keyword, cur, idx, word } from '../parse.js';
 
 const PREFIX = 140, ASSIGN = 20;
 
@@ -30,15 +30,3 @@ keyword('async', PREFIX, () => {
   const params = expr(ASSIGN - .5);
   return params && ['async', params];
 });
-
-// Compile
-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/feature/class.js

@@ -1,10 +1,9 @@
-// Class declarations and expressions
+// Class declarations and expressions - parse half
 // class A extends B { ... }
-import { binary, unary, token, expr, space, next, parse, keyword, literal, word, operator, compile, skip, cur, idx } from '../parse.js';
+import { binary, unary, token, expr, space, next, parse, keyword, word, skip } from '../parse.js';
 import { block } from './if.js';
 
 const TOKEN = 200, PREFIX = 140, COMP = 90;
-const STATIC = Symbol('static');
 
 // static member → ['static', member]
 unary('static', PREFIX);
@@ -35,35 +34,3 @@ keyword('class', TOKEN, () => {
   }
   return ['class', name, expr(TOKEN), block()];
 });
-
-// Compile
-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/feature/collection.js

@@ -1,28 +1,17 @@
 /**
- * Collection literals: arrays and objects (Justin feature)
+ * Collection literals: arrays and objects (Justin feature) - parse half
  *
  * [a, b, c]
  * {a: 1, b: 2}
  * {a, b} (shorthand)
- *
- * 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 { group, binary, operator, compile, parse, peek } from '../parse.js';
-import { ACC } from './accessor.js';
+import { group, binary, parse, peek } from '../parse.js';
 
 const ASSIGN = 20, TOKEN = 200;
 
 // Allow {keyword: value} - prevent keyword match before colon
 parse.prop = pos => peek(pos) !== 58;
 
-// Object inner: null, string, or array starting with : , ... get set
-const isObject = a => a == null || typeof a === 'string' || [':', ',', '...', 'get', 'set'].includes(a[0]);
-
 // [a,b,c]
 group('[]', TOKEN);
 
@@ -31,33 +20,3 @@ group('{}', TOKEN);
 
 // a: b (colon operator for object properties)
 binary(':', ASSIGN - 1, true);
-
-// Compile - detect block vs object
-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/feature/function.js

@@ -1,7 +1,6 @@
-// Function declarations and expressions
-import { space, next, parse, keyword, parens, expr, operator, compile, cur, idx, skip } from '../parse.js';
+// Function declarations and expressions - parse half
+import { space, next, parse, keyword, parens, cur, idx, skip } from '../parse.js';
 import { block } from './if.js';
-import { RETURN } from './op/arrow.js';
 
 const TOKEN = 200;
 
@@ -19,39 +18,3 @@ keyword('function', TOKEN, () => {
   const node = generator ? ['function*', name, parens() || null, block()] : ['function', name, parens() || null, block()];
   return node;
 });
-
-// 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 === RETURN) return e[0]; throw e; }
-    };
-    if (name) ctx[name] = fn;
-    return fn;
-  };
-});
-
-// Generator function (parse only, no implementation)
-operator('function*', (name, params, body) => {
-  throw Error('Generator functions are not supported in evaluation');
-});

package/feature/if.js

@@ -1,5 +1,5 @@
-// If/else statement - else consumed internally
-import { parse, space, skip, expr, err, keyword, parens, word, idx, seek, operator, compile } from '../parse.js';
+// If/else statement - parse half. else consumed internally.
+import { space, skip, expr, err, keyword, parens, word, idx, seek } from '../parse.js';
 
 const STATEMENT = 5, SEMI = 59;
 
@@ -27,9 +27,3 @@ keyword('if', STATEMENT + 1, () => {
   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);
-});