@tabnas/parser 0.8.1 → 0.8.3

package/dist/defaults.js

@@ -260,6 +260,9 @@ Unexpected end of source.`,
         // Empty string is allowed and returns undefined
         empty: true,
         emptyResult: undefined,
+        // Negotiated lexing off: grammars written for a tokenising lexer
+        // never need it. Scannerless front-ends (GBNF) opt in.
+        relex: false,
     },
     // Parser
     parse: {

package/dist/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"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"}

package/dist/lexer.d.ts

@@ -76,7 +76,18 @@ declare class Lex {
     pnt: Point;
     fwd: string;
     fwdSI: number;
+    want: Tin[] | null;
+    relexUndo: {
+        sI: number;
+        rI: number;
+        cI: number;
+        token: Token[];
+        end: Token | undefined;
+    };
     refwd(): string;
+    relex(from: Token, want: Tin[], rule: Rule): Token | undefined;
+    unrelex(sI: number, rI: number, cI: number, token: Token[], end: Token | undefined): void;
+    speculate(mat: LexMatcher, rule: Rule, tI?: number): Token | undefined;
     constructor(ctx: Context);
     token(ref: Tin | string, val: any, src: string | undefined, pnt?: Point, use?: any, why?: string, len?: number): Token;
     next(rule: Rule, alt?: NormAltSpec, altI?: number, tI?: number): Token;

package/dist/lexer.js

@@ -396,7 +396,14 @@ let makeFixedMatcher = (cfg, _opts) => {
         const cands = cc < 256 ? table[cc] : wide;
         if (undefined === cands)
             return undefined;
+        // Negotiated lexing: only candidates the requesting alternate wants
+        // may match. Longest-match-wins still holds among those, so a
+        // shorter wanted token can win over a longer unwanted one — which
+        // is the point: the alternate knows which cut it needs.
+        const want = lex.want;
         for (const cand of cands) {
+            if (null != want && !want.includes(cand.tin))
+                continue;
             // Single-char Latin-1 candidates already matched via the table
             // index; longer (or wide-char) candidates verify in place.
             if ((1 === cand.len && cc < 256) || src.startsWith(cand.src, pnt.sI)) {
@@ -428,30 +435,35 @@ let makeMatchMatcher = (cfg, _opts) => {
         // remainder string, so materialize it (memoized per position).
         let fwd = lex.refwd();
         let oc = 'o' === rule.state ? 0 : 1;
-        for (let valueMatcher of valueMatchers) {
-            if (valueMatcher.match instanceof RegExp) {
-                // TODO: only match VL if present in rule
-                let m = fwd.match(valueMatcher.match);
-                if (m) {
-                    let msrc = m[0];
-                    let mlen = msrc.length;
-                    if (0 < mlen) {
-                        let tkn = undefined;
-                        let val = valueMatcher.val ? valueMatcher.val(m) : msrc;
-                        tkn = lex.token('#VL', val, msrc, pnt);
-                        pnt.sI += mlen;
-                        pnt.cI += mlen;
-                        return tkn;
+        // Under a negotiated-lexing constraint, value matchers are skipped
+        // outright: they produce value tokens (#VL) by content, not by the
+        // requesting alternate's tin list, so they cannot serve a want.
+        const want = lex.want;
+        if (null == want)
+            for (let valueMatcher of valueMatchers) {
+                if (valueMatcher.match instanceof RegExp) {
+                    // TODO: only match VL if present in rule
+                    let m = fwd.match(valueMatcher.match);
+                    if (m) {
+                        let msrc = m[0];
+                        let mlen = msrc.length;
+                        if (0 < mlen) {
+                            let tkn = undefined;
+                            let val = valueMatcher.val ? valueMatcher.val(m) : msrc;
+                            tkn = lex.token('#VL', val, msrc, pnt);
+                            pnt.sI += mlen;
+                            pnt.cI += mlen;
+                            return tkn;
+                        }
                     }
                 }
-            }
-            else {
-                let tkn = valueMatcher.match(lex, rule);
-                if (null != tkn) {
-                    return tkn;
+                else {
+                    let tkn = valueMatcher.match(lex, rule);
+                    if (null != tkn) {
+                        return tkn;
+                    }
                 }
             }
-        }
         for (let tokenMatcher of tokenMatchers) {
             // Only match Token if present in Rule sequence.
             // Exception: an `eager$` flag on the matcher opts out of
@@ -462,7 +474,15 @@ let makeMatchMatcher = (cfg, _opts) => {
             // literal's own tin even when the current rule's tcol is
             // narrower, so the next rule up the stack can see the token
             // as its proper type rather than falling through to #TX.
-            if (tokenMatcher.tin$ &&
+            if (null != want) {
+                // Negotiated lexing: the alternate's own tin list replaces tcol
+                // gating — only matchers able to produce a wanted tin run.
+                if (!tokenMatcher.tin$ ||
+                    !want.includes(tokenMatcher.tin$)) {
+                    continue;
+                }
+            }
+            else if (tokenMatcher.tin$ &&
                 !tokenMatcher.eager$ &&
                 !rule.spec.def.tcol[oc][tI].includes(tokenMatcher.tin$)) {
                 continue;
@@ -819,29 +839,58 @@ let makeNumberMatcher = (cfg, _opts) => {
     let mcfg = cfg.number;
     // Sticky ('y') so the regex runs against the full source at an offset
     // (ender.lastIndex = pnt.sI) instead of an allocated remainder slice.
-    let ender = (0, utility_1.regexp)('y', [
-        '([-+]?(0(',
-        [
-            mcfg.hex ? 'x[0-9a-fA-F_]+' : null,
-            mcfg.oct ? 'o[0-7_]+' : null,
-            mcfg.bin ? 'b[01_]+' : null,
-        ]
-            .filter((s) => null != s)
-            .join('|'),
-        // ')|[.0-9]+([0-9_]*[0-9])?)',
-        ')|\\.?[0-9]+([0-9_]*[0-9])?)',
-        // Fraction: a bare trailing dot is fine, but when fraction digits
-        // are present the run must START with a digit, as the integer and
-        // exponent runs already require. The previous `\.[0-9]?(...)` made
-        // the leading digit optional, so a separator could open the run
-        // and `1._5` parsed as 1.5 while `1_5.` style boundary-separator
-        // forms fell to text — separators are legal only BETWEEN digits.
-        // (?: keeps the capture count: tsrc is read from m[9] below.)
-        '(\\.(?:[0-9]([0-9_]*[0-9])?)?)?',
-        '([eE][-+]?[0-9]+([0-9_]*[0-9])?)?',
+    // A base-prefixed run (0x…, 0o…, 0b…) is a COMPLETE integer: no fraction
+    // and no exponent may attach to it. Only the decimal alternative carries
+    // that tail.
+    //
+    // Both groups used to sit outside the alternation, so they attached to
+    // base-prefixed runs too. `0xFF.5` then produced msrc `0xFF.5`, which
+    // coerces to NaN, so the matcher declined the whole span and the lenient
+    // text matcher took `0xFF` as #TX — while Go, whose base-prefix branch has
+    // no tail at all, read #NR("0xFF") and left `.5` to following matchers.
+    //
+    // The follow character decided whether that was visible: `0xFF.a` agreed
+    // by accident, because `.a` cannot open a fraction, so the regex
+    // backtracked to `0xFF` and `.` served as the ender. Any test probing only
+    // `0xFF.x` or `0xFF.5x` passes against the broken code — see the parity
+    // fixtures, which deliberately carry both a diverging and an agreeing
+    // follow character for each of 0x/0o/0b.
+    //
+    // Fraction digits, when present, must START with a digit, as the integer
+    // and exponent runs already require: an earlier `\.[0-9]?(...)` let a
+    // separator open the run, so `1._5` parsed as 1.5 — separators are legal
+    // only BETWEEN digits.
+    //
+    // Every inner group is now non-capturing, so the number contributes
+    // exactly ONE capture (msrc) and the ender's first group is m[2] rather
+    // than m[9]. That retires "count parens in numberEnder!" as a hazard.
+    // The marker letter is case-insensitive, as it is in Go's matchNumber
+    // (src[sI+1] == 'x' || src[sI+1] == 'X', and likewise o/O and b/B) and as
+    // JS `Number()` already is — +"0XFF" is 255, so the coercion below needed
+    // no change. TS accepted only the lowercase marker, so `0XFF` lexed as
+    // #TX here and #NR there.
+    //
+    // Widening TS to match Go, rather than narrowing Go to match TS: Go is the
+    // reference port, and narrowing would break any Go consumer relying on
+    // 0XFF being 255. It is also the internally consistent direction — hex
+    // DIGITS are already case-insensitive in both ports (0xAB == 0xab), so
+    // only the marker was asymmetric.
+    let baseAlts = [
+        mcfg.hex ? '[xX][0-9a-fA-F_]+' : null,
+        mcfg.oct ? '[oO][0-7_]+' : null,
+        mcfg.bin ? '[bB][01_]+' : null,
     ]
-        .join('')
-        .replace(/_/g, mcfg.sep ? (0, utility_1.escre)(mcfg.sepChar) : ''), ')', ...cfg.rePart.ender);
+        .filter((s) => null != s)
+        .join('|');
+    let decimalRe = '\\.?[0-9]+(?:[0-9_]*[0-9])?' +
+        '(?:\\.(?:[0-9](?:[0-9_]*[0-9])?)?)?' +
+        '(?:[eE][-+]?[0-9]+(?:[0-9_]*[0-9])?)?';
+    let ender = (0, utility_1.regexp)('y', ('([-+]?' +
+        // With every base form disabled there is no prefix branch at all,
+        // rather than a degenerate `0(?:)` that matches a bare `0`.
+        ('' === baseAlts
+            ? decimalRe
+            : '(?:0(?:' + baseAlts + ')|' + decimalRe + ')')).replace(/_/g, mcfg.sep ? (0, utility_1.escre)(mcfg.sepChar) : ''), ')', ...cfg.rePart.ender);
     let numberSep = mcfg.sep
         ? (0, utility_1.regexp)('g', (0, utility_1.escre)(mcfg.sepChar))
         : undefined;
@@ -854,7 +903,11 @@ let makeNumberMatcher = (cfg, _opts) => {
         let m = ender.exec(lex.src);
         if (m) {
             let msrc = m[1];
-            let tsrc = m[9]; // NOTE: count parens in numberEnder!
+            // m[2], not m[9]: the number contributes exactly one capture (msrc),
+            // so the ender's first group follows it directly. Every inner group in
+            // the number pattern is non-capturing precisely so this index cannot
+            // drift again.
+            let tsrc = m[2];
             let out = undefined;
             let included = true;
             if (null != msrc &&
@@ -1245,6 +1298,106 @@ class Lex {
         }
         return this.fwd;
     }
+    // Negotiated lexing (cfg.lex.relex): re-cut the source span of an
+    // already-lexed token, constrained to the tins the requesting
+    // alternate wants. Returns the recut token — the cursor then sits
+    // after it and any pending lookahead is discarded — or undefined,
+    // with all lexer state restored.
+    //
+    // Why this exists: one character can be claimable by several
+    // matchers ('"' by an escape class and by a fixed quote; '\n' by a
+    // whitespace class and by a fixed literal). The first fetch commits
+    // to one identity by matcher order, and the pushback buffer makes
+    // that identity sticky across rule boundaries — so an alternate
+    // wanting the other, equally valid, identity fails. Scannerless
+    // notations (GBNF) hit this constantly; the parser knows which tins
+    // it wants, so it is allowed to renegotiate the cut.
+    relex(from, want, rule) {
+        if (null == from || from.len <= 0 || from.sI < 0) {
+            return undefined;
+        }
+        const pnt = this.pnt;
+        const sI = pnt.sI;
+        const rI = pnt.rI;
+        const cI = pnt.cI;
+        const queue = pnt.token;
+        const end = pnt.end;
+        pnt.sI = from.sI;
+        pnt.rI = from.rI;
+        pnt.cI = from.cI;
+        pnt.token = [];
+        pnt.end = undefined;
+        this.want = want;
+        let tkn = undefined;
+        try {
+            tkn = this.next(rule);
+        }
+        finally {
+            this.want = null;
+        }
+        if (null == tkn || !want.includes(tkn.tin)) {
+            pnt.sI = sI;
+            pnt.rI = rI;
+            pnt.cI = cI;
+            pnt.token = queue;
+            pnt.end = end;
+            return undefined;
+        }
+        // Commit. The cursor now sits after the recut token; queued
+        // lookahead derived from the old cut is stale and stays dropped.
+        // Preserve any attached ignored token (it precedes the span and is
+        // unaffected by the recut).
+        if (null != from.ignored) {
+            tkn.ignored = from.ignored;
+        }
+        // Record where the point was, so the caller can undo this commit if
+        // the alternate that asked for it goes on to fail. See `unrelex`.
+        const undo = this.relexUndo;
+        undo.sI = sI;
+        undo.rI = rI;
+        undo.cI = cI;
+        undo.token = queue;
+        undo.end = end;
+        return tkn;
+    }
+    // Undo a committed recut: put the point back where `relex` found it.
+    // The caller passes its own copy of the snapshot rather than reading
+    // `relexUndo` directly, because that field is overwritten by any
+    // further recut and the undo must reach back to the FIRST one.
+    unrelex(sI, rI, cI, token, end) {
+        const pnt = this.pnt;
+        pnt.sI = sI;
+        pnt.rI = rI;
+        pnt.cI = cI;
+        pnt.token = token;
+        pnt.end = end;
+    }
+    // Run one matcher under a `want` constraint, keeping its token only
+    // when the tin is wanted and restoring the point otherwise. Used for
+    // custom matchers during negotiated lexing, where the produced tin is
+    // not knowable in advance. A matcher is free to move the cursor and
+    // queue tokens, so the restore covers the same fields `relex` saves.
+    speculate(mat, rule, tI) {
+        const pnt = this.pnt;
+        const sI = pnt.sI;
+        const rI = pnt.rI;
+        const cI = pnt.cI;
+        const qN = pnt.token.length;
+        const end = pnt.end;
+        if (undefined === BUILTIN_MATCHER[mat.matcher]) {
+            this.refwd();
+        }
+        const tkn = mat(this, rule, tI);
+        if (null != tkn && this.want.includes(tkn.tin)) {
+            return tkn;
+        }
+        pnt.sI = sI;
+        pnt.rI = rI;
+        pnt.cI = cI;
+        pnt.token.length = qN;
+        pnt.end = end;
+        return undefined;
+    }
     constructor(ctx) {
         this.src = types_1.EMPTY; // Full source text being lexed.
         this.ctx = {}; // Parse context (config, logging, subscribers).
@@ -1252,6 +1405,22 @@ class Lex {
         this.pnt = makePoint(-1); // Current scan position.
         this.fwd = types_1.EMPTY; // Source from pnt.sI onward (the unconsumed remainder).
         this.fwdSI = -1; // pnt.sI the current fwd slice was taken at (memo key).
+        // Negotiated-lexing constraint (cfg.lex.relex). When non-null, only
+        // matchers that can produce one of these tins run, and tcol gating is
+        // bypassed — the requesting alternate's own token list is a sharper
+        // gate than the rule-level union. Set only inside relex().
+        this.want = null;
+        // Where the point stood immediately before the last recut `relex`
+        // COMMITTED. One reusable record: the parser copies out of it at the
+        // moment of the commit (see parse_alts), because a later recut
+        // overwrites it.
+        this.relexUndo = {
+            sI: -1,
+            rI: -1,
+            cI: -1,
+            token: [],
+            end: undefined,
+        };
         this.ctx = ctx;
         this.src = ctx.src();
         this.cfg = ctx.cfg;
@@ -1300,6 +1469,38 @@ class Lex {
                 : dispatch[cc < 256 ? cc : 256];
             try {
                 for (let mat of mats) {
+                    // Negotiated lexing: a single-token builtin whose tin is not
+                    // wanted cannot serve the request; skip it. match/fixed filter
+                    // internally, per candidate.
+                    if (null != this.want) {
+                        const nm = mat.matcher;
+                        if ('match' !== nm && 'fixed' !== nm) {
+                            const t = this.cfg.t;
+                            const btin = 'space' === nm ? t.SP :
+                                'line' === nm ? t.LN :
+                                    'string' === nm ? t.ST :
+                                        'comment' === nm ? t.CM :
+                                            'number' === nm ? t.NR :
+                                                'text' === nm ? t.TX : -1;
+                            if (-1 === btin) {
+                                // A custom `lex.match` matcher. Its token identity is
+                                // opaque — the only way to learn whether it can serve
+                                // the request is to run it — so run it speculatively and
+                                // put the cursor back when what it produced is not
+                                // wanted. Skipping it outright would deny custom tokens
+                                // the renegotiation that match and fixed tokens get.
+                                const cand = this.speculate(mat, rule, tI);
+                                if (undefined === cand)
+                                    continue;
+                                tkn = cand;
+                                match = mat;
+                                break;
+                            }
+                            if (!this.want.includes(btin)) {
+                                continue;
+                            }
+                        }
+                    }
                     if (undefined === BUILTIN_MATCHER[mat.matcher]) {
                         this.refwd();
                     }