parseman 0.58.2 → 0.59.0

package/src/table/emit-assembly.ts

@@ -142,6 +142,9 @@ export const EMITTED_PARAMS = [
   // Appended for the pass-through collapse (`run-support.ts`); old factories
   // ignore it.
   'collapseEmpty',
+  // Appended for constructor-built tree objects (`cst/plain.d.ts`): a `new` call has
+  // no allocation site, so V8 cannot pretenure them. Old factories ignore them.
+  '_SP', '_LF', '_ND', '_FC', '_BUF',
 ] as const
 
 /**
@@ -180,9 +183,9 @@ if(s!==null)return skipTriviaScanned(s,input,cur,ctx)
 if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)
 }
-function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
+function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,new _LF(value,new _SP(s,e)))}
 function _pushLeafBuf(ctx,value,s,e){
-const l={_tag:'leaf',value,span:{start:s,end:e}}
+const l=new _LF(value,new _SP(s,e))
 const b=ctx._cstBuf
 if(b.ch!==undefined)b.ch.push(l)
 else if(b.single!==undefined){b.ch=[b.single,l];b.single=undefined}
@@ -242,7 +245,7 @@ if(ctx._rootTriviaLog!==undefined&&ctx._rootTriviaLog.length!==rt)ctx._rootTrivi
 /** Printed only into assemblies that open a count-only raw buffer. */
 const NO_RAW_RUNTIME_PRELUDE = `
 function _pushLeafNoRawBuf(ctx,value,s,e){
-const l={_tag:'leaf',value,span:{start:s,end:e}}
+const l=new _LF(value,new _SP(s,e))
 const b=ctx._cstBuf
 if(b.ch!==undefined)b.ch.push(l)
 else if(b.single!==undefined){b.ch=[b.single,l];b.single=undefined}
@@ -414,7 +417,7 @@ function emitRollback(t: string, buf: boolean, rawMode: number, s: Sinks = NO_SI
  * only the first branch, a known slot keeps only the second (with the scope's own
  * scanner already bound into `skip`), and `TRI_UNKNOWN` keeps both.
  */
-function emitTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string): string {
+function emitTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string, miss?: (c: string) => string): string {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
@@ -432,7 +435,14 @@ if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
 if(EC.e>${t}s)cur=EC.e
 else{rollbackScannedTriviaAt(ctx,${t}tl,${t}stl,${t}lg,${t}slg,${t}rt,${t}srt)}`
-  if (l.tri !== TRI_UNKNOWN) return scanned
+  // A character no trivia of this slot can start opens the empty gap, which
+  // records nothing, so the term runs at `cur` with no marks around a scan.
+  if (l.tri !== TRI_UNKNOWN) return miss === undefined ? scanned : `const ${t}c=input.charCodeAt(cur)
+if(${miss(`${t}c`)}){
+${fast}
+}else{
+${scanned}
+}`
   return `if(ctx.trivia===undefined){
 ${fast}
 }else{
@@ -588,6 +598,13 @@ export function emitAssemblySource(
   extraIps: readonly number[] = [],
   staticBuild = false,
   select?: ReadonlySet<number>,
+  /**
+   * Leave the `_errors` bit of a lexical program over a scan out of the side-sink
+   * census below. A budgeted selection is priced and chosen on this lowering, so
+   * the marks that bit adds move no site in or out of a budget; the artifact is
+   * then emitted with them.
+   */
+  scanSinkNeutral = false,
 ): EmitResult {
   const { code, k, fx, disp, dsp, triviaLabelled } = t
   const swapLegal = !cfg.trackLines
@@ -733,13 +750,15 @@ export function emitAssemblySource(
   // that otherwise matched byte for byte.
   //
   // Any future row whose child is not an offset in `code` belongs here for the
-  // same reason. `OP_LIVE` is the other such row, and it is unemittable.
+  // same reason. `OP_LIVE` is the other such row, and it is unemittable. An
+  // `OP_LEX_PROGRAM` over a scan (`t.lexPrograms[id].scan`, a whole `balanced()`
+  // lowered as one recognizer) runs that same interpreted scan, so it is one too.
   const sinkSites = reachable
   const sinkBits = new Map<number, number>()
   for (const ip of sinkSites) {
     const op = code[ip]
     sinkBits.set(ip,
-      op === OP_SCAN ? 3
+      op === OP_SCAN || (!scanSinkNeutral && op === OP_LEX_PROGRAM && t.lexPrograms[code[ip + 1]!]!.scan !== undefined) ? 3
         : (op === OP_FIELD ? 1 : 0)
           | (op === OP_EXPECT || (REC && (op === OP_REP || op === OP_REPV)) ? 2 : 0))
   }
@@ -974,6 +993,19 @@ return 1
     return `if(${gateMissTest(child)}){${miss}}\n`
   }
 
+  /**
+   * The test that no trivia of slot `ki` can start at the code unit `c`: the
+   * slot's first characters, as code points, decide every code unit below the
+   * surrogates; a surrogate, or `NaN` past the end of input, is left to the scan.
+   * `undefined` where the first set is unbounded or too wide to print.
+   */
+  function triviaMiss(ki: number): ((c: string) => string) | undefined {
+    const leads = triviaLeadRanges(ki, t.trivia)
+    if (leads === undefined || leads.length > 16) return undefined
+    if (leads.length === 0) return c => `${c}<55296`
+    return c => `${c}<55296&&!(${leads.map(r => r.lo === r.hi ? `${c}===${r.lo}` : `(${c}>=${r.lo}&&${c}<=${r.hi})`).join('||')})`
+  }
+
   function skipFor(l: SiteLabel): string {
     if (l.tri < 0) return '_skipTrivia'
     const ki = l.tri
@@ -991,11 +1023,16 @@ return 1
     if (!hasScan) {
       // No installed scanner: the labelled/`trackLines` path, which records
       // through `scanTrivia`. `needsDeferredTriviaCommit` is implied by an open
-      // buffer, so an in-node site skips the call that asks.
+      // buffer, so an in-node site skips the call that asks. A character no gap
+      // can start answers first, with no call (`triviaMiss`).
+      const miss = triviaMiss(ki)
+      const pre = miss === undefined ? '' : `const c=input.charCodeAt(cur)
+if(${miss('c')})return cur
+`
       skipDefs.push(l.buf
-        ? `function ${nm}(input,cur,ctx){return skipDeferredTrivia(input,cur,ctx)}`
+        ? `function ${nm}(input,cur,ctx){${pre === '' ? '' : `\n${pre}`}return skipDeferredTrivia(input,cur,ctx)}`
         : `function ${nm}(input,cur,ctx){
-if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
+${pre}if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)}`)
       return nm
     }
@@ -1397,7 +1434,7 @@ try{return ${child}(input,pos,ctx)}finally{ctx.state=saved}
         return `${head}
 const v=${child}(input,pos,ctx)
 if(v===FAIL)return FAIL
-return ${fn}(v,{start:pos,end:EC.e})
+return ${fn}(v,new _SP(pos,EC.e))
 }`
       }
 
@@ -1427,7 +1464,7 @@ return v
 const v=${child}(input,pos,ctx)
 if(v===FAIL)return FAIL
 const f=ctx._fields
-if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
+if(f!==undefined)f.push(new _FC(${name},v,new _SP(pos,EC.e)))
 return v
 }`
         }
@@ -1463,7 +1500,7 @@ return v
         return `${head}
 const v=${child}(input,pos,ctx)
 if(v!==FAIL)return v
-const err={_tag:'parseError',span:${prog.lines === 1 ? 'spanLines(ctx,pos,pos)' : '{start:pos,end:pos}'},expected:${xf}}
+const err={_tag:'parseError',span:${prog.lines === 1 ? 'spanLines(ctx,pos,pos)' : 'new _SP(pos,pos)'},expected:${xf}}
 const es=ctx._errors
 if(es!==undefined)es.push(err)
 ${REC ? 'if(ctx._tolerant===true)captureError(ctx,err)\n' : ''}ctx._fc=false
@@ -1478,7 +1515,7 @@ return err
         // The SPAN is the routed item's own object, not a copy — `assemble.ts`
         // hands the same one to the leaf, and a fresh `{start,end}` here would
         // be a different tree for any consumer comparing by identity.
-        const push = `pushCstLeaf(ctx,{_tag:'leaf',value:it.value,span:it.span})`
+        const push = `pushCstLeaf(ctx,new _LF(it.value,it.span))`
         return `${head}
 const it=ctx._routed
 if(it===undefined||pos!==it.span.start){
@@ -1587,8 +1624,8 @@ ctx._triviaLog=sOtl
 }
 if(v===FAIL)return FAIL
 const e=EC.e
-const out=${isToken ? 'input.slice(pos,e)' : `${fn}(v,{start:pos,end:e})`}
-if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:${capturesSource ? 'input.slice(pos,e)' : 'out'},span:{start:pos,end:e}})
+const out=${isToken ? 'input.slice(pos,e)' : `${fn}(v,new _SP(pos,e))`}
+if(wasCap)pushCstLeaf(ctx,new _LF(${capturesSource ? 'input.slice(pos,e)' : 'out'},new _SP(pos,e)))
 EC.e=e
 return out
 }`
@@ -1613,7 +1650,7 @@ ${hasSuffix && (lineFlags & 2) !== 0 ? 'if(sm)_trackLines(ctx,input,e)' : ''}
 ${hasSuffix ? `if(!sm){ctx._fe=e;ctx._fx=${suffixExpected};if(ctx._probe!==undefined)failAt(ctx,${suffixExpected},e)}` : ''}
 const v=${pending ? 'tp?_pfTokValue:' : ''}input.slice(pos,e)
 ${pending ? 'if(tp){_pfTokBody=-1;_pfTokValue=undefined}' : ''}
-if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,new _LF(v,new _SP(pos,e)))
 EC.e=e
 return v
 }`
@@ -1653,7 +1690,7 @@ ctx._rootTriviaLog=sRtl
 }
 if(e<0)return FAIL
 const v=input.slice(pos,e)
-if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+if(wasCap)pushCstLeaf(ctx,new _LF(v,new _SP(pos,e)))
 EC.e=e
 return v
 }`
@@ -1661,7 +1698,7 @@ return v
 const e=${run}(input,pos,ctx)
 if(e<0)return FAIL
 const v=input.slice(pos,e)
-if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,new _LF(v,new _SP(pos,e)))
 EC.e=e
 return v
 }`
@@ -1803,7 +1840,7 @@ return v
         const close = (): string => REC ? `${parts.join('\n')}\n}finally{ctx._sync=${sy}}\n}` : `${parts.join('\n')}\n}`
         if (n === 1) {
           parts.push(fused
-            ? projection === 0 ? 'return v0' : `return ${fn}([v0],{start:pos,end:EC.e})`
+            ? projection === 0 ? 'return v0' : `return ${fn}([v0],new _SP(pos,EC.e))`
             : wantValues ? 'return [v0]' : 'return undefined')
           return close()
         }
@@ -1830,13 +1867,13 @@ return v
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]!})` : kids[i]!
             parts.push(holdsGap(code, k, base, n, i, nullable)
               ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L))
-              : emitTerm(callee, vn, tmp(), L, skipFor(L)))
+              : emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : undefined))
           }
           names.push(vn)
         }
         parts.push('EC.e=cur')
         parts.push(fused
-          ? projection >= 0 ? `return ${names[projection]}` : `return ${fn}([${names.join(',')}],{start:pos,end:cur})`
+          ? projection >= 0 ? `return ${names[projection]}` : `return ${fn}([${names.join(',')}],new _SP(pos,cur))`
           : wantValues ? `return [${names.join(',')}]` : 'return undefined')
         return close()
       }
@@ -2176,7 +2213,7 @@ return FAIL
         const routedCall = (target: string): string => `{const savedRouted=ctx._routed
 ${emitRollback(m1, L.buf, L.raw, sinks)}
 ${emitMark(m2, L.buf, L.raw, sinks, false)}
-ctx._routed={value:key,span:{start:pos,end:selEnd}}
+ctx._routed={value:key,span:new _SP(pos,selEnd)}
 try{v=${target}(input,pos,ctx)}finally{ctx._routed=savedRouted}
 break}`
         const plainCall = (target: string): string => `v=${target}(input,selEnd,ctx);break`
@@ -2445,8 +2482,8 @@ return out
 const end=${recognize}(input,pos)
 if(end<0){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 const value=${value}
-const leaf={_tag:'leaf',value,span:{start:pos,end}}
-const kids=[leaf],rawKids=[leaf],span={start:pos,end}
+const leaf=new _LF(value,new _SP(pos,end))
+const kids=[leaf],rawKids=[leaf],span=new _SP(pos,end)
 EC.e=end
 const nd=${build}(kids,undefined,span,rawKids,EMPTY_TL,undefined)
 ${L.buf && L.raw === RAW_OMIT
@@ -2574,8 +2611,8 @@ ctx.captureTrivia=sCap
 if(v===FAIL)return FAIL
 const end=EC.e
 ${collapseChildren
-    ? `const nd=captured.length===1?captured[0]:${build}(captured,undefined,{start:pos,end},EMPTY_CH,EMPTY_TL,undefined)`
-    : `const nd=${build}(captured,${fields ? 'fieldMap' : 'undefined'},{start:pos,end},EMPTY_CH,EMPTY_TL,undefined)`}
+    ? `const nd=captured.length===1?captured[0]:${build}(captured,undefined,new _SP(pos,end),EMPTY_CH,EMPTY_TL,undefined)`
+    : `const nd=${build}(captured,${fields ? 'fieldMap' : 'undefined'},new _SP(pos,end),EMPTY_CH,EMPTY_TL,undefined)`}
 ${publish}
 EC.e=end
 return nd
@@ -2605,26 +2642,26 @@ return nd
           const direct = `${build}(kids,fieldMap,span,rawKids,${captureWide ? 'tlog' : 'EMPTY_TL'},st)`
           value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:${direct}` : `nd=${direct}`
         } else {
-          value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):{_tag:'node',type:${ty},span,state:st??null,children:kids}`
+          value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):new _ND(${ty},span,st??null,kids===EMPTY_CH?kids:[...kids])`
         }
         // HOST COLLAPSE applies wherever the node's VALUE comes from the host —
         // any node under a CST host, not only the builder-less ones.
         const collapsible = keepChildren && (hostCst || (build === undefined && proj < 0))
         const openCapture = omitsRaw
-          ? `const buf={noRaw:true,rawLen:0}
+          ? `const buf=new _BUF(undefined,true,0)
 ctx._cstBuf=buf
 ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
 ctx._cstRawChildren=undefined
 ctx._cstTriviaLog=undefined`
           : keepChildren
-          ? `const buf={}
+          ? `const buf=new _BUF(undefined,undefined,0)
 ctx._cstBuf=buf
 ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
 ctx._cstRawChildren=undefined
 ctx._cstTriviaLog=undefined`
-          : `const buf={rawOnly:true}
+          : `const buf=new _BUF(true,undefined,0)
 ctx._cstBuf=buf
 ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
@@ -2667,7 +2704,7 @@ ctx._cstTriviaLog=sTl
 ctx.captureTrivia=sCap
 if(v===FAIL)return FAIL
 const end=EC.e
-const span=${tracked ? 'spanLines(ctx,pos,end)' : '{start:pos,end}'}
+const span=${tracked ? 'spanLines(ctx,pos,end)' : 'new _SP(pos,end)'}
 const st=${readsState ? 'ctx.state' : 'undefined'}
 let nd
 ${unwrap ? 'if(kids.length===1)nd=unwrapChild(kids[0])\nelse ' : ''}${collapse ? 'if(kids.length===1)nd=kids[0]\nelse ' : ''}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]

package/src/table/emit.ts

@@ -3,6 +3,14 @@ import type { FoldedProgram, TableProgram } from './program.ts'
 import { resolveTable } from './program.ts'
 import { EMITTED_PARAMS, Unemittable, emitAssemblySource } from './emit-assembly.ts'
 import { cfgKey, type RunCfg } from './assemble.ts'
+import { PARSEMAN_VERSION } from '../version.ts'
+
+/**
+ * Opens every printed assembly factory. A runtime older than the printer passes fewer
+ * helpers; refuse it when the assembly is built, instead of failing partway through the
+ * first parse on whichever helper is reached first. Runs once per assembly.
+ */
+export const FACTORY_ARITY_GUARD = `if(arguments.length<${EMITTED_PARAMS.length})throw new Error(${JSON.stringify(`parseman: this parser was printed by parseman ${PARSEMAN_VERSION}; upgrade the parseman runtime to at least that version`)});`
 
 /**
  * Print a program as the module a build emits.
@@ -221,7 +229,7 @@ function emitAssemblies(prog: TableProgram, cfgs: readonly AssemblyCfg[]): strin
     const plan = em.plan
     out.push('{'
       + `key:${key},`
-      + `factory:function(${EMITTED_PARAMS.join(',')}){${em.source}\n},`
+      + `factory:function(${EMITTED_PARAMS.join(',')}){${FACTORY_ARITY_GUARD}${em.source}\n},`
       + 'plan:{'
       + `classes:[${plan.classes.map(r => `[${r.join(',')}]`).join(',')}],`
       + `armExpected:[${plan.armExpected.map(r => `[${r.join(',')}]`).join(',')}],`

package/src/table/encode-baseline.ts

@@ -1,5 +1,6 @@
 import type { Combinator, FirstSet, ParserDef } from '../types.ts'
 import { firstSetOf, matchesEmpty } from '../combinators/first-set.ts'
+import { leadRanges } from '../lead-ranges.ts'
 import { deriveExpected } from '../combinators/expect.ts'
 import { buildReadsState, buildReadsTrivia } from '../compiler/build-arity.ts'
 import {
@@ -34,7 +35,7 @@ function disjointSets(sets: readonly FirstSet[]): boolean {
   const seen: Array<{ lo: number; hi: number }> = []
   for (const fs of sets) {
     if (fs.kind !== 'ranges' || fs.ranges.length === 0) return false
-    for (const r of fs.ranges) {
+    for (const r of leadRanges(fs.ranges)) {
       for (const p of seen) if (r.lo <= p.hi && p.lo <= r.hi) return false
       seen.push(r)
     }

package/src/table/program.ts

@@ -2,6 +2,7 @@ import type { Combinator, ParseContext, ParseResult } from '../types.ts'
 import { classifiedTrivia, trivia as triviaOf } from '../combinators/map.ts'
 import { fastTriviaScanner, type FastTriviaScanner } from '../combinators/trivia-skip.ts'
 import { regex } from '../combinators/regex.ts'
+import { leadRanges } from '../lead-ranges.ts'
 import { choice } from '../combinators/choice.ts'
 import { many } from '../combinators/repeat.ts'
 import type { EmittedFactory, PoolPlan } from './emit-assembly.ts'
@@ -642,7 +643,7 @@ export function decodeClassSpec(spec: string): Array<{ lo: number; hi: number }>
 export function resolveClass(spec: string): ResolvedClass {
   const ascii = new Uint8Array(128)
   const hi: number[] = []
-  for (const { lo, hi: up } of decodeClassSpec(spec)) {
+  for (const { lo, hi: up } of leadRanges(decodeClassSpec(spec))) {
     if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1
     if (up >= 128) hi.push(Math.max(lo, 128), up)
   }

package/src/table/run-support.ts

@@ -14,6 +14,7 @@
  */
 import type { ParseContext } from '../types.ts'
 import { popCstChild, pushCstChild } from '../cst/capture-buffer.ts'
+import { PlainLeaf, PlainLineSpan, PlainSpan } from '../cst/plain.js'
 
 export type Span = { start: number; end: number }
 export type LineSpan = Span & {
@@ -37,7 +38,7 @@ export function lineCol(ctx: ParseContext, offset: number): [number, number] {
 
 export function spanLines(ctx: ParseContext, start: number, end: number): LineSpan {
   const s = lineCol(ctx, start), e = lineCol(ctx, end)
-  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] }
+  return new PlainLineSpan(start, end, s[0], s[1], e[0], e[1])
 }
 
 /**
@@ -51,11 +52,7 @@ export function rawEntry(v: unknown, input: string, s: number, e: number): unkno
     const tg = (v as { _tag?: string })._tag
     if (tg === 'node' || tg === 'leaf' || tg === 'parseError') return v
   }
-  return {
-    _tag: 'leaf',
-    value: typeof v === 'string' ? v : (typeof v === 'object' && v !== null ? input.slice(s, e) : ''),
-    span: { start: s, end: e },
-  }
+  return new PlainLeaf(typeof v === 'string' ? v : (typeof v === 'object' && v !== null ? input.slice(s, e) : ''), new PlainSpan(s, e))
 }
 
 /** `input`'s code point at `pos`, or −1 at EOF. Surrogate-pair aware. */
@@ -95,7 +92,7 @@ export function collapseEmpty(
   // A frame keeps the raw entry of the child it does not count, for a reducer
   // that reads `rawChildren`.
   const raw = readsRaw ? [rawEntry(undefined, input, pos, end)] : EMPTY_KIDS
-  const nd = build(EMPTY_KIDS, undefined, { start: pos, end }, raw, EMPTY_TRIVIA, undefined)
+  const nd = build(EMPTY_KIDS, undefined, new PlainSpan(pos, end), raw, EMPTY_TRIVIA, undefined)
   if (collected) pushCstChild(ctx, nd, ctx._cstBuf?.noRaw === true ? undefined : rawEntry(nd, input, pos, end))
   return nd
 }

package/src/table/scan-shapes.ts

@@ -235,6 +235,9 @@ function parseSeqParts(source: string): SeqPart[] | null {
       let cp: number
       if (uni) { cp = uni.cp; i = uni.next }
       else if (e === undefined) return null
+      // A digit escape is a backreference or a legacy octal escape (`\012`); only a
+      // lone `\0` is NUL.
+      else if (e >= '0' && e <= '9' && (e !== '0' || (source[i + 2] !== undefined && source[i + 2]! >= '0' && source[i + 2]! <= '9'))) return null
       else if (e in CLASS_ESCAPES) { cp = CLASS_ESCAPES[e]!; i += 2 }
       else if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z')) return null
       else { cp = e.codePointAt(0)!; i += 2 }
@@ -1078,11 +1081,11 @@ function parseScanShapeCore(source: string): ScanShape | null {
 /**
  * Flag-aware wrapper around `parseScanShape`. Lowering to a raw code-point scan
  * assumes default regex semantics, so any flag that changes matching (`i` case
- * folding, `u` surrogate handling, `m`/`s` anchor/dot behavior) disables it.
+ * folding, `u`/`v` code points and sets, `m`/`s` anchor/dot behavior) disables it.
  * `g`/`y` are stickiness-only and safe.
  */
 export function scanShapeFromRegex(source: string, flags: string): ScanShape | null {
-  if (/[msu]/.test(flags)) return null
+  if (/[msuv]/.test(flags)) return null
   if (/i/.test(flags)) return caseFoldShape(source)
   return parseScanShape(source)
 }

package/src/table/site-labels.ts

@@ -65,6 +65,7 @@ import {
   OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
 import { childSlots } from './child-slots.ts'
+import { leadRanges } from '../lead-ranges.ts'
 
 /** No scope on this path installs a known trivia — the lattice's top element. */
 export const TRI_UNKNOWN = -2
@@ -380,5 +381,5 @@ export function triviaLeadRanges(
   const fs = trivia[tri]?._meta.firstSet
   if (fs === undefined) return undefined
   if (fs.kind === 'empty') return []
-  return fs.kind === 'ranges' && fs.ranges !== undefined ? fs.ranges : undefined
+  return fs.kind === 'ranges' && fs.ranges !== undefined ? leadRanges(fs.ranges) : undefined
 }

package/src/table/trivia-gap.ts

@@ -48,6 +48,25 @@ export function skipDeferredTrivia(input: string, cur: number, ctx: ParseContext
   return scan
 }
 
+/**
+ * THE CHARACTERS A TRIVIA CAN START WITH, as a table over ASCII: `1` where a run
+ * may start, `0` where none can. `null` when the trivia's first set is unbounded.
+ *
+ * A gap at a character outside the table is the empty gap. It consumes nothing
+ * and records nothing in any sink (trivia log, root log, capture buffer, line
+ * table), so a skip there can answer `cur` without scanning. A character at or
+ * above 128, or past the end of input, is not decided by the table.
+ */
+export function triviaLeadTable(triviaP: Combinator<unknown>): Uint8Array | null {
+  const fs = triviaP._meta.firstSet
+  if (fs.kind === 'any') return null
+  const table = new Uint8Array(128)
+  if (fs.kind === 'ranges') {
+    for (const r of fs.ranges) for (let c = Math.max(0, r.lo); c <= Math.min(127, r.hi); c++) table[c] = 1
+  }
+  return table
+}
+
 /** The end of the run at `cur` when nothing root-selected lies in it, else −1. */
 function clearRunEnd(input: string, cur: number, ctx: ParseContext, triviaP: Combinator<unknown> | undefined, plain: boolean): number {
   const rootKinds = ctx._rootTriviaKindIndex

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.58.2'
+export const PARSEMAN_VERSION = '0.59.0'