subscript 10.3.5 → 10.4.0

package/feature/op/range.js

@@ -1,26 +1,12 @@
 /**
- * Range operators
+ * Range operators - parse half
  *
  * .. (inclusive range): 1..5 → [1,2,3,4,5]
  * ..< (exclusive range): 1..<5 → [1,2,3,4]
- *
- * Common in: Swift, Kotlin, Rust, Ruby
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } from '../../parse.js';
 
 const COMP = 90;
 
 binary('..', COMP);
 binary('..<', COMP);
-
-// Compile
-operator('..', (a, b) => (a = compile(a), b = compile(b), ctx => {
-  const start = a(ctx), end = b(ctx), arr = [];
-  for (let i = start; i <= end; i++) arr.push(i);
-  return arr;
-}));
-operator('..<', (a, b) => (a = compile(a), b = compile(b), ctx => {
-  const start = a(ctx), end = b(ctx), arr = [];
-  for (let i = start; i < end; i++) arr.push(i);
-  return arr;
-}));

package/feature/op/spread.js

@@ -1,15 +1,10 @@
 /**
- * Spread/rest operator
+ * Spread/rest operator - parse half
  *
  * ...x → spread in arrays/calls, rest in params
- *
- * Common in: JS, TS, Python (*args), Ruby (*splat)
  */
-import { unary, operator, compile } from '../../parse.js';
+import { unary } from '../../parse.js';
 
 const PREFIX = 140;
 
 unary('...', PREFIX);
-
-// Compile (for arrays/objects spread)
-operator('...', a => (a = compile(a), ctx => Object.entries(a(ctx))));

package/feature/op/ternary.js

@@ -1,15 +1,10 @@
 /**
- * Ternary conditional operator
+ * Ternary conditional operator - parse half
  *
  * a ? b : c → conditional expression
- *
- * Common in: C, JS, Java, PHP, etc.
  */
-import { token, expr, next, operator, compile } from '../../parse.js';
+import { token, expr, next } from '../../parse.js';
 
 const ASSIGN = 20;
 
 token('?', ASSIGN, (a, b, c) => a && (b = expr(ASSIGN - 1)) && next(c => c === 58) && (c = expr(ASSIGN - 1), ['?', a, b, c]));
-
-// Compile
-operator('?', (a, b, c) => (a = compile(a), b = compile(b), c = compile(c), ctx => a(ctx) ? b(ctx) : c(ctx)));

package/feature/op/type.js

@@ -1,18 +1,12 @@
 /**
- * Type operators
+ * Type operators - parse half
  *
  * as: type cast/assertion (identity in JS)
  * is: type check (instanceof in JS)
- *
- * Common in: TypeScript, Kotlin, Swift, C#
  */
-import { binary, operator, compile } from '../../parse.js';
+import { binary } from '../../parse.js';
 
 const COMP = 90;
 
 binary('as', COMP);
 binary('is', COMP);
-
-// Compile (identity in JS)
-operator('as', (a, b) => (a = compile(a), ctx => a(ctx)));
-operator('is', (a, b) => (a = compile(a), b = compile(b), ctx => a(ctx) instanceof b(ctx)));

package/feature/op/unary.js

@@ -1,14 +1,12 @@
 /**
- * Unary keyword operators
+ * Unary keyword operators - parse half
  *
  * typeof x → type string
  * void x → undefined
  * delete x → remove property
  * new X() → construct instance
- *
- * JS-specific keywords
  */
-import { unary, keyword, operator, compile, skip, expr, word } from '../../parse.js';
+import { unary, keyword, skip, expr, word } from '../../parse.js';
 
 const PREFIX = 140;
 
@@ -19,26 +17,3 @@ unary('delete', PREFIX);
 keyword('new', PREFIX, () =>
   word('.target') ? (skip(7), ['new.target']) : ['new', expr(PREFIX)]
 );
-
-// Compile
-operator('typeof', a => (a = compile(a), ctx => typeof a(ctx)));
-operator('void', a => (a = compile(a), ctx => (a(ctx), undefined)));
-operator('delete', a => {
-  if (a[0] === '.') {
-    const obj = compile(a[1]), key = a[2];
-    return ctx => delete obj(ctx)[key];
-  }
-  if (a[0] === '[]') {
-    const obj = compile(a[1]), key = compile(a[2]);
-    return ctx => delete obj(ctx)[key(ctx)];
-  }
-  return () => true;
-});
-operator('new', (call) => {
-  const target = compile(call?.[0] === '()' ? call[1] : call);
-  const args = call?.[0] === '()' ? call[2] : null;
-  const argList = !args ? () => [] :
-    args[0] === ',' ? (a => ctx => a.map(f => f(ctx)))(args.slice(1).map(compile)) :
-    (a => ctx => [a(ctx)])(compile(args));
-  return ctx => new (target(ctx))(...argList(ctx));
-});

package/feature/prop.js

@@ -1,8 +1,8 @@
 /**
- * Minimal property access: a.b, a[b], f()
+ * Minimal property access: a.b, a[b], f() - parse half
  * For array literals, private fields, see member.js
  */
-import { access, binary, group, operator, compile } from '../parse.js';
+import { access, binary, group } from '../parse.js';
 
 const ACCESS = 170;
 
@@ -17,18 +17,3 @@ group('()', ACCESS);
 
 // a(b,c,d), a() - function calls
 access('()', ACCESS);
-
-// Compile
-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/feature/regex.js

@@ -1,18 +1,15 @@
 /**
- * Regex literals: /pattern/flags
+ * Regex literals: /pattern/flags - parse half
  *
  * AST (constructor form, JSON-serializable):
  *   /abc/gi  → ['//', 'abc', 'gi']
  *   /abc/    → ['//', 'abc']
  *
- * Note: Disambiguates from division by context:
+ * Disambiguates from division by context:
  *   - `/` after value = division (falls through to prev)
  *   - `/` at start or after operator = regex
- *
- * Compile:
- *   ['//', 'abc', 'gi']  → new RegExp('abc', 'gi')
  */
-import { token, skip, err, next, idx, cur, operator } from '../parse.js';
+import { token, skip, err, next, idx, cur } from '../parse.js';
 
 const PREFIX = 140, SLASH = 47, BSLASH = 92;
 
@@ -37,9 +34,3 @@ token('/', PREFIX, a => {
 
   return flags ? ['//', pattern, flags] : ['//', pattern];
 });
-
-// Compile: ['//', pattern, flags?] → RegExp
-operator('//', (a, b) => {
-  const re = new RegExp(a, b || '');
-  return () => re;
-});

package/feature/seq.js

@@ -1,21 +1,12 @@
 /**
- * Sequence operators (C-family)
+ * Sequence operators (C-family) - parse half
  *
  * , ; — returns last evaluated value
  */
-import { nary, operator, compile } from '../parse.js';
+import { nary } from '../parse.js';
 
 const STATEMENT = 5, SEQ = 10;
 
 // Sequences
 nary(',', SEQ);
 nary(';', STATEMENT, true);  // right-assoc to allow same-prec statements
-
-// Compile - returns last evaluated value
-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/feature/shebang.js

@@ -0,0 +1,7 @@
+// Shebang `#!...` line treated as a line comment.
+// `#!` is not valid syntax outside the shebang context (private fields require an identifier),
+// so registering it globally is safe and lets the existing comment machinery handle it.
+import './comment.js';
+import { parse } from '../parse.js';
+
+parse.comment['#!'] = '\n';

package/feature/subscript.js

@@ -0,0 +1,23 @@
+/**
+ * subscript - parse aggregator
+ * Minimal expression parser. No eval - import 'subscript/eval/subscript.js' for runtime.
+ */
+
+// Literals
+import './number.js';       // Decimal numbers: 123, 1.5, 1e3
+import './string.js';       // Double-quoted strings with escapes
+
+// Operators (C-family common set) - order matters for token chain performance
+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';            // Sequences: a, b; a; b
+import './group.js';          // Grouping: (a)
+import './access.js';         // Property access: a.b, a[b], f(), [a,b]
+
+export * from '../parse.js';

package/feature/switch.js

@@ -1,7 +1,6 @@
-// Switch/case/default
+// Switch/case/default - parse half
 // AST: ['switch', val, ['case', test, body], ['default', body], ...]
-import { expr, skip, space, keyword, parens, operator, compile, idx, err, seek, parse, lookup, word, cur } from '../parse.js';
-import { BREAK } from './loop.js';
+import { expr, skip, space, keyword, parens, idx, err, seek, lookup, word } from '../parse.js';
 
 const STATEMENT = 5, ASSIGN = 20, COLON = 58, SEMI = 59, CBRACE = 125;
 
@@ -49,28 +48,3 @@ const switchBody = () => {
 
 // switch (x) { ... }
 keyword('switch', STATEMENT + 1, () => space() === 40 && ['switch', parens(), ...switchBody()]);
-
-// Compile
-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/feature/template.js

@@ -1,8 +1,9 @@
 /**
- * Template literals: `a ${x} b` → ['`', [,'a '], 'x', [,' b']]
- * Tagged templates:  tag`...`  → ['``', 'tag', ...]
+ * Template literals - parse half
+ * `a ${x} b` → ['`', [,'a '], 'x', [,' b']]
+ * Tagged: tag`...` → ['``', 'tag', ...]
  */
-import { parse, skip, err, expr, lookup, cur, idx, operator, compile } from '../parse.js';
+import { parse, skip, err, expr, lookup, cur, idx } from '../parse.js';
 
 const ACCESS = 170, BACKTICK = 96, DOLLAR = 36, OBRACE = 123, BSLASH = 92;
 const esc = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v' };
@@ -24,16 +25,3 @@ lookup[BACKTICK] = (a, prec) =>
   a && prec < ACCESS ? (parse.asi && parse.newline ? void 0 : (skip(), ['``', a, ...parseBody()])) : // tagged
   !a ? (skip(), (p => p.length < 2 && p[0]?.[0] === undefined ? p[0] || [,''] : ['`', ...p])(parseBody())) : // plain
   prev?.(a, prec);
-
-// Compile
-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/feature/try.js

@@ -1,9 +1,7 @@
-// try/catch/finally/throw statements
+// try/catch/finally/throw statements - parse half
 // AST (faithful): ['try', body, ['catch', param, handler]?, ['finally', cleanup]?]
-// Note: body/handler are raw block results, param is raw parens result
-import { space, parse, keyword, parens, expr, word, skip, operator, compile } from '../parse.js';
+import { space, parse, keyword, parens, expr, word, skip, peek } from '../parse.js';
 import { block } from './if.js';
-import { RETURN } from './op/arrow.js';import { BREAK, CONTINUE } from './loop.js';
 
 const STATEMENT = 5;
 
@@ -13,7 +11,8 @@ keyword('try', STATEMENT + 1, () => {
   space();
   if (word('catch')) {
     skip(5); space();
-    node.push(['catch', parens(), block()]);
+    // ES2019 optional catch binding: `catch { ... }` (no parameter)
+    node.push(['catch', peek() === 40 ? parens() : null, block()]);
   }
   space();
   if (word('finally')) {
@@ -29,36 +28,3 @@ keyword('throw', STATEMENT + 1, () => {
   if (parse.newline) throw SyntaxError('Unexpected newline after throw');
   return ['throw', expr(STATEMENT)];
 });
-
-// Compile try - normalize in compiler, not parser
-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/feature/unit.js

@@ -1,5 +1,5 @@
 /**
- * Unit suffixes: 5px, 10rem, 2s, 500ms
+ * Unit suffixes - parse half: 5px, 10rem, 2s, 500ms
  *
  * AST:
  *   5px   → ['px', [,5]]
@@ -9,14 +9,11 @@
  *   import { unit } from 'subscript/feature/unit.js'
  *   unit('px', 'em', 'rem', 's', 'ms')
  */
-import { lookup, next, parse, idx, seek, operator, compile } from '../parse.js';
+import { lookup, next, parse, idx, seek } from '../parse.js';
 
-const units = {};
+export const units = {};
 
-export const unit = (...names) => names.forEach(name => {
-  units[name] = 1;
-  operator(name, val => (val = compile(val), ctx => ({ value: val(ctx), unit: name })));
-});
+export const unit = (...names) => names.forEach(name => { units[name] = 1; });
 
 // Wrap number handler to check for unit suffix
 const wrapNum = cc => {

package/feature/var.js

@@ -1,5 +1,5 @@
 /**
- * Variable declarations: let, const, var
+ * Variable declarations: let, const, var - parse half
  *
  * AST:
  *   let x = 1         → ['let', ['=', 'x', 1]]
@@ -8,55 +8,10 @@
  *   for (let x in o)  → ['for', ['in', ['let', 'x'], 'o'], body]
  *   var x             → ['var', 'x']   (acts as assignment target)
  */
-import { expr, space, keyword, operator, compile, seek, word, idx } from '../parse.js';
+import { expr, space, keyword, seek, word, idx } from '../parse.js';
 
 const STATEMENT = 5, SEQ = 10, ASSIGN = 20;
 
-// 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);
-    }
-  }
-};
-
 // let/const: expr(SEQ-1) consumes assignment, stops before comma
 // For for-in/of, return ['in/of', ['let', x], iterable] not ['let', ['in', x, it]]
 // For comma, return ['let', decl1, decl2, ...] not ['let', [',', ...]]
@@ -84,26 +39,3 @@ keyword('const', STATEMENT + 1, () => decl('const'));
 // var: just declares identifier, assignment happens separately
 // var x = 5 → ['=', ['var', 'x'], 5]
 keyword('var', STATEMENT, () => (space(), ['var', expr(ASSIGN)]));
-
-// Compile
-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/jessie.js

@@ -3,32 +3,11 @@
  *
  * Builds on justin with statements: blocks, variables, if/else,
  * loops, functions, try/catch, switch, throw.
+ *
+ * For parse-only: import { parse } from 'subscript/feature/jessie.js'
  */
-import './justin.js';
-
-// JS source compatibility
-import './feature/unicode.js';
-
-// Statement features
-import './feature/var.js';
-import './feature/function.js';
-import './feature/async.js';
-import './feature/class.js';
-import './feature/regex.js';
-
-// Control flow
-import './feature/if.js';
-import './feature/loop.js';
-import './feature/try.js';
-import './feature/switch.js';
-import './feature/statement.js';  // debugger, with, labeled statements
-
-// Module system
-import './feature/module.js';
-import './feature/accessor.js';
-
-// Automatic Semicolon Insertion
-import './feature/asi.js';
+import './feature/jessie.js';
+import './eval/jessie.js';
 
 export * from './parse.js';
 export { default } from './subscript.js';