parseman 0.51.1 → 0.51.2

package/dist/analysis/diagnostics.js

@@ -4253,6 +4253,7 @@ var OP_COV = 40;
 var OP_SCOPE_PLAIN = 41;
 var OP_LEX_BODY = 42;
 var OP_LEX_PROGRAM = 43;
+var OP_SOURCE_LEAF = 44;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -4271,6 +4272,7 @@ var OP_NAMES = {
   [OP_NOT]: "NOT",
   [OP_PEEK]: "PEEK",
   [OP_LEAF]: "LEAF",
+  [OP_SOURCE_LEAF]: "SOURCE_LEAF",
   [OP_EMPTY]: "EMPTY",
   [OP_LIT_TRACK]: "LIT_TRACK",
   [OP_RX_TRACK]: "RX_TRACK",
@@ -7040,7 +7042,7 @@ var Encoder = class {
       }
       case "leaf": {
         const child = this.node(d.parser).ip;
-        return this.emit(OP_LEAF, this.fn(d.fn, d.fnSrc ?? null), child);
+        return this.emit(d.cstValue === "source" ? OP_SOURCE_LEAF : OP_LEAF, this.fn(d.fn, d.fnSrc ?? null), child);
       }
       case "node": {
         if (d.type === void 0) missingInferredType();
@@ -7265,6 +7267,7 @@ var Encoder = class {
         case OP_WITHCTX:
         case OP_XFORM:
         case OP_LEAF:
+        case OP_SOURCE_LEAF:
         case OP_NODE:
         case OP_NODE_TRACK:
           return [ip + 2];
@@ -8474,6 +8477,7 @@ function childSlots(code, ip, out) {
     case OP_NODE_TRACK:
     case OP_FIELD:
     case OP_LEAF:
+    case OP_SOURCE_LEAF:
     case OP_ARMGATE:
       out.push(code[ip + 2]);
       return true;
@@ -8582,7 +8586,7 @@ function transfer(code, ip, at, hostCst) {
     if (at.tri === TRI_NONE && !at.buf) return at;
     return { tri: TRI_NONE, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
   }
-  if (op === OP_LEAF) {
+  if (op === OP_LEAF || op === OP_SOURCE_LEAF) {
     if (!at.buf) return at;
     return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
   }
@@ -8669,7 +8673,7 @@ function leadingScalarTerminal(code, ip, minDepth = 2, throughAttempt = true, th
       depth++;
       continue;
     }
-    if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+    if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
       at = code[at + 2];
       depth++;
       continue;
@@ -8702,7 +8706,7 @@ function leadingScalarSequence(code, ip) {
         at2 = code[at2 + 1];
         continue;
       }
-      if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+      if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
         at2 = code[at2 + 2];
         continue;
       }
@@ -8735,7 +8739,7 @@ function leadingScalarSequence(code, ip) {
       at = code[at + 2];
       continue;
     }
-    if (op === OP_GATE || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+    if (op === OP_GATE || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
       at = code[at + 2];
       continue;
     }
@@ -8765,7 +8769,7 @@ function leadingLiteralFamily(code, constants, ip, minDepth = 2, limit = 4) {
       if (op === OP_RULE || op === OP_LABEL || op === OP_TOKEN || op === OP_ATTEMPT || op === OP_PEEK) {
         return walk(code[at + 1], depth + 1);
       }
-      if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+      if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
         return walk(code[at + 2], depth + 1);
       }
       if (op === OP_SEQ || op === OP_SEQV) {
@@ -9651,8 +9655,10 @@ ${rootCap ? "ctx._rootTriviaCapture=sR\n" : ""}return v
       }
       /* ── boundaries ──────────────────────────────────────────────────────── */
       case OP_TOKEN:
-      case OP_LEAF: {
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
         const isToken = op === OP_TOKEN;
+        const capturesSource = isToken || op === OP_SOURCE_LEAF && hostCst;
         const fn = isToken ? void 0 : fnRef(code[ip + 1]);
         const child = link(isToken ? code[ip + 1] : code[ip + 2]);
         const wasCap = L.buf ? "true" : "(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)";
@@ -9685,7 +9691,7 @@ 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:out,span:{start:pos,end:e}})
+if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:${capturesSource ? "input.slice(pos,e)" : "out"},span:{start:pos,end:e}})
 EC.e=e
 return out
 }`;
@@ -10836,6 +10842,12 @@ function ref() {
 }
 
 // src/combinators/token.ts
+function semanticLeafValue(_ctx, _input, _start, _end, value) {
+  return value;
+}
+function sourceLeafValue(ctx, input, start, end, value) {
+  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
+}
 function token(root) {
   const meta = {
     firstSet: root._meta.firstSet,
@@ -10888,7 +10900,8 @@ function token(root) {
     }
   };
 }
-function leaf(root, fn) {
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
   const meta = {
     firstSet: root._meta.firstSet,
     canMatchNewline: root._meta.canMatchNewline,
@@ -10897,7 +10910,12 @@ function leaf(root, fn) {
   return {
     _tag: "leaf",
     _meta: meta,
-    _def: { tag: "leaf", parser: root, fn },
+    _def: {
+      tag: "leaf",
+      parser: root,
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
+    },
     parse(input, pos, ctx) {
       const savedBuf = ctx._cstBuf;
       const savedChildren = ctx._cstChildren;
@@ -10925,11 +10943,21 @@ function leaf(root, fn) {
       }
       if (!result.ok) return result;
       const value = fn(result.value, result.span);
-      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span: result.span });
+      if (wasCapturing) pushCstLeaf(ctx, {
+        _tag: "leaf",
+        value: cstValue(ctx, input, pos, result.span.end, value),
+        span: result.span
+      });
       return { ok: true, value, span: result.span };
     }
   };
 }
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
+}
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
+}
 
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
@@ -12717,7 +12745,8 @@ function assemble(t2, prog, cfg) {
           return value;
         };
       }
-      case OP_LEAF: {
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
         const fn = fns[code[ip + 1]];
         const child = link(code[ip + 2]);
         return (input, pos, ctx) => {
@@ -12745,7 +12774,11 @@ function assemble(t2, prog, cfg) {
           if (v === FAIL) return FAIL;
           const end = EC.e;
           const out = fn(v, { start: pos, end });
-          if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value: out, span: { start: pos, end } });
+          if (wasCapturing) pushCstLeaf(ctx, {
+            _tag: "leaf",
+            value: op === OP_SOURCE_LEAF && hostCst ? input.slice(pos, end) : out,
+            span: { start: pos, end }
+          });
           EC.e = end;
           return out;
         };
@@ -14775,7 +14808,7 @@ function payloadKey(p, d) {
     case "transform":
       return `transform\0${fnKey(d.fnSrc, d.fn)}\0${d.recognitionOnly === true}`;
     case "leaf":
-      return `leaf\0${fnKey(d.fnSrc, d.fn)}`;
+      return `leaf\0${d.cstValue ?? "value"}\0${fnKey(d.fnSrc, d.fn)}`;
     case "many":
     case "oneOrMore":
       return `${d.tag}\0${d.min}\0${d.max ?? ""}`;
@@ -16566,7 +16599,7 @@ function rebuildCombinator(root, replacements) {
         out = token(one(d.parser));
         break;
       case "leaf":
-        out = leaf(one(d.parser), d.fn);
+        out = d.cstValue === "source" ? sourceLeaf(one(d.parser), d.fn) : leaf(one(d.parser), d.fn);
         break;
       // A LABELLED expect reproduces `d.expected` exactly (`expect` sets it to `[label]`).
       // An unlabelled one RE-DERIVES it from the rebuilt inner parser, so it can differ