@bablr/bablr-vm 0.13.0 → 0.13.2

package/lib/evaluate.js

@@ -1,11 +1,12 @@
 import { Coroutine } from '@bablr/coroutine';
-import { reifyExpression } from '@bablr/agast-vm-helpers';
+import { buildCall, buildNull, buildReference, reifyExpression } from '@bablr/agast-vm-helpers';
 import { StreamGenerator } from '@bablr/agast-helpers/stream';
 import { resolveLanguage } from '@bablr/helpers/grammar';
 import { buildTokens } from './utils/token.js';
 import { formatType } from './utils/format.js';
 import { facades } from './facades.js';
 import { State } from './state.js';
+import { updateSpans } from './spans.js';
 
 const nodeTopType = Symbol.for('@bablr/node');
 
@@ -23,103 +24,6 @@ export const evaluate = (ctx, rootLanguage, rootSource, strategy) => {
 
 const resolvedLanguages = new WeakMap();
 
-function updateSpans(ctx, s, node, phase) {
-  switch (phase) {
-    case 'open': {
-      const { attributes, flags } = node;
-      const { span: innerSpan, balanced, balancedSpan, balancer, openSpan } = attributes || {};
-
-      if (!flags.intrinsic && (balancer || balanced)) {
-        throw new Error('not implemented');
-      }
-
-      if (flags.intrinsic) {
-        if (s.path) {
-          if (balancedSpan) {
-            if (!balanced) throw new Error();
-
-            s.spans = s.spans.push({
-              type: 'Lexical',
-              name: balancedSpan,
-              path: s.path,
-              guard: balanced,
-            });
-          }
-
-          if (innerSpan) {
-            throw new Error();
-          }
-        }
-      }
-
-      if (openSpan) {
-        s.spans = s.spans.push({
-          type: 'Explicit',
-          name: openSpan,
-          path: s.path,
-          guard: null,
-        });
-      }
-
-      if (balancer) {
-        const balancedNode = s.balanced.value;
-
-        if (!s.balanced.size) throw new Error();
-
-        s.balanced = s.balanced.pop();
-
-        if (balancer && balancedNode.openTag.value.attributes.balancedSpan) {
-          s.spans = s.spans.pop();
-        }
-      }
-
-      if (balanced) {
-        s.balanced = s.balanced.push(ctx.agast.nodeForTag(s.result));
-      }
-
-      if (innerSpan) {
-        s.spans = s.spans.push({
-          type: 'Inner',
-          name: innerSpan,
-          path: s.path,
-          guard: null,
-        });
-      }
-
-      break;
-    }
-
-    case 'close': {
-      const { openTag, flags } = node;
-      const { attributes } = openTag.value;
-      const { balancedSpan, span: innerSpan, closeSpan, balanced } = attributes || {};
-
-      if (balancedSpan && !flags.intrinsic) {
-        if (!balanced) throw new Error();
-
-        s.spans = s.spans.push({
-          type: 'Lexical',
-          name: balancedSpan,
-          path: s.path,
-          guard: balanced,
-        });
-      }
-
-      if (closeSpan) {
-        if (s.spans.value.type !== 'Explicit') throw new Error();
-        s.spans = s.spans.pop();
-      }
-
-      if (innerSpan) {
-        s.spans = s.spans.pop();
-      }
-      break;
-    }
-    default:
-      throw new Error();
-  }
-}
-
 const __evaluate = function* bablrStrategy(ctx, rootLanguage, rootSource, agastState, strategy) {
   let s = State.from(ctx, rootSource, agastState);
 
@@ -381,6 +285,26 @@ const __evaluate = function* bablrStrategy(ctx, rootLanguage, rootSource, agastS
 
         s = s.parent;
 
+        if (rejectedState.path.depth > s.path.depth) {
+          const lowPath = rejectedState.path.at(
+            Math.min(s.path.depth + 1, rejectedState.path.depth),
+          );
+
+          if (s.path.depth) {
+            const { name, isArray } = lowPath.reference?.value || {};
+
+            if (s.node.depth === s.path.depth && !s.node.resolver.counters.has(name)) {
+              if (!lowPath.openTag?.value.flags.trivia && !lowPath.openTag?.value.flags.escape) {
+                yield buildCall('advance', buildReference(name, isArray));
+              }
+
+              if (s.result.type === 'Reference') {
+                yield buildCall('advance', buildNull());
+              }
+            }
+          }
+        }
+
         if (!s) throw new Error('rejected root state');
 
         rejectedState.source.reject();

package/lib/spans.js

@@ -0,0 +1,92 @@
+export function updateSpans(ctx, s, node, phase) {
+  switch (phase) {
+    case 'open': {
+      const { attributes, flags } = node;
+      const { span: innerSpan, balanced, balancedSpan, balancer, openSpan } = attributes || {};
+
+      if (!flags.intrinsic && (balancer || balanced)) {
+        throw new Error('not implemented');
+      }
+
+      if (flags.intrinsic) {
+        if (s.path && balanced) {
+          s.spans = s.spans.push({
+            type: 'Lexical',
+            name: balancedSpan || s.span.name,
+            path: s.path,
+            guard: balanced,
+          });
+
+          if (innerSpan) {
+            throw new Error();
+          }
+        }
+      }
+
+      if (openSpan) {
+        s.spans = s.spans.push({
+          type: 'Explicit',
+          name: openSpan,
+          path: s.path,
+          guard: null,
+        });
+      }
+
+      if (balancer) {
+        const balancedNode = s.balanced.value;
+
+        if (!s.balanced.size) throw new Error();
+
+        if (!balancedNode.openTag.value.attributes.balanced) {
+          throw new Error();
+        }
+
+        s.balanced = s.balanced.pop();
+
+        s.spans = s.spans.pop();
+      }
+
+      if (balanced) {
+        s.balanced = s.balanced.push(ctx.agast.nodeForTag(s.result));
+      }
+
+      if (innerSpan) {
+        s.spans = s.spans.push({
+          type: 'Inner',
+          name: innerSpan,
+          path: s.path,
+          guard: null,
+        });
+      }
+
+      break;
+    }
+
+    case 'close': {
+      const { openTag, flags } = node;
+      const { attributes } = openTag.value;
+      const { balancedSpan, span: innerSpan, closeSpan, balanced } = attributes || {};
+
+      if (balanced && !flags.intrinsic) {
+        s.spans = s.spans.push({
+          type: 'Lexical',
+          name: balancedSpan || s.span.name,
+          path: s.path,
+          guard: balanced,
+        });
+      }
+
+      if (closeSpan) {
+        if (s.spans.value.type !== 'Explicit') throw new Error();
+        s.spans = s.spans.pop();
+      }
+
+      if (innerSpan) {
+        s.spans = s.spans.pop();
+      }
+      break;
+    }
+    default:
+      throw new Error();
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,10 +12,10 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.0",
-    "@bablr/agast-vm-helpers": "0.1.0",
+    "@bablr/agast-helpers": "0.1.1",
+    "@bablr/agast-vm-helpers": "0.1.1",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.15.0",
+    "@bablr/helpers": "0.15.1",
     "@bablr/regex-vm": "0.5.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0",