Make ASI more flexible

Author: dy

docs.md

@@ -163,7 +163,25 @@ jessie`
 `({})  // 120
 ```
 
+#### ASI (Automatic Semicolon Insertion)
 
+Jessie supports JS-style ASI – newlines at statement level act as semicolons:
+
+```js
+jessie('a = 1\nb = 2\na + b')({})  // 3
+```
+
+ASI precedence can be customized via `prec.asi`:
+
+```js
+import { prec } from 'subscript/parse.js'
+
+prec.asi = 0       // disable ASI (require explicit semicolons)
+prec.asi = 150     // ASI even inside expressions (newline always separates)
+delete prec.asi    // restore default (prec[';'])
+
+import 'subscript/feature/asi.js
+```
 
 
 ## Extend Parser

feature/asi.js

@@ -1,15 +1,10 @@
-/**
- * Automatic Semicolon Insertion (ASI)
- *
- * JS-style ASI: insert virtual ; when newline precedes illegal token at statement level
- */
-import { parse } from '../parse.js';
+// ASI: newline at `;` precedence level triggers nary `;`
+import { parse, prec } from '../parse.js';
 
-const STATEMENT = 5;
+// Set prec.asi before importing to customize (default: prec[';'])
+const lvl = prec.asi ?? prec[';'];
 
-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);
-};
+parse.asi = (a, p, expr, b, items) => p < lvl && (b = expr(lvl - .5)) && (
+  items = b?.[0] === ';' ? b.slice(1) : [b],
+  a?.[0] === ';' ? (a.push(...items), a) : [';', a, ...items]
+);

parse.js

@@ -47,7 +47,7 @@ export let idx, cur,
       cc !== end &&
       (newNode =
         ((fn = lookup[cc]) && fn(token, prec)) ??
-        (parse.asi && token && nl && (newNode = parse.asi(token, prec, expr))) ??
+        (token && nl && parse.asi?.(token, prec, expr)) ??
         (!token && !parse.reserved && next(parse.id))
       )
     ) token = newNode, parse.reserved = 0;
@@ -84,26 +84,29 @@ export let idx, cur,
   // operator lookup table
   lookup = [],
 
+  // precedence registry - features register, others can read/override
+  prec = {},
+
   // create operator checker/mapper
   token = (
     op,
-    prec = SPACE,
+    p = SPACE,
     map,
     c = op.charCodeAt(0),
     l = op.length,
     prev = lookup[c],
     word = op.toUpperCase() !== op,
     matched, r
-  ) => lookup[c] = (a, curPrec, curOp, from = idx) =>
+  ) => (prec[op] = p, lookup[c] = (a, curPrec, curOp, from = idx) =>
     (matched = curOp,
       (curOp ?
         op == curOp :
         (l < 2 || (op.charCodeAt(1) === cur.charCodeAt(idx + 1) && (l < 3 || cur.substr(idx, l) == op))) && (!word || !parse.id(cur.charCodeAt(idx + l))) && (matched = curOp = op)
       ) &&
-      curPrec < prec &&
+      curPrec < p &&
       (idx += l, (r = map(a)) ? loc(r, from) : (idx = from, matched = 0, word && r !== false && (parse.reserved = 1), !word && !prev && err()), r)
     ) ||
-    prev?.(a, curPrec, matched),
+    prev?.(a, curPrec, matched)),
 
   binary = (op, prec, right = false) => token(op, prec, (a, b) => a && (b = expr(prec - (right ? .5 : 0))) && [op, a, b]),
 

spec.md

@@ -181,6 +181,16 @@ Keywords are literals — they have no operator, only a value.
 Template literals contain string parts (as literals) interleaved with expression parts (as nodes).
 
 ### Statements (jessie)
+
+ASI (Automatic Semicolon Insertion) treats newlines as statement separators, producing flat `;` arrays:
+```
+a; b        → [';', 'a', 'b']
+a\nb        → [';', 'a', 'b']       (ASI inserts ;)
+a; b; c     → [';', 'a', 'b', 'c']
+a\nb\nc     → [';', 'a', 'b', 'c']  (flat, not nested)
+```
+
+Control flow:
 ```
 ['if', cond, then]            if (cond) then
 ['if', cond, then, else]      if (cond) then else alt

test/asi.js

@@ -397,13 +397,59 @@ test('jessie: ASI basic', () => {
   is(ast[2], 'b')
 })
 
+test('jessie: ASI flat arrays', () => {
+  // 2 stmts - both forms should be identical
+  is(parse('a;b'), [';', 'a', 'b'])
+  is(parse('a\nb'), [';', 'a', 'b'])
+
+  // 3 stmts - flat array, not nested
+  is(parse('a;b;c'), [';', 'a', 'b', 'c'])
+  is(parse('a\nb\nc'), [';', 'a', 'b', 'c'])
+  is(parse('a;b\nc'), [';', 'a', 'b', 'c'])
+  is(parse('a\nb;c'), [';', 'a', 'b', 'c'])
+
+  // 4 stmts - all variations flat
+  is(parse('a;b;c;d'), [';', 'a', 'b', 'c', 'd'])
+  is(parse('a\nb\nc\nd'), [';', 'a', 'b', 'c', 'd'])
+  is(parse('a;b\nc;d'), [';', 'a', 'b', 'c', 'd'])
+})
+
 test('jessie: ASI return', () => {
   const ast = parse('return\nx')
   is(ast[0], ';')
   is(ast[1][0], 'return')
   is(ast[2], 'x')
 })
 
+test('jessie: ASI custom precedence', async () => {
+  const { prec, parse } = await import('../parse.js')
+
+  // Default: ASI at statement level (prec[';'] = 5)
+  // Newline continues expression when inside higher-precedence context
+  is(parse('a + b\nc'), [';', ['+', 'a', 'b'], 'c'])
+  is(parse('a\n+ b'), ['+', 'a', 'b'], 'continuation token binds')
+
+  // Disable ASI and reimport feature fresh
+  prec.asi = 0
+  parse.asi = null
+  await import('../feature/asi.js?v=disabled')
+  let threw = false
+  try { parse('a\nb') } catch { threw = true }
+  is(threw, true, 'asi=0 disables ASI')
+
+  // High precedence: ASI triggers inside expressions
+  prec.asi = 150
+  parse.asi = null
+  await import('../feature/asi.js?v=high')
+  is(parse('a + b\nc'), ['+', 'a', [';', 'b', 'c']], 'ASI inside + rhs')
+
+  // Restore default
+  delete prec.asi
+  parse.asi = null
+  await import('../feature/asi.js?v=restore')
+  is(parse('a\nb'), [';', 'a', 'b'])
+})
+
 // === compile integration ===
 
 test('jessie: compile integration', () => {