subscript 9.2.0 → 10.0.1

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,6 +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';
 
-// /**/, //
-token('/*', PREC_TOKEN, (a, prec) => (next(c => c !== STAR && cur.charCodeAt(idx + 1) !== 47), skip(),skip(), 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/control.js

@@ -1,142 +1,2 @@
-/**
- * Control flow: if/else, while, for, break, continue, return, blocks
- *
- * AST:
- *   if (c) a else b    → ['if', c, a, b?]
- *   while (c) a        → ['while', c, a]
- *   for (i;c;s) a      → ['for', i, c, s, a]
- *   { a; b }           → ['block', [';', a, b]]
- *   break/continue     → ['break'] / ['continue']
- *   return x           → ['return', x?]
- */
-import * as P from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_STATEMENT, OPAREN, CPAREN, OBRACE, CBRACE, PREC_SEQ, PREC_TOKEN } from '../src/const.js'
-
-const { token, expr, skip, space, err, parse, next } = P
-const SEMI = 59
-
-// Control signals
-class Break {}
-class Continue {}
-class Return { constructor(v) { this.value = v } }
-export const BREAK = new Break(), CONTINUE = new Continue()
-
-// Shared loop body executor
-const loop = (body, ctx) => {
-  try { return { val: body(ctx) } }
-  catch (e) {
-    if (e === BREAK) return { brk: 1 }
-    if (e === CONTINUE) return { cnt: 1 }
-    if (e instanceof Return) return { ret: 1, val: e.value }
-    throw e
-  }
-}
-
-// if (cond) body [else alt]
-token('if', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const cond = expr(0, CPAREN), body = parseBody()
-  space()
-  // check 'else' — skip 4 chars via skip() since P.idx is read-only from module
-  const alt = P.cur.substr(P.idx, 4) === 'else' && !parse.id(P.cur.charCodeAt(P.idx + 4))
-    ? (skip(), skip(), skip(), skip(), parseBody()) : undefined
-  return alt !== undefined ? ['if', cond, body, alt] : ['if', cond, body]
-})
-
-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)
-})
-
-// while (cond) body
-token('while', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  return ['while', expr(0, CPAREN), parseBody()]
-})
-
-operator('while', (cond, body) => {
-  cond = compile(cond); body = compile(body)
-  return ctx => {
-    let r, res
-    while (cond(ctx)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
-
-// for (init; cond; step) body
-token('for', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const init = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const cond = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const step = space() === CPAREN ? null : expr(PREC_SEQ)
-  space() === CPAREN ? skip() : err('Expected )')
-  return ['for', init, cond, step, parseBody()]
-})
-
-operator('for', (init, cond, step, body) => {
-  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)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
-
-// Block parsing helper - only used by control structures
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip() // consume {
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)  // prec=0 to allow nested control structures
-}
-
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx)) // new scope
-})
-
-// break / continue / return
-token('break', PREC_TOKEN, a => a ? null : ['break'])
-operator('break', () => () => { throw BREAK })
-
-token('continue', PREC_TOKEN, a => a ? null : ['continue'])
-operator('continue', () => () => { throw CONTINUE })
-
-token('return', PREC_STATEMENT, a => {
-  if (a) return
-  space()
-  const c = P.cur.charCodeAt(P.idx)
-  if (!c || c === CBRACE || c === SEMI) return ['return']
-  return ['return', expr(PREC_STATEMENT)]
-})
-
-operator('return', val => {
-  val = val !== undefined ? compile(val) : null
-  return ctx => { throw new Return(val?.(ctx)) }
-})
+// Control flow symbols (shared by loop, group, switch, try, function)
+export const BREAK = Symbol('break'), CONTINUE = Symbol('continue'), RETURN = Symbol('return');

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 './control.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,11 +1,15 @@
-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'
+import { nary, group, operator, compile } from '../parse.js';
 
-// (a,b,c), (a) — uses PREC_ACCESS to avoid conflict with ?.
-group('()', PREC_ACCESS)
-operator('()', (a, b) => b === undefined && (!a && err('Empty ()'), compile(a)))
+const STATEMENT = 5, SEQ = 10, ACCESS = 170;
 
-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)
+// (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 sequences - returns last evaluated value
+const seq = (...args) => (args = args.map(compile), ctx => { let r; for (const a of args) r = a(ctx); return r; });
+operator(',', seq);
+operator(';', seq);

package/feature/if.js

@@ -1,43 +1,28 @@
-/**
- * Conditionals: if/else
- *
- * AST:
- *   if (c) a else b    → ['if', c, a, b?]
- */
-import * as P from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_STATEMENT, OPAREN, CPAREN, OBRACE, CBRACE } from '../src/const.js'
+// 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 { token, expr, skip, space, err, parse } = P
+const STATEMENT = 5, SEMI = 59;
 
-// Block parsing helper
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip()
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)
-}
+// 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;
+};
 
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx))
-})
-
-// if (cond) body [else alt]
-token('if', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const cond = expr(0, CPAREN), body = parseBody()
-  space()
-  const alt = P.cur.substr(P.idx, 4) === 'else' && !parse.id(P.cur.charCodeAt(P.idx + 4))
-    ? (skip(), skip(), skip(), skip(), parseBody()) : undefined
-  return alt !== undefined ? ['if', cond, body, alt] : ['if', cond, body]
-})
+// 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)
-})
+  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

@@ -1,122 +1,123 @@
-/**
- * Loops: while, for, break, continue, return
- *
- * AST:
- *   while (c) a        → ['while', c, a]
- *   for (i;c;s) a      → ['for', i, c, s, a]
- *   break/continue     → ['break'] / ['continue']
- *   return x           → ['return', x?]
- */
-import * as P from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_STATEMENT, OPAREN, CPAREN, OBRACE, CBRACE, PREC_SEQ, PREC_TOKEN } from '../src/const.js'
+// 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';
+import { BREAK, CONTINUE, RETURN } from './control.js';
 
-const { token, expr, skip, space, err } = P
-const SEMI = 59
+export { BREAK, CONTINUE, RETURN };
 
-// Control signals
-class Break {}
-class Continue {}
-class Return { constructor(v) { this.value = v } }
-export const BREAK = new Break(), CONTINUE = new Continue()
-
-// Shared loop body executor
-const loop = (body, ctx) => {
-  try { return { val: body(ctx) } }
+// Loop body executor - catches control flow and returns status
+export const loop = (body, ctx) => {
+  try { return { v: body(ctx) }; }
   catch (e) {
-    if (e === BREAK) return { brk: 1 }
-    if (e === CONTINUE) return { cnt: 1 }
-    if (e instanceof Return) return { ret: 1, val: e.value }
-    throw 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;
   }
-}
+};
 
-// Block parsing helper
-const parseBody = () => {
-  if (space() === OBRACE) {
-    skip()
-    return ['block', expr(0, CBRACE)]
-  }
-  return expr(0)
-}
+const STATEMENT = 5, CBRACE = 125, SEMI = 59;
 
-operator('block', body => {
-  if (body === undefined) return () => {}
-  body = compile(body)
-  return ctx => body(Object.create(ctx))
-})
+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()];
+});
 
-// while (cond) body
-token('while', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  return ['while', expr(0, CPAREN), parseBody()]
-})
+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)
+  cond = compile(cond); body = compile(body);
   return ctx => {
-    let r, res
-    while (cond(ctx)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
+    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;
+  };
+});
 
-// for (init; cond; step) body
-token('for', PREC_STATEMENT, a => {
-  if (a) return
-  space() === OPAREN || err('Expected (')
-  skip()
-  const init = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const cond = space() === SEMI ? null : expr(PREC_SEQ)
-  space() === SEMI ? skip() : err('Expected ;')
-  const step = space() === CPAREN ? null : expr(PREC_SEQ)
-  space() === CPAREN ? skip() : err('Expected )')
-  return ['for', init, cond, step, parseBody()]
-})
-
-operator('for', (init, cond, step, body) => {
-  init = init ? compile(init) : null
-  cond = cond ? compile(cond) : () => true
-  step = step ? compile(step) : null
-  body = compile(body)
+operator('do', (body, cond) => {
+  body = compile(body); cond = compile(cond);
   return ctx => {
-    let r, res
-    for (init?.(ctx); cond(ctx); step?.(ctx)) {
-      r = loop(body, ctx)
-      if (r.brk) break
-      if (r.cnt) continue
-      if (r.ret) return r.val
-      res = r.val
-    }
-    return res
-  }
-})
+    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;
+  };
+});
 
-// break / continue / return
-token('break', PREC_TOKEN, a => a ? null : ['break'])
-operator('break', () => () => { throw BREAK })
+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);
+  }
+});
 
-token('continue', PREC_TOKEN, a => a ? null : ['continue'])
-operator('continue', () => () => { throw CONTINUE })
+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;
+  };
+};
 
-token('return', PREC_STATEMENT, a => {
-  if (a) return
-  space()
-  const c = P.cur.charCodeAt(P.idx)
-  if (!c || c === CBRACE || c === SEMI) return ['return']
-  return ['return', expr(PREC_STATEMENT)]
-})
+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('return', val => {
-  val = val !== undefined ? compile(val) : null
-  return ctx => { throw new Return(val?.(ctx)) }
-})
+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) }; }));