@bablr/bablr-vm 0.22.1 → 0.23.1

package/lib/match.js

@@ -1,31 +1,45 @@
-import { resolveLanguage } from '@bablr/helpers/grammar';
+import { getProduction } from '@bablr/helpers/grammar';
 import { WeakStackFrame } from '@bablr/weak-stack';
 
-import { agast, TagPathFacade as TagPath, PathFacade as Path } from '@bablr/agast-vm';
+import { agast } from '@bablr/agast-vm';
+import * as Tags from '@bablr/agast-helpers/tags';
+import * as BTree from '@bablr/agast-helpers/btree';
 import {
-  buildOpenNodeTag,
-  buildProperty,
   buildReference,
-  fragmentFlags,
+  buildReferenceTag,
+  getFlagsWithGap,
   mergeReferences,
+  printBinding,
+  printType,
+  buildPropertyTag,
+  buildOpenFragmentTag,
+  nodeFlags,
+  streamFromTree,
 } from '@bablr/agast-helpers/tree';
-import { effectsFor } from '@bablr/agast-vm-helpers';
-import { FragmentFacade } from './node.js';
+import { effectsFor, reifyExpression, shouldBranch } from '@bablr/agast-vm-helpers';
 
 import { facades, actuals } from './facades.js';
 import {
   CloseNodeTag,
   OpenNodeTag,
-  ReferenceTag,
-  ShiftTag,
   AttributeDefinition,
   Property,
-  PropertyWrapper,
-  InitializerTag,
+  ReferenceTag,
   BindingTag,
-  LiteralTag,
+  ShiftTag,
+  TreeNode,
 } from '@bablr/agast-helpers/symbols';
-import { offsetForTag } from '@bablr/agast-helpers/path';
+import {
+  buildNullNode,
+  endsNode,
+  getCloseTag,
+  getTags,
+  has,
+  isMultiFragment,
+  Path,
+  TagPath,
+} from '@bablr/agast-helpers/path';
+import { updateSpans } from './spans.js';
 
 export class MatchFacade {
   constructor(match) {
@@ -53,6 +67,10 @@ export class MatchFacade {
     return actuals.get(this).propertyMatcher;
   }
 
+  get rawPropertyMatcher() {
+    return actuals.get(this).rawPropertyMatcher;
+  }
+
   get depth() {
     return actuals.get(this).depth;
   }
@@ -62,43 +80,7 @@ export class MatchFacade {
   }
 
   get fragment() {
-    const {
-      ctx,
-      effects,
-      isCoverBoundary,
-      isNode,
-      fragmentNode,
-      node,
-      mergedReference,
-      rangePreviousIndex,
-      rangeFinalIndex,
-    } = actuals.get(this);
-
-    const { name, isArray } = mergedReference;
-
-    let prev =
-      rangePreviousIndex != null
-        ? (fragmentNode || node).tags.at(rangePreviousIndex)
-        : rangePreviousIndex;
-
-    let offset = [ReferenceTag, ShiftTag].includes(prev?.type) ? 0 : 1;
-
-    if ((isNode || isCoverBoundary) && name) {
-      return new FragmentFacade(
-        effects.success !== 'none' ? fragmentNode : null,
-        ctx,
-        false,
-        true,
-        [rangePreviousIndex + offset, rangeFinalIndex],
-        mergedReference,
-        isArray ? fragmentNode.getChildPropertyIndex(rangePreviousIndex + offset) : null,
-      );
-    } else {
-      return new FragmentFacade(fragmentNode || node, ctx, false, true, [
-        rangePreviousIndex + offset,
-        rangeFinalIndex,
-      ]);
-    }
+    return actuals.get(this).fragment;
   }
 
   get pathDepth() {
@@ -109,13 +91,8 @@ export class MatchFacade {
     return actuals.get(this).pathName;
   }
 
-  get pathParent() {
-    return actuals.get(this).pathParent;
-  }
-
   get node() {
-    const { node, ctx } = actuals.get(this);
-    return FragmentFacade.wrap(node, ctx, false);
+    return actuals.get(this).node;
   }
 
   get props() {
@@ -150,6 +127,10 @@ export class MatchFacade {
     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);
   }
@@ -158,15 +139,6 @@ export class MatchFacade {
     return facades.get(actuals.get(this).coveredBoundary.shiftMatch);
   }
 
-  get captured() {
-    return actuals.get(this).captured;
-  }
-
-  get range() {
-    let { range } = actuals.get(this);
-    return range && [range[0], range[1]];
-  }
-
   get effects() {
     return actuals.get(this).effects;
   }
@@ -180,118 +152,186 @@ export class MatchFacade {
   }
 
   get state() {
-    return facades.get(actuals.get(this).state);
+    return actuals.get(this).s.getPublic();
   }
 
   get s() {
-    return facades.get(actuals.get(this).s);
+    return actuals.get(this).s.getPublic();
   }
 
-  get rangePrevious() {
-    return actuals.get(this).rangePrevious;
+  ancestors(...args) {
+    return actuals.get(this).ancestors(...args);
   }
+}
 
-  get rangePreviousIndex() {
-    return actuals.get(this).rangePreviousIndex;
-  }
+const normalizeBindingPath = (path) => {
+  if (path.length <= 1) return path;
+};
 
-  get rangeInitial() {
-    return actuals.get(this).rangeInitial;
-  }
+export class Match extends WeakStackFrame {
+  static startFrame(ctx, s, m, finishedMatch, verb, matcher, options) {
+    let effects = effectsFor(verb.description);
+    let isShift = verb.description.startsWith('shift'); // should this be didShift?
 
-  get rangeFinal() {
-    return actuals.get(this).rangeFinal;
-  }
+    let parentMatch = m;
 
-  get rangeFinalIndex() {
-    return actuals.get(this).rangeFinalIndex;
-  }
+    if (!s) throw new Error('not initialized');
 
-  get mergedLanguagePath() {
-    return actuals.get(this).mergedLanguagePath;
-  }
+    let matcher_ = reifyExpression(matcher);
 
-  ancestors(...args) {
-    return actuals.get(this).ancestors(...args);
+    if (parentMatch && parentMatch.cover && !parentMatch.isNode) {
+      if (matcher_.refMatcher) {
+        let m = matcher_.refMatcher;
+        if (!['_', '#'].includes(m.type) || m.flags.expression || m.flags.hasGap || m.flags.array) {
+          throw new Error('no references inside covers');
+        }
+      }
+    }
+
+    if (isShift && matcher_.nodeMatcher.type === '__') {
+      throw new Error();
+    }
+    if (isShift && !parentMatch) throw new Error();
+
+    if (shouldBranch(effects)) {
+      s = s.branch();
+    }
+
+    s.languages = isShift
+      ? finishedMatch.languages
+      : parentMatch
+      ? parentMatch.languages
+      : s.languages;
+
+    m = parentMatch
+      ? parentMatch.startFrame(s, matcher, effects, isShift ? finishedMatch : null, options)
+      : Match.from(ctx, s, matcher, null, options);
+
+    updateSpans(m, 'open');
+
+    if (m.name && !getProduction(m.grammar, m.name))
+      throw new Error(`Production {type: ${printType(m.name)}} does not exist`);
+
+    if (m.flags.token && !m.isNode) {
+      throw new Error('tokens must be nodes');
+    }
+
+    finishedMatch = null;
+
+    if (!m.parent && m.type === '__') {
+      s.node = m.rootNode;
+    }
+    return m;
   }
-}
 
-export class Match extends WeakStackFrame {
-  constructor(parent, context, language, state, matcher, effects, shiftMatch = null, options = {}) {
-    if (!context || !language || !state) {
+  constructor(parent, context, state, rawMatcher, effects, shiftMatch = null, options = {}) {
+    if (!context || !state) {
       throw new Error('Invalid arguments to Match constructor');
     }
+    let matcher = reifyExpression(rawMatcher);
 
     super(parent);
 
     this.context = context;
-    this.language = language;
     this.state = state;
+    this.rawPropertyMatcher = rawMatcher;
     this.propertyMatcher = matcher;
     this.effects = effects;
     this.shiftMatch = shiftMatch;
+    this.emittedMatch = parent?.emittedMatch || this;
 
-    this.rangePreviousIndex = null;
-    this.rangeFinalIndex = null;
     this.agast = null;
-    this.agastFragment = null; // why do it this way?
-    this.node = null;
     this.cover = null;
     this.running = null;
     this.options = options;
 
-    let isNode = !matcher.nodeMatcher.flags.fragment;
-    let isCover = matcher.nodeMatcher.flags.cover;
+    let isNode = !matcher.nodeMatcher.type;
+    let isCover = matcher.nodeMatcher.type === '_';
 
-    this.agast = isNode ? null : state.agast ?? null;
-    this.node = isNode ? null : parent?.node;
+    this.languages = state.languages;
+    this.nodeMatch = isNode || !parent ? this : parent.nodeMatch;
+    this.expressionMatch = shiftMatch
+      ? shiftMatch.expressionMatch
+      : parent?.expressionMatch || (matcher.refMatcher?.flags.expression ? this : null);
+    this.languageMatch =
+      normalizeBindingPath(matcher.bindingMatchers).length || !parent ? this : parent.languageMatch;
+    this.agast = null;
     this.cover =
-      effects.success === 'none'
-        ? null
-        : !parent?.isNode && parent?.cover
+      !parent?.isNode && parent?.cover && matcher.refMatcher?.type !== '#'
         ? parent.cover
         : isCover && parent
         ? this
         : null;
+    this.rootNode = null;
+    this.nodeDepth = (parent?.nodeDepth ?? 0) + (isNode ? 1 : 0);
+    this.parentPreviousTagPath = this.parent && TagPath.from(this.parent.path, -1, -1);
+    this.emitted = this.parent?.emitted || null;
 
-    if (isNode || !parent?.node) {
-      let held = null;
-      // TODO wat
-      if (this.coveredBoundary.shiftMatch) {
-        let { reference, binding, node } = state.held;
-        held = buildProperty(reference, binding, node.node);
-      }
-      this.agast = agast({ held });
-    } else {
-      this.agast = parent.agast;
-      if (effects.success === 'none') {
-        this.agast = agast();
-        this.agast.vm.next(buildOpenNodeTag(fragmentFlags));
+    if (!this.language) {
+      throw new Error(`Unknown language ${printBinding(matcher.bindingMatcher)}`);
+    }
+
+    let held = null;
+    if (this.coveredBoundary.shiftMatch) {
+      held = state.held;
+    }
+    this.agast = agast({ held });
+
+    let parentHasGap = !this.parent
+      ? this.matcher.flags.hasGap
+      : this.parent.nodeMatch.node.value.flags.hasGap;
+
+    this.agast.vm.next(buildOpenFragmentTag(parentHasGap ? getFlagsWithGap(nodeFlags) : nodeFlags));
+    if (!this.parent) {
+      if (isNode || isCover) {
+        this.agast.vm.next(buildReferenceTag());
       }
+    } else if (shiftMatch) {
+      this.agast.vm.next(shiftMatch.rootNode);
     }
+    this.rootNode = this.agast.getState().node;
 
     new MatchFacade(this);
   }
 
-  static from(context, language, state, matcher, props, options) {
-    return Match.create(context, language, state, matcher, effectsFor('eat'), props, options);
+  static from(context, state, matcher, props, options) {
+    return Match.create(context, state, matcher, effectsFor('eat'), props, options);
+  }
+
+  get language() {
+    return BTree.getAt(-1, this.languages);
+  }
+
+  get emitting() {
+    return this.emittedMatch === this;
   }
 
   get isCoverBoundary() {
-    let { cover } = this;
-    return cover === this;
+    let { cover, isNode } = this;
+    return cover === this || (!cover && isNode);
   }
 
   get matcher() {
     return this.propertyMatcher?.nodeMatcher;
   }
 
+  get node() {
+    let { rootNode } = this;
+
+    if (this.matcher.type === '__') {
+      return rootNode;
+    }
+    if (Tags.getSize(getTags(rootNode)) <= 1) return null;
+
+    return Tags.getAt(-1, rootNode.value.children).value.node;
+  }
+
   get vm() {
     return this.agast.vm;
   }
 
   get mergedReference() {
-    let ref = buildReference('.');
+    let ref = buildReference();
 
     let first = true;
     let m = this;
@@ -305,7 +345,7 @@ export class Match extends WeakStackFrame {
 
         if (lastName && (lastName !== name || lastRefType !== refType)) break;
         ref = ['#', '@'].includes(ref.type) ? ref : mergeReferences(ref, parentRef);
-        if (refType !== '.') {
+        if (refType !== '_') {
           lastName = name;
           lastRefType = refType;
         }
@@ -316,22 +356,6 @@ export class Match extends WeakStackFrame {
     return ref;
   }
 
-  get mergedLanguagePath() {
-    let languagePath = [];
-
-    let first = true;
-    let m = this;
-    do {
-      if (m.isNode && !first) break;
-      if (m.propertyMatcher.bindingMatcher) {
-        languagePath = m.propertyMatcher.bindingMatcher.languagePath.concat(languagePath);
-      }
-      first = false;
-    } while ((m = m.shiftMatch || m.parent));
-
-    return Object.freeze(languagePath);
-  }
-
   get pathName() {
     return this.mergedReference.name;
   }
@@ -339,26 +363,13 @@ export class Match extends WeakStackFrame {
   get path() {
     let { agast } = this;
 
-    return agast.state.path || agast.state.resultPath?.path;
-  }
-
-  get pathParent() {
-    let m = this;
-
-    do {
-      m = m.parent;
-    } while (m && !m.isNode);
-    return m;
+    return agast.getState().path || agast.getState().resultPath?.path;
   }
 
   get coveredBoundary() {
     return this.cover || this;
   }
 
-  get parentPath() {
-    return this.pathParent?.path;
-  }
-
   get ctx() {
     return this.context;
   }
@@ -375,153 +386,90 @@ export class Match extends WeakStackFrame {
     return this.matcher?.type || null;
   }
 
-  get flags() {
-    return this.matcher?.flags;
+  get name() {
+    return this.matcher?.name || null;
   }
 
-  get captured() {
-    return !this.rangePrevious || !!this.rangeFinal;
+  get flags() {
+    return this.matcher?.flags;
   }
 
   get allowEmpty() {
-    return !!this.grammar.emptyables?.has(this.type) || this.options.allowEmpty;
-  }
-
-  get fragmentNode() {
-    if (!this.agastFragment) return null;
-
-    let { node, resultPath } = this.agastFragment.state;
-    return resultPath?.tag.type === CloseNodeTag ? resultPath.node : node;
+    return !!this.grammar.emptyables?.has(this.name) || this.options.allowEmpty;
   }
 
-  get fragmentPath() {
-    if (!this.agastFragment) return null;
-
-    let { path, resultPath } = this.agastFragment.state;
-    return resultPath?.tag.type === CloseNodeTag ? resultPath.path : path;
-  }
-
-  get rangePrevious() {
-    let path = this.fragmentPath || this.path;
-
-    return this.rangePreviousIndex == null || path == null
-      ? null
-      : TagPath.from(path, this.rangePreviousIndex, -1);
-  }
-
-  setRangePreviousIndex(value) {
-    if ((value != null && !Number.isFinite(value)) || value < 0) throw new Error();
-    this.rangePreviousIndex = value;
-    if (
-      value != null &&
-      (!this.rangePrevious ||
-        (this.isNode &&
-          ![OpenNodeTag, Property, InitializerTag, LiteralTag, AttributeDefinition].includes(
-            this.rangePrevious.tag.type,
-          )))
-    )
-      throw new Error();
+  get didShift() {
+    return !!this.shiftMatch;
   }
 
-  setRangeFinalIndex(value) {
-    if (value != null && !Number.isFinite(value)) throw new Error();
-    this.rangeFinalIndex = value;
-    this.rangeFinal;
+  get isNode() {
+    return !this.matcher.type;
   }
 
-  get rangeFinal() {
-    let path = this.fragmentPath || this.path;
-
-    return this.rangeFinalIndex == null || path == null
-      ? null
-      : TagPath.from(path, this.rangeFinalIndex, -1);
+  get isCover() {
+    return this.propertyMatcher.nodeMatcher.type === '_';
   }
 
-  get rangeInitial() {
-    const { rangePrevious, isNode, fragmentPath, path, rangePreviousIndex } = this;
-
-    if (!rangePrevious) return rangePrevious;
-
-    if (isNode) return TagPath.from(fragmentPath || path, rangePreviousIndex + 1, 0);
+  advance(tag) {
+    let { vm, getState } = this.agast;
+    let s = this.state;
 
-    return rangePrevious?.nextSibling;
-  }
+    let result = vm.next(tag);
 
-  get range() {
-    const { rangeInitial, rangeFinal } = this;
-    return rangeInitial === null ? null : [rangeInitial, rangeFinal];
-  }
+    if (!result || result.done) throw new Error();
 
-  get didShift() {
-    return !!this.shiftMatch;
-  }
+    let agastState = getState();
 
-  get referencePath() {
-    if (!(this.isNode || this.isCoverBoundary || this.cover) || this.state.depths.path < 0) {
-      return null;
+    if (tag.type === OpenNodeTag) {
+      s.depths.result++;
+    } else if (tag.type === CloseNodeTag) {
+      s.depths.result--;
     }
 
-    let parentPath = this.fragmentPath || this.path;
-
-    let ref = TagPath.from(parentPath, this.rangePreviousIndex + 1, 0);
-
-    if (!ref) return null;
-
-    if (ref.tag.type === ShiftTag) {
-      let refIndex = ref.tagsIndex - ref.tag.value.index;
-      ref = TagPath.from(ref.path, refIndex, 0);
-    }
+    this.rootNode = agastState.path.atDepth(0).node;
 
-    if (ref && ref.tag.type !== ReferenceTag) throw new Error();
-    return ref;
-  }
+    s.resultPath = agastState.resultPath;
 
-  get isNode() {
-    let { flags } = this.matcher;
-    return !this.parent || !flags.fragment;
-  }
+    // if (this.emitted?.depth > 1) throw new Error();
 
-  get isCover() {
-    return this.cover === this;
-  }
+    if (this.emittedMatch === this) {
+      let emittedPath = this.emitted || null;
 
-  advance(tag, s = this.state) {
-    let { vm, state: agastState } = s.agast;
+      let newEmitted = emittedPath && emittedPath.mapOnto(this.rootNode);
 
-    let result = vm.next(tag);
+      if (emittedPath) {
+        if (!newEmitted) throw new Error();
+        // if (newEmitted.tag.depth !== this.emitted.tag.depth) throw new Error();
+      }
 
-    if (tag.type === OpenNodeTag) {
-      s.depths.result++;
-      this.node = s.node || s.resultPath.node;
-    } else if (tag.type === CloseNodeTag) {
-      s.depths.result--;
+      this.emitted = newEmitted;
     }
 
-    s.resultPath =
-      (agastState.path || agastState.resultPath?.path) &&
-      TagPath.from(
-        agastState.path || agastState.resultPath?.path,
-        -1,
-        tag.type === PropertyWrapper ? -1 : offsetForTag(tag),
-      );
     return result.value;
   }
 
-  startFrame(state, propertyMatcher, effects, shiftMatch, options) {
+  startFrame(state, rawMatcher, effects, shiftMatch, options) {
     let { context } = this;
-    const { bindingMatcher } = propertyMatcher;
 
-    let language = shiftMatch?.language ?? this.language;
+    let language = this.language;
+
+    // TODO stop wasting CPU cycles doing this twice or more!
+    let matcher = reifyExpression(rawMatcher);
+    let { bindingMatchers } = matcher;
 
-    if (bindingMatcher) {
-      language = resolveLanguage(context, language, bindingMatcher.languagePath);
+    for (let bindingMatcher of bindingMatchers) {
+      let { segments } = bindingMatcher || { segments: [] };
 
-      if (!language) {
-        throw new Error(`Unknown language ${bindingMatcher.languagePath.join('.')}`);
+      for (let segment of segments) {
+        language = segment.type
+          ? BTree.getAt(-2, state.languages)
+          : language.dependencies[segment.name];
       }
+
+      state.languages = BTree.push(state.languages, language);
     }
 
-    let m = this.push(context, language, state, propertyMatcher, effects, shiftMatch, options);
+    let m = this.push(context, state, rawMatcher, effects, shiftMatch, options);
 
     this.running = m;
 
@@ -531,55 +479,129 @@ export class Match extends WeakStackFrame {
   endFrame() {
     const finishedMatch = this;
     const m = finishedMatch.parent;
+    let s = finishedMatch.state;
+
+    if (finishedMatch.shiftMatch) {
+      s.held = null;
+    }
+
+    let matchers = finishedMatch.propertyMatcher.bindingMatchers || [];
+
+    for (let matcher of matchers) {
+      let { segments } = matcher;
+      let normalizedSegments = normalizeBindingPath(segments);
+      if (normalizedSegments.length) {
+        finishedMatch.state.languages = BTree.pop(finishedMatch.state.languages);
+      }
+    }
 
     if (!m) return m;
 
-    finishedMatch.setRangeFinalIndex((finishedMatch.fragmentNode || m.node).tags.size - 1);
+    updateSpans(finishedMatch, 'close');
 
-    m.running = null;
+    if (shouldBranch(finishedMatch.effects)) {
+      if (finishedMatch.effects.success !== 'none') {
+        s = s.accept();
+      } else {
+        s = s.reject(finishedMatch);
+      }
+    }
+
+    m.emitted = finishedMatch.emitted;
+    m.emittedMatch = finishedMatch.emittedMatch;
+
+    if (finishedMatch.effects.success !== 'none') {
+      // for a shift, only copy the parts of the stack that aren't already present from the last successful shift frame
+
+      if (finishedMatch.shiftMatch) {
+        let property = Tags.getAt(-2, finishedMatch.rootNode.value.tags);
+        s.node = property.value.node;
+        m.advance(property.value.tags[0]);
+        for (let bindingTag of property.value.tags[1]) {
+          m.advance(bindingTag);
+        }
+        m.advance(property.value.node);
+      } else {
+        s.node = finishedMatch.rootNode;
+        m.advance(s.node);
+      }
+    }
 
     return m;
   }
 
   throw_() {
-    const finishedMatch = this;
-    const m = finishedMatch.parent;
+    let { bind } = this.options;
+    let finishedMatch = this;
+    let m = finishedMatch.parent;
+    let s = finishedMatch.state;
 
     if (!m) return m;
 
     m.running = null;
 
-    finishedMatch.setRangePreviousIndex(null);
+    // TODO don't do this if we're falling back to a successful shift either
+    if (bind) {
+      for (let tag of Tags.traverse(this.rootNode.value.children)) {
+        if (tag.type === Property) {
+          let { reference, shift, tags } = tag.value;
+
+          if (
+            !['#', '@'].includes(reference.type) &&
+            !reference.flags.array &&
+            !has(reference.name, m.node) &&
+            !shift
+          ) {
+            m.advance(buildPropertyTag([tags[0], [], buildNullNode()]));
+          }
+        }
+      }
+    }
+
+    if (s.status === 'active') {
+      s.reject(finishedMatch);
+    }
+
+    // restore successful parts of shift stack here
+
+    // if (
+    //   finishedMatch.isCoverBoundary &&
+    //   finishedMatch.shiftMatch &&
+    //   finishedMatch.effects.failure === 'none'
+    // ) {
+    //   m.advance(finishedMatch.shiftMatch.rootNode);
+
+    //   s.node = finishedMatch.shiftMatch.node;
+    // }
+
+    m.state.resultPath = TagPath.fromNode(m.state.node, -1);
 
     return m;
   }
 
   *emit(options) {
-    let { state } = this;
-    let { emitted } = state;
+    let { state, emitted, emittedMatch } = this;
 
-    let m = emitted?.match ?? this;
+    let m = emittedMatch;
 
     if (!state.depth) {
-      let { node } = m;
+      let node = m.node || m.rootNode;
 
-      // if (!node) {
-      //   node = resultPath.node;
-      // }
-
-      let path = Path.from(node);
-
-      let tagPath = emitted?.tagPath || (path.node.tags.size ? TagPath.from(path, 0) : null);
+      let tagPath = emitted
+        ? emitted
+        : Tags.getSize(getTags(node))
+        ? TagPath.fromNode(m.rootNode, 0)
+        : null;
 
       while (tagPath) {
-        if (
-          options.holdUndefinedAttributes &&
-          tagPath.tag.type === OpenNodeTag &&
-          tagPath.tag.value.type &&
-          (m.node.undefinedAttributes ?? 0) > 0
-        ) {
-          break;
-        }
+        // if (
+        //   options.holdUndefinedAttributes &&
+        //   tagPath.tag.type === OpenNodeTag &&
+        //   tagPath.tag.value.name
+        //   && (countUndefinedAttributes(m.node) ?? 0) > 0
+        // ) {
+        //   break;
+        // }
 
         if (
           tagPath.tag.type === OpenNodeTag &&
@@ -588,70 +610,191 @@ export class Match extends WeakStackFrame {
         )
           break;
 
-        let holdShifted =
+        let holdingShifted =
           options.holdShiftedNodes &&
           tagPath.tag.type === ReferenceTag &&
-          tagPath.tag.value.flags.expression;
+          tagPath.tag.value.flags.expression &&
+          tagPath.depth <= 1;
 
-        if (!state.emitted || !tagPath.equalTo(state.emitted.tagPath)) {
-          state.emitted = emitted = { match: m, tagPath };
+        if (holdingShifted) {
+          if (!tagPath.equalTo(m.emitted)) {
+            m.emitted = emitted = tagPath;
+            this.emittedMatch = m;
 
-          if (tagPath.tag.type === OpenNodeTag) {
-            state.depths.emitted++;
-          } else if (tagPath.tag.type === CloseNodeTag) {
-            state.depths.emitted--;
+            yield tagPath.tag;
           }
 
+          if (
+            m.expressionMatch &&
+            (m.expressionMatch.running || !getCloseTag(m.expressionMatch.rootNode))
+          ) {
+            break;
+          } else {
+            let { parentPreviousTagPath } = m;
+            let nextTag =
+              parentPreviousTagPath &&
+              Tags.getAt(parentPreviousTagPath.tagsIndex + 2, m.parent.node.value.tags);
+
+            let doneShifting = !(nextTag?.type === Property && nextTag.value.shift);
+
+            // todo monomorph
+            let shiftIndex = nextTag?.type === Property ? nextTag?.value.shift?.index ?? 0 : 0;
+            while (!doneShifting && nextTag) {
+              nextTag =
+                Tags.getAt(
+                  [parentPreviousTagPath.tagsIndex + 2 + shiftIndex, 1],
+                  m.parent.node.value.tags,
+                ) ||
+                Tags.getAt(
+                  parentPreviousTagPath.tagsIndex + 2 + shiftIndex,
+                  m.parent.node.value.tags,
+                );
+              doneShifting = nextTag && !(nextTag.type === Property && nextTag.value.shift);
+              if (!doneShifting) {
+                shiftIndex++;
+              }
+            }
+
+            if ((parentPreviousTagPath && !nextTag) || !doneShifting) {
+              break;
+            } else {
+              if (m.parent.rootNode) {
+                if (shiftIndex) {
+                  m = m.parent;
+                  tagPath = Path.from(m.rootNode)
+                    .tagPathAt(1)
+                    .inner.tagPathAt(1 + shiftIndex, 0).nextSibling;
+                  if (tagPath?.tag.type === TreeNode) {
+                    tagPath = tagPath.inner.tagPathAt(0);
+                  }
+                }
+              }
+
+              if (!tagPath) break;
+            }
+          }
+        }
+
+        if (tagPath.depth === 0 && endsNode(tagPath.tag)) {
+          let finishedMatch = m;
+          m = m.parent;
+
+          let parentRoot = Path.from(m.rootNode);
+
+          if (m.type !== '__') {
+            parentRoot = parentRoot.tagPathAt(getCloseTag(m.rootNode) ? -2 : -1).inner;
+          }
+
+          let finishedChildren =
+            finishedMatch.type !== '__' ? 1 : Tags.getSize(finishedMatch.rootNode.value.children);
+
+          let parentNextTagPath = parentRoot?.tagPathAt(
+            finishedMatch.parentPreviousTagPath.tagsIndex + finishedChildren + 1,
+          );
+
+          tagPath = parentNextTagPath;
+
+          if (!tagPath) {
+            if (m.running) {
+              m = m.running;
+
+              let shiftIndex =
+                finishedMatch.parentPreviousTagPath.tag.type === Property &&
+                finishedMatch.parentPreviousTagPath.tag.value.shift
+                  ? finishedMatch.parentPreviousTagPath.tag.value.shift.index
+                  : m.didShift
+                  ? 1
+                  : 0;
+
+              tagPath = TagPath.fromNode(m.rootNode, 1 + shiftIndex);
+            }
+          }
+
+          if (tagPath?.tag.type === Property) {
+            tagPath = tagPath.next;
+          }
+          continue;
+        }
+
+        if (!m.emitted || !tagPath.equalTo(m.emitted)) {
           if (
             !(
-              (tagPath.tag.type === BindingTag && !tagPath.tag.value.languagePath?.length) ||
-              (tagPath.tag.type === AttributeDefinition && options.holdUndefinedAttributes)
+              [OpenNodeTag, CloseNodeTag].includes(tagPath.tag.type) &&
+              tagPath.depth === 0 &&
+              isMultiFragment(tagPath.node) &&
+              (m.depth || !(m.matcher.type === '__'))
             )
           ) {
-            yield tagPath.tag;
+            m.emitted = emitted = tagPath;
+            this.emittedMatch = m;
+
+            if (tagPath.tag.type === OpenNodeTag && !tagPath.tag.value.selfClosing) {
+              state.depths.emitted++;
+            } else if (tagPath.tag.type === CloseNodeTag) {
+              state.depths.emitted--;
+            }
+
+            if (
+              tagPath.tag.type !== Property &&
+              !(tagPath.tag.type === BindingTag && !tagPath.tag.value.segments?.length) &&
+              !(tagPath.tag.type === ShiftTag && options.holdShiftedNodes) &&
+              !(tagPath.tag.type === AttributeDefinition && options.holdUndefinedAttributes) &&
+              !(m.depth === 0 && !tagPath.depth && tagPath.tag.type === ReferenceTag)
+            ) {
+              yield tagPath.tag;
+            }
           }
         }
 
         if (
-          (tagPath.tag.type === CloseNodeTag ||
-            (tagPath.tag.type === OpenNodeTag && tagPath.tag.value.selfClosing)) &&
-          !tagPath.next
+          endsNode(tagPath.tag) ||
+          (!holdingShifted && !tagPath.nextSibling && !tagPath.tag.type === Property)
         ) {
-          tagPath = TagPath.from(m.fragmentPath, m.rangeInitial.tagsIndex + 1, 0);
+          let nextPath = tagPath.next;
+          if (nextPath) {
+            tagPath = nextPath;
+            continue;
+          }
 
           do {
-            m = m.parent;
-          } while (m && !m.isNode);
+            if (m.running) {
+              m = m.running;
+              // TODO is -1 ok
+              let shiftIndex = m.didShift ? -1 : 0;
+              tagPath = TagPath.fromNode(m.rootNode, shiftIndex);
+            } else if (m.parent && (!m.parent.running || m.parent.running !== m)) {
+              tagPath = m.parentPreviousTagPath;
+
+              tagPath = TagPath.from(
+                tagPath.path,
+                tagPath.tagsIndex +
+                  1 +
+                  (m.matcher.type === '__' ? Tags.getSize(m.rootNode.value.children) : 1),
+                0,
+              );
+
+              m = m.parent;
+            } else {
+              m = null;
+              break;
+            }
+          } while (m && !tagPath);
 
           if (!m) break;
 
           continue;
         }
 
-        if (!holdShifted && tagPath.tag.type === ReferenceTag && !tagPath.nextSibling) {
-          let { running } = m;
-
-          while (running && !running.isNode) {
-            if (running.state.depth > 0) {
-              running = null;
-              break;
-            } else {
-              running = running.running;
-            }
-          }
+        tagPath =
+          tagPath.tag.type === Property
+            ? tagPath.nextProperty?.next || tagPath.nextSibling
+            : options.holdShiftedNodes
+            ? tagPath.nextUnshifted
+            : tagPath.next;
 
-          if (running) {
-            m = running;
-          } else {
-            break;
-          }
-          tagPath = TagPath.from(m.path, 0);
-        } else {
-          if (holdShifted) {
-            tagPath = tagPath.nextUnshifted;
-          } else {
-            tagPath = tagPath.next;
-          }
+        if (!tagPath && m.running) {
+          m = m.running;
+          tagPath = TagPath.fromNode(m.rootNode, 0);
         }
       }
     }