subscript 9.2.0 → 10.0.0

package/README.md

@@ -1,97 +1,67 @@
-# sub<em>script</em> <a href="https://github.com/spectjs/subscript/actions/workflows/node.js.yml"><img src="https://github.com/spectjs/subscript/actions/workflows/node.js.yml/badge.svg"/></a> <a href="https://bundlejs.com/?q=subscript"><img alt="npm bundle size" src="https://img.shields.io/bundlejs/size/subscript"/></a> <a href="http://npmjs.org/subscript"><img src="https://img.shields.io/npm/v/subscript"/></a> <a href="http://microjs.com/#subscript"><img src="https://img.shields.io/badge/microjs-subscript-blue?color=darkslateblue"/></a>
+# sub<sub><sup> ✦ </sup></sub>script [![build](https://github.com/dy/subscript/actions/workflows/node.js.yml/badge.svg)](https://github.com/dy/subscript/actions/workflows/node.js.yml) [![npm](https://img.shields.io/npm/v/subscript)](http://npmjs.org/subscript) [![size](https://img.shields.io/bundlephobia/minzip/subscript?label=size)](https://bundlephobia.com/package/subscript) [![demo](https://img.shields.io/badge/play-%F0%9F%9A%80-white)](https://dy.github.io/subscript/) [![microjs](https://img.shields.io/badge/microjs-subscript-blue?color=darkslateblue)](http://microjs.com/#subscript)
 
-> _Subscript_ is fast, tiny & extensible parser / evaluator / microlanguage.
+> Tiny expression parser & evaluator.
 
-####  Used for:
+* **Safe** — sandboxed, blocks `__proto__`, `constructor`, no global access
+* **Fast** — Pratt parser engine, see [benchmarks](#performance)
+* **Portable** — universal expression format, any compile target
+* **Metacircular** — can parse and compile itself
+* **Extensible** — pluggable syntax for building custom DSL
 
-* expressions evaluators, calculators
-* subsets of languages
-* sandboxes, playgrounds, safe eval
-* custom DSL
-* preprocessors
-* templates
+## Usage
 
-_Subscript_ has [3.5kb](https://npmfs.com/package/subscript/7.4.3/subscript.min.js) footprint <!-- (compare to [11.4kb](https://npmfs.com/package/jsep/1.2.0/dist/jsep.min.js) _jsep_ + [4.5kb](https://npmfs.com/package/expression-eval/5.0.0/dist/expression-eval.module.js) _expression-eval_) -->, good [performance](#performance) and extensive test coverage.
+```js
+import subscript from 'subscript'
 
+let fn = subscript('a + b * 2')
+fn({ a: 1, b: 3 })  // 7
+```
 
-## Usage
+## Presets
 
-```js
-import subscript from './subscript.js'
+### subscript
 
-// parse expression
-const fn = subscript('a.b + Math.sqrt(c - 1)')
+Common expressions:
 
-// evaluate with context
-fn({ a: { b:1 }, c: 5, Math })
-// 3
+`a.b a[b] a(b) + - * / % < > <= >= == != ! && || ~ & | ^ << >> ++ -- = += -= *= /=`
+```js
+import subscript from 'subscript'
+
+subscript('a.b + c * 2')({ a: { b: 1 }, c: 3 })  // 7
 ```
 
-## Operators
-
-_Subscript_ supports [common syntax](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(syntax)) (_JavaScript_, _C_, _C++_, _Java_, _C#_, _PHP_, _Swift_, _Objective-C_, _Kotlin_, _Perl_ etc.):
-
-* `a.b`, `a[b]`, `a(b)`
-* `a++`, `a--`, `++a`, `--a`
-* `a * b`, `a / b`, `a % b`
-* `+a`, `-a`, `a + b`, `a - b`
-* `a < b`, `a <= b`, `a > b`, `a >= b`, `a == b`, `a != b`
-* `~a`, `a & b`, `a ^ b`, `a | b`, `a << b`, `a >> b`
-* `!a`, `a && b`, `a || b`
-* `a = b`, `a += b`, `a -= b`, `a *= b`, `a /= b`, `a %= b`, `a <<= b`, `a >>= b`
-* `(a, (b))`, `a; b;`
-* `"abc"`, `'abc'`
-* `0.1`, `1.2e+3`
-
-### Justin
-
-_Just-in_ is no-keywords JS subset, _JSON_ + _expressions_ (see [thread](https://github.com/endojs/Jessie/issues/66)).<br/>
-It extends _subscript_ with:
-
-+ `a === b`, `a !== b`
-+ `a ** b`, `a **= b`
-+ `a ?? b`, `a ??= b`
-+ `a ||= b`, `a &&= b`
-+ `a >>> b`, `a >>>= b`
-+ `a ? b : c`, `a?.b`
-+ `...a`
-+ `[a, b]`
-+ `{a: b}`
-+ `(a, b) => c`
-+ `// foo`, `/* bar */`
-+ `true`, `false`, `null`, `NaN`, `undefined`
-+ `a in b`
+### justin
+
+JSON + expressions + templates + arrows:
 
+`` 'str' 0x 0b === !== ** ?? >>> ?. ? : => ... [] {} ` // /**/ true false null ``
 ```js
-import justin from 'subscript/justin'
+import justin from 'subscript/justin.js'
 
-let fn = justin('{ x: 1, "y": 2+2 }["x"]')
-fn()  // 1
+justin('{ x: a?.b ?? 0, y: [1, ...rest] }')({ a: null, rest: [2, 3] })
+// { x: 0, y: [1, 2, 3] }
 ```
 
-### Control Flow
-
-For statement syntax, import `subscript/feature/control.js`:
+### jessie
 
-+ `if (c) a`, `if (c) a else b`
-+ `while (c) body`
-+ `for (init; cond; step) body`
-+ `{ a; b }` — block scope
-+ `let x`, `const x = 1`
-+ `break`, `continue`, `return x`
+JSON + expressions + statements, functions:
 
+`if else for while do let const var function class return throw try catch switch import export /regex/`
 ```js
-import subscript from 'subscript/justin'
-import 'subscript/feature/control.js'
-
-let sum = subscript(`
-  let sum = 0;
-  for (i = 0; i < 10; i += 1) sum += i;
-  sum
+import jessie from 'subscript/jessie.js'
+
+let fn = jessie(`
+  function factorial(n) {
+    if (n <= 1) return 1
+    return n * factorial(n - 1)
+  }
+  factorial(5)
 `)
-sum() // 45
+fn({})  // 120
 ```
 
+Jessie can parse and compile its own source.
+
 
 ## Parse / Compile
 
@@ -109,137 +79,113 @@ fn = compile(tree)
 fn({ a: {b: 1}, c: 2 }) // 2
 ```
 
-### Syntax Tree
+## Extension
 
-AST has simplified lispy tree structure (inspired by [frisk](https://ghub.io/frisk) / [nisp](https://github.com/ysmood/nisp)), opposed to [ESTree](https://github.com/estree/estree):
-
-* not limited to particular language (JS), can be compiled to different targets;
-* reflects execution sequence, rather than code layout;
-* has minimal overhead, directly maps to operators;
-* simplifies manual evaluation and debugging;
-* has conventional form and one-liner docs:
+```js
+import { binary, operator, compile } from 'subscript/justin.js'
+
+// add intersection operator
+binary('∩', 80)  // register parser
+operator('∩', (a, b) => (  // register compiler
+  a = compile(a), b = compile(b),
+  ctx => a(ctx).filter(x => b(ctx).includes(x))
+))
+```
 
 ```js
-import { compile } from 'subscript.js'
-
-const fn = compile(['+', ['*', 'min', [,60]], [,'sec']])
-fn({min: 5}) // min*60 + "sec" == "300sec"
-
-// node kinds
-['+', a];         // unary operator `+a`
-['+', a, b];      // binary operator `a + b`
-['+', a, b, c];   // n-ary operator `a + b + c`
-['()', a];        // group operator `(a)`
-['()', a, b];     // access operator `a(b)`
-[, 'a'];          // literal value `'a'`
-'a';              // variable (from scope)
-null|empty;       // placeholder
-
-// eg.
-['()', 'a']       // (a)
-['()', 'a', null] // a()
-['()', 'a', 'b']  // a(b)
-['++', 'a']       // ++a
-['++','a', null]  // a++
+import justin from 'subscript/justin.js'
+justin('[1,2,3] ∩ [2,3,4]')({})  // [2, 3]
 ```
 
-### Stringify
+See [docs.md](./docs.md) for full API.
+
 
-To convert tree back to code, there's codegenerator function:
+## Syntax Tree
+
+Expressions parse to a minimal JSON-compatible AST:
 
 ```js
-import { stringify } from 'subscript.js'
+import { parse } from 'subscript'
 
-stringify(['+', ['*', 'min', [,60]], [,'sec']])
-// 'min * 60 + "sec"'
+parse('a + b * 2')
+// ['+', 'a', ['*', 'b', [, 2]]]
 ```
 
-## Extending
-
-_Subscript_ provides premade language [features](./feature) and API to customize syntax:
+AST has simplified lispy tree structure (inspired by [frisk](https://ghub.io/frisk) / [nisp](https://github.com/ysmood/nisp)), opposed to [ESTree](https://github.com/estree/estree):
 
-* `unary(str, precedence, postfix=false)` − register unary operator, either prefix `⚬a` or postfix `a⚬`.
-* `binary(str, precedence, rassoc=false)` − register binary operator `a ⚬ b`, optionally right-associative.
-* `nary(str, precedence)` − register n-ary (sequence) operator like `a; b;` or `a, b`, allows missing args.
-* `group(str, precedence)` - register group, like `[a]`, `{a}`, `(a)` etc.
-* `access(str, precedence)` - register access operator, like `a[b]`, `a(b)` etc.
-* `token(str, precedence, lnode => node)` − register custom token or literal. Callback takes left-side node and returns complete expression node.
-* `operator(str, (a, b) => ctx => value)` − register evaluator for an operator. Callback takes node arguments and returns evaluator function.
+* not limited to particular language (JS), can be compiled to different targets;
+* reflects execution sequence, rather than code layout;
+* has minimal overhead, directly maps to operators;
+* simplifies manual evaluation and debugging;
+* has conventional form and one-liner docs:
 
-Longer operators should be registered after shorter ones, eg. first `|`, then `||`, then `||=`.
+Three forms:
 
 ```js
-import script, { compile, operator, unary, binary, token } from './subscript.js'
+'x'             // identifier — resolve from context
+[, value]       // literal — return as-is (empty slot = data)
+[op, ...args]   // operation — apply operator
+```
 
-// enable objects/arrays syntax
-import 'subscript/feature/array.js';
-import 'subscript/feature/object.js';
+See [spec.md](./spec.md).
 
-// add identity operators (precedence of comparison)
-binary('===', 9), binary('!==', 9)
-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)))
 
-// add nullish coalescing (precedence of logical or)
-binary('??', 3)
-operator('??', (a, b) => b && (a = compile(a), b = compile(b), ctx => a(ctx) ?? b(ctx)))
+## Safety
 
-// add JS literals
-token('undefined', 20, a => a ? err() : [, undefined])
-token('NaN', 20, a => a ? err() : [, NaN])
+Blocked by default:
+- `__proto__`, `__defineGetter__`, `__defineSetter__`
+- `constructor`, `prototype`
+- Global access (only context is visible)
+
+```js
+subscript('constructor.constructor("alert(1)")()')({})
+// undefined (blocked)
 ```
 
-See [`./feature/*`](./feature) or [`./justin.js`](./justin.js) for examples.
+## Performance
 
+```
+Parse 30k:  subscript 150ms · justin 183ms · jsep 270ms · expr-eval 480ms · jexl 1056ms
+Eval 30k:   new Function 7ms · subscript 15ms · jsep+eval 30ms · expr-eval 72ms
+```
 
+## Utils
 
-## Performance
+### Codegen
 
-Subscript shows good performance within other evaluators. Example expression:
+Convert tree back to code:
 
-```
-1 + (a * b / c % d) - 2.0 + -3e-3 * +4.4e4 / f.g[0] - i.j(+k == 1)(0)
+```js
+import { codegen } from 'subscript/util/stringify.js'
+
+codegen(['+', ['*', 'min', [,60]], [,'sec']])
+// 'min * 60 + "sec"'
 ```
 
-Parse 30k times:
+### Bundle
 
-```
-subscript: ~150 ms 🥇
-justin: ~183 ms
-jsep: ~270 ms 🥈
-jexpr: ~297 ms 🥉
-mr-parser: ~420 ms
-expr-eval: ~480 ms
-math-parser: ~570 ms
-math-expression-evaluator: ~900ms
-jexl: ~1056 ms
-mathjs: ~1200 ms
-new Function: ~1154 ms
-```
+Create custom dialect as single file:
 
-Eval 30k times:
-```
-new Function: ~7 ms 🥇
-subscript: ~15 ms 🥈
-justin: ~17 ms
-jexpr: ~23 ms 🥉
-jsep (expression-eval): ~30 ms
-math-expression-evaluator: ~50ms
-expr-eval: ~72 ms
-jexl: ~110 ms
-mathjs: ~119 ms
-mr-parser: -
-math-parser: -
+```js
+import { bundle } from 'subscript/util/bundle.js'
+
+const code = await bundle('subscript/jessie.js')
+// → self-contained ES module
 ```
 
-<!--
+
 ## Used by
 
-[prepr](https://github.com/dy/prepr), [justin](#justin), [jz](https://github.com/dy/jz), [glsl-transpiler](https://github.com/stackgl/glsl-transpiler), [piezo](https://github.com/dy/piezo)
--->
+* [jz](https://github.com/dy/jz) — JS subset → WASM compiler
+<!-- * [prepr](https://github.com/dy/prepr) -->
+<!-- * [glsl-transpiler](https://github.com/stackgl/glsl-transpiler) -->
+<!-- * [piezo](https://github.com/dy/piezo) -->
+
+
+## Refs
 
-## Alternatives
+[jsep](https://github.com/EricSmekens/jsep), [jexl](https://github.com/TomFrost/Jexl), [expr-eval](https://github.com/silentmatt/expr-eval), [math.js](https://mathjs.org/).
 
-[jexpr](https://github.com/justinfagnani/jexpr), [jsep](https://github.com/EricSmekens/jsep), [jexl](https://github.com/TomFrost/Jexl), [mozjexl](https://github.com/mozilla/mozjexl), [expr-eval](https://github.com/silentmatt/expr-eval), [expression-eval](https://github.com/donmccurdy/expression-eval), [string-math](https://github.com/devrafalko/string-math), [nerdamer](https://github.com/jiggzson/nerdamer), [math-codegen](https://github.com/mauriciopoppe/math-codegen), [math-parser](https://www.npmjs.com/package/math-parser), [math.js](https://mathjs.org/docs/expressions/parsing.html), [nx-compile](https://github.com/nx-js/compiler-util), [built-in-math-eval](https://github.com/mauriciopoppe/built-in-math-eval)
+<!-- [mozjexl](https://github.com/mozilla/mozjexl), [jexpr](https://github.com/justinfagnani/jexpr), [expression-eval](https://github.com/donmccurdy/expression-eval), [string-math](https://github.com/devrafalko/string-math), [nerdamer](https://github.com/jiggzson/nerdamer), [math-codegen](https://github.com/mauriciopoppe/math-codegen), [math-parser](https://www.npmjs.com/package/math-parser), [nx-compile](https://github.com/nx-js/compiler-util), [built-in-math-eval](https://github.com/mauriciopoppe/built-in-math-eval) -->
 
-<p align=center><a href="https://github.com/krsnzd/license/">🕉</a></p>
+<p align=center><a href="https://github.com/krsnzd/license/">ॐ</a></p>

package/feature/access.js

@@ -1,11 +1,71 @@
-import { access, binary, group, err } from '../src/parse.js'
-import { operator, compile } from '../src/compile.js'
-import { PREC_ACCESS, unsafe } from '../src/const.js'
+/**
+ * Property access: a.b, a[b], a(b), [1,2,3]
+ * 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';
+
+const ACCESS = 170;
 
 // a[b]
-access('[]', PREC_ACCESS)
-operator('[]', (a, b) => !b ? err() : (a = compile(a), b = compile(b), ctx => { const k = b(ctx); return unsafe(k) ? undefined : a(ctx)[k] }))
+access('[]', ACCESS);
 
 // a.b
-binary('.', PREC_ACCESS)
-operator('.', (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, unsafe(b) ? () => undefined : ctx => a(ctx)[b]))
+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)]);
+  return prop(a, (obj, path, ctx) => obj[path](...args(ctx)), true);
+});
+
+// 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] === '{}'
+  ));
+
+// Compile error helper
+const compileErr = msg => { throw Error(msg) };
+
+// Property accessor helper - compiles property access pattern to evaluator
+export const prop = (a, fn, generic, obj, path) => (
+  a == null ? compileErr('Empty ()') :
+  a[0] === '()' && a.length == 2 ? prop(a[1], fn, generic) :
+  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))
+);

package/feature/accessor.js

@@ -0,0 +1,49 @@
+/**
+ * Object accessor properties (getters/setters)
+ *
+ * AST:
+ *   { get x() { body } }         → ['{}', ['get', 'x', body]]
+ *   { set x(v) { body } }        → ['{}', ['set', 'x', 'v', body]]
+ */
+import { token, expr, skip, space, err, next, parse, cur, idx, operator, compile } from '../parse.js';
+
+// Accessor marker for object property definitions
+export const ACC = Symbol('accessor');
+
+const ASSIGN = 20;
+const OPAREN = 40, CPAREN = 41, OBRACE = 123, CBRACE = 125;
+
+// Shared parser for get/set — returns false if not valid accessor pattern (falls through to identifier)
+// Returns false (not undefined) to signal "fall through without setting reserved"
+const accessor = (kind) => a => {
+  if (a) return; // not prefix
+  space();
+  const name = next(parse.id);
+  if (!name) return false; // no property name = not accessor (e.g. `{ get: 1 }`)
+  space();
+  if (cur.charCodeAt(idx) !== OPAREN) return false; // not followed by ( = not accessor
+  skip();
+  const params = expr(0, CPAREN);
+  space();
+  if (cur.charCodeAt(idx) !== OBRACE) return false;
+  skip();
+  return [kind, name, params, expr(0, CBRACE)];
+};
+
+token('get', ASSIGN - 1, accessor('get'));
+token('set', ASSIGN - 1, accessor('set'));
+
+// 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

@@ -0,0 +1,15 @@
+/**
+ * Automatic Semicolon Insertion (ASI)
+ *
+ * JS-style ASI: insert virtual ; when newline precedes illegal token at statement level
+ */
+import { parse } from '../parse.js';
+
+const STATEMENT = 5;
+
+parse.asi = (token, prec, expr) => {
+  if (prec >= STATEMENT) return; // only at statement level
+  const next = expr(STATEMENT - .5);
+  if (!next) return;
+  return token?.[0] !== ';' ? [';', token, next] : (token.push(next), token);
+};

package/feature/async.js

@@ -0,0 +1,45 @@
+// Async/await/yield: async function, async arrow, await, yield expressions
+import { unary, expr, skip, space, cur, idx, word, operator, compile } from '../parse.js';
+import { keyword } from './block.js';
+
+const PREFIX = 140, ASSIGN = 20;
+
+// await expr → ['await', expr]
+unary('await', PREFIX);
+
+// yield expr → ['yield', expr]
+// yield* expr → ['yield*', expr]
+keyword('yield', PREFIX, () => {
+  space();
+  if (cur[idx] === '*') {
+    skip();
+    space();
+    return ['yield*', expr(ASSIGN)];
+  }
+  return ['yield', expr(ASSIGN)];
+});
+
+// async function name() {} → ['async', ['function', name, params, body]]
+// async () => {} → ['async', ['=>', params, body]]
+// async x => {} → ['async', ['=>', x, body]]
+keyword('async', PREFIX, () => {
+  space();
+  // async function - check for 'function' word
+  if (word('function')) return ['async', expr(PREFIX)];
+  // async arrow: async () => or async x =>
+  // Parse at assign precedence to catch => operator
+  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/block.js

@@ -0,0 +1,41 @@
+// Block parsing helpers
+import { expr, skip, space, lookup, err, parse, seek, cur, idx, parens, loc, operator, compile } from '../parse.js';
+
+const STATEMENT = 5, OBRACE = 123, CBRACE = 125;
+
+// keyword(op, prec, fn) - prefix-only word token
+// keyword('while', 6, () => ['while', parens(), body()])
+// keyword('break', 6, () => ['break'])
+// attaches .loc to array results for source mapping
+export const keyword = (op, prec, map, c = op.charCodeAt(0), l = op.length, prev = lookup[c], r) =>
+  lookup[c] = (a, curPrec, curOp, from = idx) =>
+    !a &&
+    (curOp ? op == curOp : (l < 2 || cur.substr(idx, l) == op) && (curOp = op)) &&
+    curPrec < prec &&
+    !parse.id(cur.charCodeAt(idx + l)) &&
+    (seek(idx + l), (r = map()) ? loc(r, from) : (seek(from), !prev && err()), r) ||
+    prev?.(a, curPrec, curOp);
+
+// infix(op, prec, fn) - infix word token (requires left operand)
+// infix('catch', 6, a => ['catch', a, parens(), block()])
+// infix('finally', 6, a => ['finally', a, block()])
+// attaches .loc to array results for source mapping
+export const infix = (op, prec, map, c = op.charCodeAt(0), l = op.length, prev = lookup[c], r) =>
+  lookup[c] = (a, curPrec, curOp, from = idx) =>
+    a &&
+    (curOp ? op == curOp : (l < 2 || cur.substr(idx, l) == op) && (curOp = op)) &&
+    curPrec < prec &&
+    !parse.id(cur.charCodeAt(idx + l)) &&
+    (seek(idx + l), loc(r = map(a), from), r) ||
+    prev?.(a, curPrec, curOp);
+
+// block() - parse required { body }
+export const block = () =>
+  (space() === OBRACE || err('Expected {'), skip(), expr(STATEMENT - .5, CBRACE) || null);
+
+// body() - parse { body } or single statement
+export const body = () =>
+  space() !== OBRACE ? expr(STATEMENT + .5) : (skip(), ['block', expr(STATEMENT - .5, CBRACE) || null]);
+
+// Compile
+operator('block', body => body === undefined ? () => {} : (body = compile(body), ctx => body(ctx)));

package/feature/class.js

@@ -0,0 +1,69 @@
+// Class declarations and expressions
+// class A extends B { ... }
+import { binary, unary, token, expr, space, next, parse, literal, word, operator, compile } from '../parse.js';
+import { keyword, block } from './block.js';
+
+const TOKEN = 200, PREFIX = 140, COMP = 90;
+const STATIC = Symbol('static');
+
+// super → literal
+literal('super', Symbol.for('super'));
+
+// static member → ['static', member]
+unary('static', PREFIX);
+
+// instanceof: object instanceof Constructor
+binary('instanceof', COMP);
+
+// #private fields: #x → '#x' (identifier starting with #)
+token('#', TOKEN, a => {
+  if (a) return;
+  const id = next(parse.id);
+  return id ? '#' + id : void 0;
+});
+
+// class [Name] [extends Base] { body }
+keyword('class', TOKEN, () => {
+  space();
+  let name = next(parse.id) || null;
+  // 'extends' parsed as name? → anonymous class
+  if (name === 'extends') name = null;
+  else {
+    space();
+    if (!word('extends')) return ['class', name, null, block()];
+  }
+  space();
+  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)]]));