@vuu-ui/vuu-table 0.8.0-debug → 0.8.1-debug

package/cjs/index.js

@@ -2590,26 +2590,58 @@ var Stack = class {
   // be done.
   /// @internal
   forceReduce() {
-    let reduce = this.p.parser.stateSlot(
+    let { parser: parser2 } = this.p;
+    let reduce = parser2.stateSlot(
       this.state,
       5
       /* ParseState.ForcedReduce */
     );
     if ((reduce & 65536) == 0)
       return false;
-    let { parser: parser2 } = this.p;
     if (!parser2.validAction(this.state, reduce)) {
       let depth = reduce >> 19, term = reduce & 65535;
       let target = this.stack.length - depth * 3;
-      if (target < 0 || parser2.getGoto(this.stack[target], term, false) < 0)
-        return false;
-      this.storeNode(0, this.reducePos, this.reducePos, 4, true);
+      if (target < 0 || parser2.getGoto(this.stack[target], term, false) < 0) {
+        let backup = this.findForcedReduction();
+        if (backup == null)
+          return false;
+        reduce = backup;
+      }
+      this.storeNode(0, this.pos, this.pos, 4, true);
       this.score -= 100;
     }
     this.reducePos = this.pos;
     this.reduce(reduce);
     return true;
   }
+  /// Try to scan through the automaton to find some kind of reduction
+  /// that can be applied. Used when the regular ForcedReduce field
+  /// isn't a valid action. @internal
+  findForcedReduction() {
+    let { parser: parser2 } = this.p, seen = [];
+    let explore = (state, depth) => {
+      if (seen.includes(state))
+        return;
+      seen.push(state);
+      return parser2.allActions(state, (action) => {
+        if (action & (262144 | 131072))
+          ;
+        else if (action & 65536) {
+          let rDepth = (action >> 19) - depth;
+          if (rDepth > 1) {
+            let term = action & 65535, target = this.stack.length - rDepth * 3;
+            if (target >= 0 && parser2.getGoto(this.stack[target], term, false) >= 0)
+              return rDepth << 19 | 65536 | term;
+          }
+        } else {
+          let found = explore(action, depth + 1);
+          if (found != null)
+            return found;
+        }
+      });
+    };
+    return explore(this.state, 0);
+  }
   /// @internal
   forceAll() {
     while (!this.p.parser.stateFlag(
@@ -2678,13 +2710,13 @@ var Stack = class {
   emitContext() {
     let last = this.buffer.length - 1;
     if (last < 0 || this.buffer[last] != -3)
-      this.buffer.push(this.curContext.hash, this.reducePos, this.reducePos, -3);
+      this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
   }
   /// @internal
   emitLookAhead() {
     let last = this.buffer.length - 1;
     if (last < 0 || this.buffer[last] != -4)
-      this.buffer.push(this.lookAhead, this.reducePos, this.reducePos, -4);
+      this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
   }
   updateContext(context) {
     if (context != this.curContext.context) {
@@ -3041,16 +3073,17 @@ var LocalTokenGroup = class {
   token(input, stack) {
     let start = input.pos, skipped = 0;
     for (; ; ) {
+      let atEof = input.next < 0, nextPos = input.resolveOffset(1, 1);
       readToken(this.data, input, stack, 0, this.data, this.precTable);
       if (input.token.value > -1)
         break;
       if (this.elseToken == null)
         return;
-      if (input.next < 0)
+      if (!atEof)
+        skipped++;
+      if (nextPos == null)
         break;
-      input.advance();
-      input.reset(input.pos, input.token);
-      skipped++;
+      input.reset(nextPos, input.token);
     }
     if (skipped) {
       input.reset(start, input.token);
@@ -3763,26 +3796,30 @@ var LRParser = class extends Parser {
   }
   /// @internal
   validAction(state, action) {
-    if (action == this.stateSlot(
+    return !!this.allActions(state, (a) => a == action ? true : null);
+  }
+  /// @internal
+  allActions(state, action) {
+    let deflt = this.stateSlot(
       state,
       4
       /* ParseState.DefaultReduce */
-    ))
-      return true;
+    );
+    let result = deflt ? action(deflt) : void 0;
     for (let i = this.stateSlot(
       state,
       1
       /* ParseState.Actions */
-    ); ; i += 3) {
+    ); result == null; i += 3) {
       if (this.data[i] == 65535) {
         if (this.data[i + 1] == 1)
           i = pair(this.data, i + 2);
         else
-          return false;
+          break;
       }
-      if (action == pair(this.data, i + 1))
-        return true;
+      result = action(pair(this.data, i + 1));
     }
+    return result;
   }
   /// Get the states that can follow this one through shift actions or
   /// goto jumps. @internal