@bablr/bablr-vm 0.23.1 → 0.23.3

package/lib/context.js

@@ -1,24 +1,7 @@
 import { buildDependentLanguages } from '@bablr/helpers/grammar';
-import { facades, actuals } from './facades.js';
+import { getGapNode } from './facades.js';
 
-export const ContextFacade = class BABLRContextFacade {
-  constructor(actual) {
-    facades.set(actual, this);
-    Object.freeze(this);
-  }
-
-  get languages() {
-    return actuals.get(this).languages;
-  }
-
-  get grammars() {
-    return actuals.get(this).grammars;
-  }
-
-  get productionEnhancer() {
-    return actuals.get(this).productionEnhancer;
-  }
-};
+let facades = new WeakMap();
 
 export const Context = class BABLRContext {
   static from(language, productionEnhancer) {
@@ -28,11 +11,13 @@ export const Context = class BABLRContext {
   constructor(languages, productionEnhancer) {
     this.languages = languages;
     this.productionEnhancer = productionEnhancer;
+    this.getGrammar = (language) => this.grammars.get(language);
+
+    Object.freeze(productionEnhancer);
 
     this.unboxedValues = new WeakMap();
 
     this.grammars = new WeakMap();
-    this.facade = new ContextFacade(this);
 
     for (const { 1: language } of this.languages) {
       if (!language) throw new Error();
@@ -40,4 +25,21 @@ export const Context = class BABLRContext {
       this.grammars.set(language, new language.grammar());
     }
   }
+
+  getPublic() {
+    let value = facades.get(this);
+    if (value) return value;
+
+    let { productionEnhancer, getGrammar } = this;
+
+    value = Object.freeze({
+      getGrammar,
+      getGapNode,
+      productionEnhancer,
+    });
+
+    facades.set(this, value);
+
+    return value;
+  }
 };

package/lib/evaluate.js

@@ -1,8 +1,12 @@
 /* global WeakSet */
 import { Coroutine } from '@bablr/coroutine';
-import { buildAttributeDefinition, buildCloseNodeTag } from '@bablr/agast-helpers/builders';
+import {
+  buildAttributeDefinition,
+  buildCloseNodeTag,
+  buildTypedSpan,
+  deepFreeze,
+} from '@bablr/agast-helpers/builders';
 import { getStreamIterator, printType, StreamIterable, wait } from '@bablr/agast-helpers/stream';
-import { facades } from './facades.js';
 import { State } from './state.js';
 import {
   OpenNodeTag,
@@ -22,12 +26,7 @@ import { buildWriteEffect } from '@bablr/agast-vm-helpers/builders';
 import { has } from '@bablr/agast-helpers/object';
 import { reifyBablrOptions } from '@bablr/agast-vm-helpers';
 import { buildNode, getTags } from '@bablr/agast-helpers/path';
-
-const validNodesByLanguage = new Map();
-
-export const isKnownValid = (language, node) => {
-  return !!validNodesByLanguage.get(language)?.has(node);
-};
+import * as Spans from '@bablr/agast-helpers/spans';
 
 const getSourceLength = (tags) => {
   let i = 0;
@@ -41,11 +40,18 @@ const getSourceLength = (tags) => {
   return i;
 };
 
-export const bablr = (ctx, rootSource, strategy, options = {}) => {
-  return new StreamIterable(__bablr(ctx, rootSource, strategy, options));
+export const bablr = (
+  ctx,
+  rootSource,
+  language,
+  strategy,
+  options = {},
+  registerNode = () => {},
+) => {
+  return new StreamIterable(__bablr(ctx, rootSource, language, strategy, options, registerNode));
 };
 
-function* __bablr(ctx, rootSource, strategy, options) {
+function* __bablr(ctx, rootSource, rootLanguage, strategy, options, registerNode) {
   let s = null;
   let m = null;
   let finishedMatch = null;
@@ -53,14 +59,22 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
   let getState = () => s.getPublic();
 
-  for (const language of ctx.languages.values()) {
-    validNodesByLanguage.set(language, validNodesByLanguage.get(language) || new WeakSet());
+  s = State.from(rootSource, ctx, rootLanguage, options.expressions, options.spans);
+
+  s.source.advance();
+
+  if (options.holdUndefinedAttributes) {
+    throw new Error('holdUndefinedAttributes not implemented');
   }
 
-  let co = new Coroutine(getStreamIterator(strategy(facades.get(ctx), getState)));
+  let co = new Coroutine(getStreamIterator(strategy(ctx.getPublic(), rootLanguage, getState)));
 
   co.advance();
 
+  if (s.source.head.step instanceof Promise) {
+    yield wait(s.source.head.step);
+  }
+
   for (;;) {
     if (co.current instanceof Promise) {
       co.current = yield wait(co.current);
@@ -71,6 +85,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
         throw new Error(`parse ate ${s.source.index} characters but the input was not consumed`);
       }
 
+      if (m) throw new Error();
+
       let { exchange } = s.source;
 
       s.source.release();
@@ -79,7 +95,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
         throw new Error('Source did not close all forks: ' + exchange.sources);
       }
 
-      return co.value;
+      return options.tree === undefined || options.tree ? finishedMatch.node : undefined;
     }
 
     const instr = co.value;
@@ -229,8 +245,6 @@ function* __bablr(ctx, rootSource, strategy, options) {
               s.node = m.node;
             }
 
-            validNodesByLanguage.get(language).add(node);
-
             break;
           }
 
@@ -327,14 +341,15 @@ function* __bablr(ctx, rootSource, strategy, options) {
       }
 
       case 'startSpan': {
-        let { arguments: { 0: name, 1: guard = null } = [] } = instr;
-        s.spans = s.spans.push({ type: 'Instruction', name, guard });
+        let { arguments: { 0: name, 1: guard = null, 2: { value: props } } = [] } = instr;
+        deepFreeze(props);
+        s.spans = Spans.push(s.spans, buildTypedSpan('Instruction', name, guard, props));
         break;
       }
 
       case 'endSpan': {
-        if (s.spans.value.type !== 'Instruction') throw new Error();
-        s.spans = s.spans.pop();
+        if (s.span.type !== 'Instruction') throw new Error();
+        s.spans = Spans.pop(s.spans);
         break;
       }
 
@@ -347,7 +362,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         yield* m.emit(outerOptions);
 
-        returnValue = facades.get(m);
+        returnValue = m.getPublic();
         break;
       }
 
@@ -359,6 +374,10 @@ function* __bablr(ctx, rootSource, strategy, options) {
         m = m.endFrame(outerOptions);
         s = m ? m.state : s;
 
+        if (finishedMatch.isNode) {
+          registerNode(m.language, m.node);
+        }
+
         if (m) {
           m.running = null;
           if (finishedMatch.shiftMatch) {
@@ -367,7 +386,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
           yield* m.emit(outerOptions);
         }
 
-        returnValue = m && facades.get(m);
+        returnValue = m && m.getPublic();
         break;
       }
 
@@ -377,7 +396,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         let parentMatch = m;
 
-        if (finishedMatch.type !== '_') throw new Error();
+        if (finishedMatch.type === '__') throw new Error();
 
         m = Match.startFrame(
           ctx,
@@ -395,7 +414,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         yield* finishedMatch.emit(outerOptions);
 
-        returnValue = m && facades.get(m);
+        returnValue = m && m.getPublic();
         break;
       }
 
@@ -410,32 +429,12 @@ function* __bablr(ctx, rootSource, strategy, options) {
           s = m.state;
         }
 
-        returnValue = m && facades.get(m);
+        returnValue = m && m.getPublic();
         break;
       }
 
       case 'getState': {
-        returnValue = facades.get(s);
-        break;
-      }
-
-      case 'init': {
-        let { arguments: { 0: canonicalURL } = [] } = instr;
-
-        if (s !== null) throw new Error();
-
-        // TODO get rid of ctx.languages
-        s = State.from(rootSource, ctx, ctx.languages.get(canonicalURL), options.expressions);
-
-        s.source.advance();
-
-        const sourceStep = s.source.head.step;
-
-        if (sourceStep instanceof Promise) {
-          yield wait(sourceStep);
-        }
-
-        returnValue = facades.get(s);
+        returnValue = s.getPublic();
         break;
       }
 

package/lib/facades.js

@@ -1,33 +1,44 @@
 import * as Tags from '@bablr/agast-helpers/tags';
-import { buildGapTag, buildProperty } from '@bablr/agast-helpers/builders';
+import { buildGapTag, buildPropertyTag } from '@bablr/agast-helpers/builders';
 import { buildFacadeLayer } from '@bablr/agast-vm-helpers/facades';
-import { buildNode, getTags } from '@bablr/agast-helpers/path';
+import { buildNode, getTags, isStubNode } from '@bablr/agast-helpers/path';
 import { Property } from '@bablr/agast-helpers/symbols';
 
 export const { facades, actuals } = buildFacadeLayer();
 
+let gapNodes = new WeakMap();
+
+export const getGapNode = (gap) => gapNodes.get(gap);
+
 export const buildFacadeNode = (node) => {
+  if (!node) return null;
+
   let facadeTags = Tags.fromValues([]);
 
+  if (isStubNode(node)) {
+    return node;
+  }
+
   for (let tag of Tags.traverse(getTags(node))) {
     if (tag.type === Property) {
       let property = tag;
-      let { reference, bindings, node, tags } = property;
-
-      let property_ = property;
+      let { reference, shift, node, tags } = property.value;
 
-      if (!reference.flags.intrinsic) {
+      let tags_;
+      if (reference?.flags.intrinsic || ['_', '#', '@'].includes(reference?.type)) {
+        tags_ = [tags[0], tags[1], buildFacadeNode(node)];
+      } else {
         let gapNode = buildNode(buildGapTag());
-        if (!reference.flags.hasGap) {
-          actuals.set(gapNode, node);
+        if (!reference?.flags.hasGap) {
+          gapNodes.set(gapNode, node);
         }
 
-        let tags_ = Tags.fromValues([tags[0], tags[1], gapNode]);
-
-        property_ = buildProperty(tags_);
+        tags_ = [tags[0], tags[1], gapNode];
       }
 
-      facadeTags = Tags.push(facadeTags, property_);
+      tags_ = tags_.slice(0, tags.length);
+
+      facadeTags = Tags.push(facadeTags, buildPropertyTag(tags_, shift));
     } else {
       facadeTags = Tags.push(facadeTags, tag);
     }

package/lib/match.js

@@ -1,5 +1,4 @@
 import { getProduction } from '@bablr/helpers/grammar';
-import { WeakStackFrame } from '@bablr/weak-stack';
 
 import { agast } from '@bablr/agast-vm';
 import * as Tags from '@bablr/agast-helpers/tags';
@@ -14,11 +13,10 @@ import {
   buildPropertyTag,
   buildOpenFragmentTag,
   nodeFlags,
-  streamFromTree,
 } from '@bablr/agast-helpers/tree';
 import { effectsFor, reifyExpression, shouldBranch } from '@bablr/agast-vm-helpers';
 
-import { facades, actuals } from './facades.js';
+import { buildFacadeNode } from './facades.js';
 import {
   CloseNodeTag,
   OpenNodeTag,
@@ -41,134 +39,13 @@ import {
 } from '@bablr/agast-helpers/path';
 import { updateSpans } from './spans.js';
 
-export class MatchFacade {
-  constructor(match) {
-    facades.set(match, this);
-    Object.freeze(this);
-  }
-
-  get language() {
-    return actuals.get(this).language;
-  }
-
-  get matcher() {
-    return actuals.get(this).matcher;
-  }
-
-  get options() {
-    return actuals.get(this).options;
-  }
-
-  get mergedReference() {
-    return actuals.get(this).mergedReference;
-  }
-
-  get propertyMatcher() {
-    return actuals.get(this).propertyMatcher;
-  }
-
-  get rawPropertyMatcher() {
-    return actuals.get(this).rawPropertyMatcher;
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get path() {
-    return actuals.get(this).path;
-  }
-
-  get fragment() {
-    return actuals.get(this).fragment;
-  }
-
-  get pathDepth() {
-    return actuals.get(this).depths.path;
-  }
-
-  get pathName() {
-    return actuals.get(this).pathName;
-  }
-
-  get node() {
-    return actuals.get(this).node;
-  }
-
-  get props() {
-    return actuals.get(this).props;
-  }
-
-  get type() {
-    return actuals.get(this).type;
-  }
-
-  get isNode() {
-    return actuals.get(this).isNode;
-  }
-
-  get isCover() {
-    return actuals.get(this).isCover;
-  }
-
-  get allowEmpty() {
-    return actuals.get(this).allowEmpty;
-  }
-
-  get didShift() {
-    return actuals.get(this).didShift;
-  }
-
-  get isCoverBoundary() {
-    return actuals.get(this).isCoverBoundary;
-  }
-
-  get coveredBoundary() {
-    return facades.get(actuals.get(this).coveredBoundary);
-  }
-
-  get nodeMatch() {
-    return facades.get(actuals.get(this).nodeMatch);
-  }
-
-  get cover() {
-    return facades.get(actuals.get(this).cover);
-  }
-
-  get shiftMatch() {
-    return facades.get(actuals.get(this).coveredBoundary.shiftMatch);
-  }
-
-  get effects() {
-    return actuals.get(this).effects;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-
-  get grammar() {
-    return actuals.get(this).grammar;
-  }
-
-  get state() {
-    return actuals.get(this).s.getPublic();
-  }
-
-  get s() {
-    return actuals.get(this).s.getPublic();
-  }
-
-  ancestors(...args) {
-    return actuals.get(this).ancestors(...args);
-  }
-}
+let facades = new WeakMap();
 
 const normalizeBindingPath = (path) => {
   if (path.length <= 1) return path;
 };
 
-export class Match extends WeakStackFrame {
+export class Match {
   static startFrame(ctx, s, m, finishedMatch, verb, matcher, options) {
     let effects = effectsFor(verb.description);
     let isShift = verb.description.startsWith('shift'); // should this be didShift?
@@ -230,8 +107,7 @@ export class Match extends WeakStackFrame {
     }
     let matcher = reifyExpression(rawMatcher);
 
-    super(parent);
-
+    this.parent = parent;
     this.context = context;
     this.state = state;
     this.rawPropertyMatcher = rawMatcher;
@@ -240,6 +116,7 @@ export class Match extends WeakStackFrame {
     this.shiftMatch = shiftMatch;
     this.emittedMatch = parent?.emittedMatch || this;
 
+    this.depth = !parent ? 0 : parent.depth + 1;
     this.agast = null;
     this.cover = null;
     this.running = null;
@@ -290,12 +167,10 @@ export class Match extends WeakStackFrame {
       this.agast.vm.next(shiftMatch.rootNode);
     }
     this.rootNode = this.agast.getState().node;
-
-    new MatchFacade(this);
   }
 
   static from(context, state, matcher, props, options) {
-    return Match.create(context, state, matcher, effectsFor('eat'), props, options);
+    return new Match(null, context, state, matcher, effectsFor('eat'), props, options);
   }
 
   get language() {
@@ -363,7 +238,7 @@ export class Match extends WeakStackFrame {
   get path() {
     let { agast } = this;
 
-    return agast.getState().path || agast.getState().resultPath?.path;
+    return Path.wrap(agast.getState().path || agast.getState().resultPath?.path);
   }
 
   get coveredBoundary() {
@@ -410,6 +285,10 @@ export class Match extends WeakStackFrame {
     return this.propertyMatcher.nodeMatcher.type === '_';
   }
 
+  push(context, state, rawMatcher, effects, shiftMatch, options) {
+    return new Match(this, context, state, rawMatcher, effects, shiftMatch, options);
+  }
+
   advance(tag) {
     let { vm, getState } = this.agast;
     let s = this.state;
@@ -426,9 +305,9 @@ export class Match extends WeakStackFrame {
       s.depths.result--;
     }
 
-    this.rootNode = agastState.path.atDepth(0).node;
+    this.rootNode = Path.wrap(agastState.path).atDepth(0).node;
 
-    s.resultPath = agastState.resultPath;
+    s.resultPath = TagPath.wrap(agastState.resultPath);
 
     // if (this.emitted?.depth > 1) throw new Error();
 
@@ -799,4 +678,97 @@ export class Match extends WeakStackFrame {
       }
     }
   }
+
+  getPublic() {
+    let cached = facades.get(this);
+    if (cached) {
+      return cached;
+    }
+
+    let {
+      parent,
+      cover,
+      nodeMatch,
+      shiftMatch,
+      coveredBoundary,
+      mergedReference,
+      matcher,
+      propertyMatcher,
+      rawPropertyMatcher,
+      language,
+      isNode,
+      isCover,
+      isCoverBoundary,
+      effects,
+      options,
+      allowEmpty,
+      depth,
+      state,
+    } = this;
+
+    let getParent = () => {
+      let value = parent;
+      if (parent) facades.set((value = facades.get(parent) || parent.getPublic()));
+      return value;
+    };
+
+    let getCover = () => {
+      let value = cover;
+      if (cover) facades.set((value = facades.get(cover) || cover.getPublic()));
+      return value;
+    };
+
+    let getCoveredBoundary = () => {
+      let value = coveredBoundary;
+      if (coveredBoundary)
+        facades.set((value = facades.get(coveredBoundary) || coveredBoundary.getPublic()));
+      return value;
+    };
+
+    let getNodeMatch = () => {
+      let value = nodeMatch;
+      if (nodeMatch) facades.set((value = facades.get(nodeMatch) || nodeMatch.getPublic()));
+      return value;
+    };
+
+    let getShiftMatch = () => {
+      let value = shiftMatch;
+      if (shiftMatch) facades.set((value = facades.get(shiftMatch) || shiftMatch.getPublic()));
+      return value;
+    };
+
+    let getState = () => {
+      return state.getPublic();
+    };
+
+    let getNode = () => {
+      return buildFacadeNode(this.node);
+    };
+
+    cached = {
+      getParent,
+      getCover,
+      getCoveredBoundary,
+      getNodeMatch,
+      getShiftMatch,
+      getState,
+      getNode,
+      mergedReference,
+      matcher,
+      propertyMatcher,
+      rawPropertyMatcher,
+      language,
+      isNode,
+      isCover,
+      isCoverBoundary,
+      effects,
+      options,
+      allowEmpty,
+      depth,
+    };
+
+    facades.set(this, cached);
+
+    return cached;
+  }
 }

package/lib/spans.js

@@ -1,26 +1,13 @@
 import { ReferenceTag } from '@bablr/agast-helpers/symbols';
-import * as BTree from '@bablr/agast-helpers/btree';
+import * as Spans from '@bablr/agast-helpers/spans';
+import { buildTypedSpan } from '@bablr/agast-helpers/builders';
 
 const popSpan = (s) => {
-  s.spans = s.spans.pop();
+  s.spans = Spans.pop(s.spans);
 };
 
 const pushSpan = (s, type, name, guard) => {
-  let isSubspan = name[0] === '.';
-  let topFrame = s.spans.value;
-
-  // if (isSubspan) {
-  //   let buildGuard = () => {
-  //     return buildPattern();
-  //   };
-  //   let name_ = topFrame.name + name;
-  //   let subframes = BTree.push(topFrame.subframes, topFrame);
-  //   let guard_ = guard;
-
-  //   s.spans = s.spans.push({ type, name: name_, guard: guard_, subframes });
-  // } else {
-  s.spans = s.spans.push({ type, name, guard, subframes: BTree.fromValues([]) });
-  // }
+  s.spans = Spans.push(s.spans, buildTypedSpan(type, name, guard));
 };
 
 export function updateSpans(m, phase) {

package/lib/state.js

@@ -1,32 +1,42 @@
 import emptyStack from '@iter-tools/imm-stack';
-import { WeakStackFrame } from '@bablr/weak-stack';
-import { getCooked, maybeWait } from '@bablr/agast-helpers/stream';
+import { maybeWait } from '@bablr/agast-helpers/stream';
 import * as BTree from '@bablr/agast-helpers/btree';
+import * as Spans from '@bablr/agast-helpers/spans';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { Matcher, Node, Regex, ShiftTag } from '@bablr/agast-vm-helpers/symbols';
+import { Matcher, Node, Regex } from '@bablr/agast-vm-helpers/symbols';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { getOpenTag } from '@bablr/agast-helpers/path';
 
 export const nodeStates = new WeakMap();
 
-export const State = class BABLRState extends WeakStackFrame {
+export const State = class BABLRState {
+  static from(source, context, language, expressions = [], spans = Spans.fromValues([])) {
+    return new State(
+      null,
+      source,
+      context,
+      BTree.fromValues([language]),
+      emptyStack.push(...emptyStack.push(...expressions).valuesReverse()),
+      spans,
+    );
+  }
+
   constructor(
     parent,
     source,
     context,
     languages,
     expressions = emptyStack,
+    spans = Spans.fromValues([]),
     balanced = emptyStack,
-    spans = emptyStack,
     resultPath = null,
     depths = { path: -1, result: -1, emitted: -1, shift: 0, nodeShift: 0 },
     held = null,
     node = null,
   ) {
-    super(parent);
-
     if (!source) throw new Error('invalid args to State');
 
+    this.parent = parent;
     this.source = source;
     this.context = context;
     this.languages = languages;
@@ -38,18 +48,10 @@ export const State = class BABLRState extends WeakStackFrame {
     this.held = held;
     this.node = node;
 
+    this.depth = !parent ? 0 : parent.depth + 1;
     this.status = 'active';
   }
 
-  static from(source, context, language, expressions = []) {
-    return State.create(
-      source,
-      context,
-      BTree.fromValues([language]),
-      emptyStack.push(...emptyStack.push(...expressions).valuesReverse()),
-    );
-  }
-
   get language() {
     return BTree.getAt(-1, this.languages);
   }
@@ -62,7 +64,7 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get span() {
-    return this.spans.value;
+    return Spans.getAt(-1, this.spans);
   }
 
   get result() {
@@ -77,12 +79,30 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.parent;
   }
 
+  push(source, context, languages, expressions, spans, balanced, resultPath, depths, held, node) {
+    return new State(
+      this,
+      source,
+      context,
+      languages,
+      expressions,
+      spans,
+      balanced,
+      resultPath,
+      depths,
+      held,
+      node,
+    );
+  }
+
   getPublic() {
     let { languages, spans, depths, held, node, source, result, resultPath, status } = this;
-    return {
+
+    return Object.freeze({
       languages,
-      span: spans.value?.name,
-      depths: { ...depths },
+      span: Spans.getAt(-1, spans),
+      spans: spans,
+      depths: Object.freeze({ ...depths }),
       holding: !!held,
       held,
       node,
@@ -90,9 +110,9 @@ export const State = class BABLRState extends WeakStackFrame {
       done: source.done,
       sourceIndex: source.index,
       result,
-      resultPath,
+      resultPath: resultPath?.frames || null,
       status,
-    };
+    });
   }
 
   guardedMatch(pattern) {
@@ -101,6 +121,7 @@ export const State = class BABLRState extends WeakStackFrame {
 
     let branchedSource = false;
     let pattern_ = pattern;
+
     if (pattern.type === Matcher) {
       let { nodeMatcher } = reifyExpression(pattern.value);
 
@@ -143,8 +164,8 @@ export const State = class BABLRState extends WeakStackFrame {
     let {
       source,
       context,
-      balanced,
       spans,
+      balanced,
       resultPath,
       depths,
       held,
@@ -158,8 +179,8 @@ export const State = class BABLRState extends WeakStackFrame {
       context,
       languages,
       expressions,
-      balanced,
       spans,
+      balanced,
       resultPath,
       { ...depths },
       held,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,14 +12,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.10.0",
-    "@bablr/agast-vm": "0.11.0",
-    "@bablr/agast-vm-helpers": "0.10.0",
+    "@bablr/agast-helpers": "0.10.4",
+    "@bablr/agast-vm": "0.11.2",
+    "@bablr/agast-vm-helpers": "0.10.4",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.25.0",
-    "@bablr/regex-vm": "0.14.0",
+    "@bablr/helpers": "0.25.2",
+    "@bablr/regex-vm": "0.14.2",
     "@bablr/stream-iterator": "2.0.0",
-    "@bablr/weak-stack": "1.0.1",
     "@iter-tools/imm-stack": "1.2.0",
     "iter-tools-es": "7.5.3"
   },