ember-source 6.4.0-alpha.2 → 6.4.0-alpha.3

package/dist/packages/shared-chunks/{transform-resolutions-O6uYv8DS.js → transform-resolutions-Dpc2ClA0.js}

@@ -1,5 +1,5 @@
 import '../@ember/debug/index.js';
-import { assert as debugAssert, isPresentArray, assertNever, getFirst, getLast, assign, dict, unwrap, asPresentArray, assertPresentArray, deprecate, expect } from '../@glimmer/util/index.js';
+import { assertNever, assign, dict } from '../@glimmer/util/index.js';
 import { SexpOpcodes as opcodes } from '../@glimmer/wire-format/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 import calculateLocationDisplay from '../@ember/template-compiler/lib/system/calculate-location-display.js';
@@ -5049,20 +5049,19 @@ var EventedTokenizer = /** @class */function () {
   return EventedTokenizer;
 }();
 
-var Char = function (Char) {
-  return Char[Char.NBSP = 160] = "NBSP", Char[Char.QUOT = 34] = "QUOT", Char[Char.LT = 60] = "LT", Char[Char.GT = 62] = "GT", Char[Char.AMP = 38] = "AMP", Char;
-}(Char || {});
-const ATTR_VALUE_REGEX_TEST = /["&\xA0]/u,
+const ATTR_VALUE_REGEX_TEST = /["\x26\xa0]/u,
   ATTR_VALUE_REGEX_REPLACE = new RegExp(ATTR_VALUE_REGEX_TEST.source, "gu"),
-  TEXT_REGEX_TEST = /[&<>\xA0]/u,
+  TEXT_REGEX_TEST = /[&<>\xa0]/u,
   TEXT_REGEX_REPLACE = new RegExp(TEXT_REGEX_TEST.source, "gu");
+
+// \x26 is ampersand, \xa0 is non-breaking space
 function attrValueReplacer(char) {
   switch (char.charCodeAt(0)) {
-    case Char.NBSP:
+    case 160:
       return "&nbsp;";
-    case Char.QUOT:
+    case 34:
       return "&quot;";
-    case Char.AMP:
+    case 38:
       return "&amp;";
     default:
       return char;
@@ -5070,13 +5069,13 @@ function attrValueReplacer(char) {
 }
 function textReplacer(char) {
   switch (char.charCodeAt(0)) {
-    case Char.NBSP:
+    case 160:
       return "&nbsp;";
-    case Char.AMP:
+    case 38:
       return "&amp;";
-    case Char.LT:
+    case 60:
       return "&lt;";
-    case Char.GT:
+    case 62:
       return "&gt;";
     default:
       return char;
@@ -5101,10 +5100,8 @@ function isVoidTag(tag) {
   return voidMap.has(tag.toLowerCase()) && tag[0]?.toLowerCase() === tag[0];
 }
 class Printer {
-  buffer = "";
-  options;
   constructor(options) {
-    this.options = options;
+    this.buffer = "", this.options = options;
   }
   /*
   This is used by _all_ methods on this Printer class that add to `this.buffer`,
@@ -5327,10 +5324,10 @@ class Printer {
     this.handledByOverride(str) || (this.buffer += JSON.stringify(str.value));
   }
   BooleanLiteral(bool) {
-    this.handledByOverride(bool) || (this.buffer += bool.value);
+    this.handledByOverride(bool) || (this.buffer += String(bool.value));
   }
   NumberLiteral(number) {
-    this.handledByOverride(number) || (this.buffer += number.value);
+    this.handledByOverride(number) || (this.buffer += String(number.value));
   }
   UndefinedLiteral(node) {
     this.handledByOverride(node) || (this.buffer += "undefined");
@@ -5352,6 +5349,7 @@ class Printer {
 function build(ast, options = {
   entityEncoding: "transformed"
 }) {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- JS users
   return ast ? new Printer(options).print(ast) : "";
 }
 function isKeyword(word, type) {
@@ -5363,28 +5361,39 @@ function isKeyword(word, type) {
  * language, and where their valid usages are.
  */
 const KEYWORDS_TYPES = {
-    action: ["Call", "Modifier"],
-    component: ["Call", "Append", "Block"],
-    debugger: ["Append"],
-    "each-in": ["Block"],
-    each: ["Block"],
-    "has-block-params": ["Call", "Append"],
-    "has-block": ["Call", "Append"],
-    helper: ["Call", "Append"],
-    if: ["Call", "Append", "Block"],
-    "in-element": ["Block"],
-    let: ["Block"],
-    log: ["Call", "Append"],
-    modifier: ["Call", "Modifier"],
-    mount: ["Append"],
-    mut: ["Call", "Append"],
-    outlet: ["Append"],
-    readonly: ["Call", "Append"],
-    unbound: ["Call", "Append"],
-    unless: ["Call", "Append", "Block"],
-    yield: ["Append"]
-  },
-  UNKNOWN_POSITION = Object.freeze({
+  action: ["Call", "Modifier"],
+  component: ["Call", "Append", "Block"],
+  debugger: ["Append"],
+  "each-in": ["Block"],
+  each: ["Block"],
+  "has-block-params": ["Call", "Append"],
+  "has-block": ["Call", "Append"],
+  helper: ["Call", "Append"],
+  if: ["Call", "Append", "Block"],
+  "in-element": ["Block"],
+  let: ["Block"],
+  log: ["Call", "Append"],
+  modifier: ["Call", "Modifier"],
+  mount: ["Append"],
+  mut: ["Call", "Append"],
+  outlet: ["Append"],
+  readonly: ["Call", "Append"],
+  unbound: ["Call", "Append"],
+  unless: ["Call", "Append", "Block"],
+  yield: ["Append"]
+};
+
+// import Logger from './logger';
+function isPresentArray(list) {
+  return !!list && list.length > 0;
+}
+function getLast(list) {
+  return 0 === list.length ? void 0 : list[list.length - 1];
+}
+function getFirst(list) {
+  return 0 === list.length ? void 0 : list[0];
+}
+const UNKNOWN_POSITION = Object.freeze({
     line: 1,
     column: 0
   }),
@@ -5403,20 +5412,7 @@ const KEYWORDS_TYPES = {
     start: UNKNOWN_POSITION,
     end: UNKNOWN_POSITION
   });
-let OffsetKind = function (OffsetKind) {
-  return OffsetKind.CharPosition = "CharPosition", OffsetKind.HbsPosition = "HbsPosition", OffsetKind.InternalsSynthetic = "InternalsSynthetic", OffsetKind.NonExistent = "NonExistent", OffsetKind.Broken = "Broken", OffsetKind;
-}({});
-
-/**
- * This file implements the DSL used by span and offset in places where they need to exhaustively
- * consider all combinations of states (Handlebars offsets, character offsets and invisible/broken
- * offsets).
- *
- * It's probably overkill, but it makes the code that uses it clear. It could be refactored or
- * removed.
- */
 class WhenList {
-  _whens;
   constructor(whens) {
     this._whens = whens;
   }
@@ -5429,7 +5425,6 @@ class WhenList {
   }
 }
 class When {
-  _map = new Map();
   get(pattern, or) {
     let value = this._map.get(pattern);
     return value || (value = or(), this._map.set(pattern, value), value);
@@ -5440,9 +5435,9 @@ class When {
   match(kind) {
     const pattern = function (kind) {
         switch (kind) {
-          case OffsetKind.Broken:
-          case OffsetKind.InternalsSynthetic:
-          case OffsetKind.NonExistent:
+          case "Broken":
+          case "InternalsSynthetic":
+          case "NonExistent":
             return "IS_INVISIBLE";
           default:
             return kind;
@@ -5453,30 +5448,32 @@ class When {
       fallback = this._map.get("MATCH_ANY");
     return exact && out.push(exact), fallback && out.push(fallback), out;
   }
+  constructor() {
+    this._map = new Map();
+  }
 }
 function match(callback) {
-  return callback(new Matcher()).check();
+  return callback(new Matcher()).validate();
 }
 class Matcher {
-  _whens = new When();
   /**
   * You didn't exhaustively match all possibilities.
   */
-  check() {
+  validate() {
     return (left, right) => this.matchFor(left.kind, right.kind)(left, right);
   }
   matchFor(left, right) {
     const nesteds = this._whens.match(left);
-    debugAssert(isPresentArray(nesteds), `no match defined for (${left}, ${right}) and no AnyMatch defined either`);
-    const callback = new WhenList(nesteds).first(right);
-    return debugAssert(null !== callback, `no match defined for (${left}, ${right}) and no AnyMatch defined either`), callback;
-  }
-  // This big block is the bulk of the heavy lifting in this file. It facilitates exhaustiveness
-  // checking so that matchers can ensure they've actually covered all the cases (and TypeScript
-  // will treat it as an exhaustive match).
-  when(left, right, callback) {
+    return isPresentArray(), new WhenList(nesteds).first(right);
+  }
+  when(left, right,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callback) {
     return this._whens.get(left, () => new When()).add(right, callback), this;
   }
+  constructor() {
+    this._whens = new When();
+  }
 }
 class SourceSlice {
   static synthetic(chars) {
@@ -5492,8 +5489,6 @@ class SourceSlice {
       chars: slice[0]
     });
   }
-  chars;
-  loc;
   constructor(options) {
     this.loc = options.loc, this.chars = options.chars;
   }
@@ -5505,9 +5500,6 @@ class SourceSlice {
   }
 }
 
-/**
- * All spans have these details in common.
- */
 /**
  * A `SourceSpan` object represents a span of characters inside of a template source.
  *
@@ -5544,10 +5536,10 @@ class SourceSlice {
  */
 class SourceSpan {
   static get NON_EXISTENT() {
-    return new InvisibleSpan(OffsetKind.NonExistent, NON_EXISTENT_LOCATION).wrap();
+    return new InvisibleSpan("NonExistent", NON_EXISTENT_LOCATION).wrap();
   }
   static load(source, serialized) {
-    return "number" == typeof serialized ? SourceSpan.forCharPositions(source, serialized, serialized) : "string" == typeof serialized ? SourceSpan.synthetic(serialized) : Array.isArray(serialized) ? SourceSpan.forCharPositions(source, serialized[0], serialized[1]) : serialized === OffsetKind.NonExistent ? SourceSpan.NON_EXISTENT : serialized === OffsetKind.Broken ? SourceSpan.broken(BROKEN_LOCATION) : void assertNever(serialized);
+    return "number" == typeof serialized ? SourceSpan.forCharPositions(source, serialized, serialized) : "string" == typeof serialized ? SourceSpan.synthetic(serialized) : Array.isArray(serialized) ? SourceSpan.forCharPositions(source, serialized[0], serialized[1]) : "NonExistent" === serialized ? SourceSpan.NON_EXISTENT : "Broken" === serialized ? SourceSpan.broken(BROKEN_LOCATION) : void assertNever(serialized);
   }
   static forHbsLoc(source, loc) {
     const start = new HbsPosition(source, loc.start),
@@ -5566,14 +5558,22 @@ class SourceSpan {
     }).wrap();
   }
   static synthetic(chars) {
-    return new InvisibleSpan(OffsetKind.InternalsSynthetic, NON_EXISTENT_LOCATION, chars).wrap();
+    return new InvisibleSpan("InternalsSynthetic", NON_EXISTENT_LOCATION, chars).wrap();
   }
   static broken(pos = BROKEN_LOCATION) {
-    return new InvisibleSpan(OffsetKind.Broken, pos).wrap();
+    return new InvisibleSpan("Broken", pos).wrap();
   }
-  isInvisible;
   constructor(data) {
-    this.data = data, this.isInvisible = data.kind !== OffsetKind.CharPosition && data.kind !== OffsetKind.HbsPosition;
+    var kind;
+    /**
+    * This file implements the DSL used by span and offset in places where they need to exhaustively
+    * consider all combinations of states (Handlebars offsets, character offsets and invisible/broken
+    * offsets).
+    *
+    * It's probably overkill, but it makes the code that uses it clear. It could be refactored or
+    * removed.
+    */
+    this.data = data, this.isInvisible = "CharPosition" !== (kind = data.kind) && "HbsPosition" !== kind;
   }
   getStart() {
     return this.data.getStart().wrap();
@@ -5713,10 +5713,9 @@ class SourceSpan {
   }
 }
 class CharPositionSpan {
-  kind = OffsetKind.CharPosition;
-  _locPosSpan = null;
+  #locPosSpan;
   constructor(source, charPositions) {
-    this.source = source, this.charPositions = charPositions;
+    this.source = source, this.charPositions = charPositions, this.kind = "CharPosition", this.#locPosSpan = null;
   }
   wrap() {
     return new SourceSpan(this);
@@ -5735,11 +5734,11 @@ class CharPositionSpan {
   }
   locDidUpdate() {}
   toHbsSpan() {
-    let locPosSpan = this._locPosSpan;
+    let locPosSpan = this.#locPosSpan;
     if (null === locPosSpan) {
       const start = this.charPositions.start.toHbsPos(),
         end = this.charPositions.end.toHbsPos();
-      locPosSpan = this._locPosSpan = null === start || null === end ? BROKEN : new HbsSpan(this.source, {
+      locPosSpan = this.#locPosSpan = null === start || null === end ? BROKEN : new HbsSpan(this.source, {
         start: start,
         end: end
       });
@@ -5762,24 +5761,23 @@ class CharPositionSpan {
   }
 }
 class HbsSpan {
-  kind = OffsetKind.HbsPosition;
-  _charPosSpan = null;
+  #charPosSpan;
   // the source location from Handlebars + AST Plugins -- could be wrong
-  _providedHbsLoc;
+  #providedHbsLoc;
   constructor(source, hbsPositions, providedHbsLoc = null) {
-    this.source = source, this.hbsPositions = hbsPositions, this._providedHbsLoc = providedHbsLoc;
+    this.source = source, this.hbsPositions = hbsPositions, this.kind = "HbsPosition", this.#charPosSpan = null, this.#providedHbsLoc = providedHbsLoc;
   }
   serialize() {
     const charPos = this.toCharPosSpan();
-    return null === charPos ? OffsetKind.Broken : charPos.wrap().serialize();
+    return null === charPos ? "Broken" : charPos.wrap().serialize();
   }
   wrap() {
     return new SourceSpan(this);
   }
   updateProvided(pos, edge) {
-    this._providedHbsLoc && (this._providedHbsLoc[edge] = pos),
+    this.#providedHbsLoc && (this.#providedHbsLoc[edge] = pos),
     // invalidate computed character offsets
-    this._charPosSpan = null, this._providedHbsLoc = {
+    this.#charPosSpan = null, this.#providedHbsLoc = {
       start: pos,
       end: pos
     };
@@ -5813,12 +5811,12 @@ class HbsSpan {
     return this;
   }
   toCharPosSpan() {
-    let charPosSpan = this._charPosSpan;
+    let charPosSpan = this.#charPosSpan;
     if (null === charPosSpan) {
       const start = this.hbsPositions.start.toCharPos(),
         end = this.hbsPositions.end.toCharPos();
-      if (!start || !end) return charPosSpan = this._charPosSpan = BROKEN, null;
-      charPosSpan = this._charPosSpan = new CharPositionSpan(this.source, {
+      if (!start || !end) return charPosSpan = this.#charPosSpan = BROKEN, null;
+      charPosSpan = this.#charPosSpan = new CharPositionSpan(this.source, {
         start: start,
         end: end
       });
@@ -5836,10 +5834,10 @@ class InvisibleSpan {
   }
   serialize() {
     switch (this.kind) {
-      case OffsetKind.Broken:
-      case OffsetKind.NonExistent:
+      case "Broken":
+      case "NonExistent":
         return this.kind;
-      case OffsetKind.InternalsSynthetic:
+      case "InternalsSynthetic":
         return this.string || "";
     }
   }
@@ -5875,25 +5873,21 @@ class InvisibleSpan {
     return BROKEN_LOCATION;
   }
 }
-const span = match(m => m.when(OffsetKind.HbsPosition, OffsetKind.HbsPosition, (left, right) => new HbsSpan(left.source, {
+const span = match(m => m.when("HbsPosition", "HbsPosition", (left, right) => new HbsSpan(left.source, {
     start: left,
     end: right
-  }).wrap()).when(OffsetKind.CharPosition, OffsetKind.CharPosition, (left, right) => new CharPositionSpan(left.source, {
+  }).wrap()).when("CharPosition", "CharPosition", (left, right) => new CharPositionSpan(left.source, {
     start: left,
     end: right
-  }).wrap()).when(OffsetKind.CharPosition, OffsetKind.HbsPosition, (left, right) => {
+  }).wrap()).when("CharPosition", "HbsPosition", (left, right) => {
     const rightCharPos = right.toCharPos();
-    return null === rightCharPos ? new InvisibleSpan(OffsetKind.Broken, BROKEN_LOCATION).wrap() : span(left, rightCharPos);
-  }).when(OffsetKind.HbsPosition, OffsetKind.CharPosition, (left, right) => {
+    return null === rightCharPos ? new InvisibleSpan("Broken", BROKEN_LOCATION).wrap() : span(left, rightCharPos);
+  }).when("HbsPosition", "CharPosition", (left, right) => {
     const leftCharPos = left.toCharPos();
-    return null === leftCharPos ? new InvisibleSpan(OffsetKind.Broken, BROKEN_LOCATION).wrap() : span(leftCharPos, right);
+    return null === leftCharPos ? new InvisibleSpan("Broken", BROKEN_LOCATION).wrap() : span(leftCharPos, right);
   }).when("IS_INVISIBLE", "MATCH_ANY", left => new InvisibleSpan(left.kind, BROKEN_LOCATION).wrap()).when("MATCH_ANY", "IS_INVISIBLE", (_, right) => new InvisibleSpan(right.kind, BROKEN_LOCATION).wrap())),
   BROKEN = "BROKEN";
 
-/**
- * All positions have these details in common. Most notably, all three kinds of positions can
- * must be able to attempt to convert themselves into {@see CharPosition}.
- */
 /**
  * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It
  * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet
@@ -5924,7 +5918,7 @@ class SourceOffset {
   * any part of the source.
   */
   static broken(pos = UNKNOWN_POSITION) {
-    return new InvisiblePosition(OffsetKind.Broken, pos).wrap();
+    return new InvisiblePosition("Broken", pos).wrap();
   }
   constructor(data) {
     this.data = data;
@@ -5969,7 +5963,7 @@ class SourceOffset {
     if (null === charPos) return SourceOffset.broken();
     {
       const result = charPos.offset + by;
-      return charPos.source.check(result) ? new CharPosition(charPos.source, result).wrap() : SourceOffset.broken();
+      return charPos.source.validate(result) ? new CharPosition(charPos.source, result).wrap() : SourceOffset.broken();
     }
   }
   /**
@@ -5988,11 +5982,8 @@ class SourceOffset {
   }
 }
 class CharPosition {
-  kind = OffsetKind.CharPosition;
-  /** Computed from char offset */
-  _locPos = null;
   constructor(source, charPos) {
-    this.source = source, this.charPos = charPos;
+    this.source = source, this.charPos = charPos, this.kind = "CharPosition", this._locPos = null;
   }
   /**
   * This is already a `CharPosition`.
@@ -6035,10 +6026,8 @@ class CharPosition {
   }
 }
 class HbsPosition {
-  kind = OffsetKind.HbsPosition;
-  _charPos;
   constructor(source, hbsPos, charPos = null) {
-    this.source = source, this.hbsPos = hbsPos, this._charPos = null === charPos ? null : new CharPosition(source, charPos);
+    this.source = source, this.hbsPos = hbsPos, this.kind = "HbsPosition", this._charPos = null === charPos ? null : new CharPosition(source, charPos);
   }
   /**
   * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has
@@ -6108,17 +6097,17 @@ class InvisiblePosition {
  *
  * @see {SourceOffset#eql}
  */
-const eql = match(m => m.when(OffsetKind.HbsPosition, OffsetKind.HbsPosition, ({
+const eql = match(m => m.when("HbsPosition", "HbsPosition", ({
   hbsPos: left
 }, {
   hbsPos: right
-}) => left.column === right.column && left.line === right.line).when(OffsetKind.CharPosition, OffsetKind.CharPosition, ({
+}) => left.column === right.column && left.line === right.line).when("CharPosition", "CharPosition", ({
   charPos: left
 }, {
   charPos: right
-}) => left === right).when(OffsetKind.CharPosition, OffsetKind.HbsPosition, ({
+}) => left === right).when("CharPosition", "HbsPosition", ({
   offset: left
-}, right) => left === right.toCharPos()?.offset).when(OffsetKind.HbsPosition, OffsetKind.CharPosition, (left, {
+}, right) => left === right.toCharPos()?.offset).when("HbsPosition", "CharPosition", (left, {
   offset: right
 }) => left.toCharPos()?.offset === right).when("MATCH_ANY", "MATCH_ANY", () => !1));
 class Source {
@@ -6131,7 +6120,7 @@ class Source {
   /**
   * Validate that the character offset represents a position in the source string.
   */
-  check(offset) {
+  validate(offset) {
     return offset >= 0 && offset <= this.source.length;
   }
   slice(start, end) {
@@ -6162,7 +6151,6 @@ class Source {
     let seenLines = 0,
       seenChars = 0;
     if (offset > this.source.length) return null;
-    // eslint-disable-next-line no-constant-condition
     for (;;) {
       let nextLine = this.source.indexOf("\n", seenChars);
       if (offset <= nextLine || -1 === nextLine) return {
@@ -6186,7 +6174,7 @@ class Source {
         if (seenChars + column > nextLine) return nextLine;
         if (isDevelopingApp()) {
           let roundTrip = this.hbsPosFor(seenChars + column);
-          debugAssert(null !== roundTrip, "the returned offset failed to round-trip"), debugAssert(roundTrip.line === line, "the round-tripped line didn't match the original line"), debugAssert(roundTrip.column === column, "the round-tripped column didn't match the original column");
+          roundTrip.line, roundTrip.column;
         }
         return seenChars + column;
       }
@@ -6200,7 +6188,6 @@ class SpanList {
   static range(span, fallback = SourceSpan.NON_EXISTENT) {
     return new SpanList(span.map(loc)).getRangeOffset(fallback);
   }
-  _span;
   constructor(span = []) {
     this._span = span;
   }
@@ -6230,7 +6217,7 @@ function hasSpan(span) {
 function maybeLoc(location, fallback) {
   return hasSpan(location) ? loc(location) : fallback;
 }
-var api$2 = Object.freeze({
+var api$1 = Object.freeze({
   __proto__: null,
   NON_EXISTENT_LOCATION: NON_EXISTENT_LOCATION,
   SYNTHETIC_LOCATION: SYNTHETIC_LOCATION,
@@ -6288,7 +6275,10 @@ const visitorKeys = {
       let error = Error.call(this, message);
       this.key = key, this.message = message, this.node = node, this.parent = parent, error.stack && (this.stack = error.stack);
     }
-    return TraversalError.prototype = Object.create(Error.prototype), TraversalError.prototype.constructor = TraversalError, TraversalError;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    return TraversalError.prototype = Object.create(Error.prototype),
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    TraversalError.prototype.constructor = TraversalError, TraversalError;
   }();
 function cannotRemoveNode(node, parent, key) {
   return new TraversalError("Cannot remove a node unless it is part of an array", node, parent, key);
@@ -6300,9 +6290,6 @@ function cannotReplaceOrRemoveInKeyHandlerYet(node, key) {
   return new TraversalError("Replacing and removing in key handlers is not yet supported.", node, null, key);
 }
 class WalkerPath {
-  node;
-  parent;
-  parentKey;
   constructor(node, parent = null, parentKey = null) {
     this.node = node, this.parent = parent, this.parentKey = parentKey;
   }
@@ -6316,7 +6303,6 @@ class WalkerPath {
   }
 }
 class PathParentsIterator {
-  path;
   constructor(path) {
     this.path = path;
   }
@@ -6346,7 +6332,10 @@ function visitNode(visitor, path) {
       parentKey: parentKey
     } = path,
     handler = function (visitor, nodeType) {
-      if (visitor.Program && ("Template" === nodeType && !visitor.Template || "Block" === nodeType && !visitor.Block)) return deprecate(`The 'Program' visitor node is deprecated. Use 'Template' or 'Block' instead (node was '${nodeType}') `), visitor.Program;
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      if (visitor.Program && ("Template" === nodeType && !visitor.Template || "Block" === nodeType && !visitor.Block))
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        return visitor.Program;
       let handler = visitor[nodeType];
       return void 0 !== handler ? handler : visitor.All;
     }(visitor, node.type);
@@ -6391,9 +6380,11 @@ function visitKey(visitor, handler, path, key) {
       void 0 !== result &&
       // TODO: dynamically check the results by having a table of
       // expected node types in value space, not just type space
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
       function (node, key, value, result) {
         if (null === result) throw cannotRemoveNode(value, node, key);
         if (Array.isArray(result)) {
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
           if (1 !== result.length) throw 0 === result.length ? cannotRemoveNode(value, node, key) : cannotReplaceNode(value, node, key);
           set(node, key, result[0]);
         } else set(node, key, result);
@@ -6404,7 +6395,7 @@ function visitKey(visitor, handler, path, key) {
 }
 function visitArray(visitor, array, parent, parentKey) {
   for (let i = 0; i < array.length; i++) {
-    let node = unwrap(array[i]),
+    let node = array[i],
       result = visitNode(visitor, new WalkerPath(node, parent, parentKey));
     void 0 !== result && (i += spliceArray(array, i, result) - 1);
   }
@@ -6416,9 +6407,8 @@ function traverse(node, visitor) {
   visitNode(visitor, new WalkerPath(node));
 }
 class Walker {
-  stack = [];
   constructor(order) {
-    this.order = order;
+    this.order = order, this.stack = [];
   }
   visit(node, visitor) {
     node && (this.stack.push(node), "post" === this.order ? (this.children(node, visitor), visitor(node, this)) : (visitor(node, this), this.children(node, visitor)), this.stack.pop());
@@ -6458,9 +6448,6 @@ let _SOURCE;
 function SOURCE() {
   return _SOURCE || (_SOURCE = new Source("", "(synthetic)")), _SOURCE;
 }
-
-// const SOURCE = new Source('', '(tests)');
-// Statements
 function buildVar(name, loc) {
   return b.var({
     name: name,
@@ -6472,7 +6459,7 @@ function buildPath(path, loc) {
   if ("string" != typeof path) {
     if ("type" in path) return path;
     {
-      debugAssert(-1 === path.head.indexOf("."), "builder.path({ head, tail }) should not be called with a head with dots in it");
+      path.head.indexOf(".");
       let {
         head: head,
         tail: tail
@@ -6493,7 +6480,7 @@ function buildPath(path, loc) {
     head: head,
     tail: tail
   } = function (original, loc) {
-    let [head, ...tail] = asPresentArray(original.split(".")),
+    let [head, ...tail] = original.split("."),
       headNode = b.head({
         original: head,
         loc: buildLoc(loc || null)
@@ -6580,11 +6567,11 @@ var publicBuilder = {
   block: function (path, params, hash, _defaultBlock, _elseBlock = null, loc, openStrip, inverseStrip, closeStrip) {
     let defaultBlock,
       elseBlock = null;
-    return "Template" === _defaultBlock.type ? (deprecate("b.program is deprecated. Use b.blockItself instead."), defaultBlock = b.blockItself({
+    return defaultBlock = "Template" === _defaultBlock.type ? b.blockItself({
       params: buildBlockParams(_defaultBlock.blockParams),
       body: _defaultBlock.body,
       loc: _defaultBlock.loc
-    })) : defaultBlock = _defaultBlock, "Template" === _elseBlock?.type ? (deprecate("b.program is deprecated. Use b.blockItself instead."), debugAssert(0 === _elseBlock.blockParams.length, "{{else}} block cannot have block params"), elseBlock = b.blockItself({
+    }) : _defaultBlock, "Template" === _elseBlock?.type ? (_elseBlock.blockParams.length, elseBlock = b.blockItself({
       params: [],
       body: _elseBlock.body,
       loc: _elseBlock.loc
@@ -6612,9 +6599,7 @@ var publicBuilder = {
       loc: buildLoc(loc || null)
     });
   },
-  element:
-  // Nodes
-  function (tag, options = {}) {
+  element: function (tag, options = {}) {
     let path,
       selfClosing,
       {
@@ -6628,10 +6613,10 @@ var publicBuilder = {
         loc: loc
       } = options;
     // this is used for backwards compat, prior to `selfClosing` being part of the ElementNode AST
-    "string" == typeof tag ? tag.endsWith("/") ? (path = buildPath(tag.slice(0, -1)), selfClosing = !0) : path = buildPath(tag) : "type" in tag ? (debugAssert("PathExpression" === tag.type, `Invalid tag type ${tag.type}`), path = tag) : "path" in tag ? (debugAssert("PathExpression" === tag.path.type, `Invalid tag type ${tag.path.type}`), path = tag.path, selfClosing = tag.selfClosing) : (path = buildPath(tag.name), selfClosing = tag.selfClosing), selfClosing && debugAssert(null == _closeTag, "Cannot build a self-closing tag with a closeTag source location");
+    "string" == typeof tag ? tag.endsWith("/") ? (path = buildPath(tag.slice(0, -1)), selfClosing = !0) : path = buildPath(tag) : "type" in tag ? (tag.type, tag.type, path = tag) : "path" in tag ? (tag.path.type, tag.path.type, path = tag.path, selfClosing = tag.selfClosing) : (path = buildPath(tag.name), selfClosing = tag.selfClosing);
     let params = blockParams?.map(param => "string" == typeof param ? buildVar(param) : param),
       closeTag = null;
-    return _closeTag ? closeTag = buildLoc(_closeTag || null) : void 0 === _closeTag && (closeTag = selfClosing || isVoidTag(path.original) ? null : buildLoc(null)), b.element({
+    return _closeTag ? closeTag = buildLoc(_closeTag) : void 0 === _closeTag && (closeTag = selfClosing || isVoidTag(path.original) ? null : buildLoc(null)), b.element({
       path: path,
       selfClosing: selfClosing || !1,
       attributes: attrs || [],
@@ -6693,7 +6678,7 @@ var publicBuilder = {
   },
   literal: buildLiteral,
   program: function (body, blockParams, loc) {
-    return deprecate("b.program is deprecated. Use b.template or b.blockItself instead."), blockParams && blockParams.length ? buildBlockItself(body, blockParams, !1, loc) : buildTemplate(body, [], loc);
+    return blockParams && blockParams.length ? buildBlockItself(body, blockParams, !1, loc) : buildTemplate(body, [], loc);
   },
   blockItself: buildBlockItself,
   template: buildTemplate,
@@ -6764,21 +6749,21 @@ const DEFAULT_STRIP = {
     }
     blockItself({
       body: body,
-      params: params,
+      params: params1,
       chained = !1,
       loc: loc
     }) {
       return {
         type: "Block",
         body: body,
-        params: params,
+        params: params1,
         get blockParams() {
           return this.params.map(p => p.name);
         },
         set blockParams(params) {
-          this.params = params.map(name => b.var({
-            name: name,
-            loc: SourceSpan.synthetic(name)
+          this.params = params.map(name1 => b.var({
+            name: name1,
+            loc: SourceSpan.synthetic(name1)
           }));
         },
         chained: chained,
@@ -6799,7 +6784,7 @@ const DEFAULT_STRIP = {
     }
     mustache({
       path: path,
-      params: params,
+      params: params1,
       hash: hash,
       trusting: trusting,
       loc: loc,
@@ -6825,15 +6810,15 @@ const DEFAULT_STRIP = {
         return Object.defineProperty(node, "escaped", {
           enumerable: !1,
           get() {
-            return deprecate("The escaped property on mustache nodes is deprecated, use trusting instead"), !this.trusting;
+            return !this.trusting;
           },
-          set(value) {
-            deprecate("The escaped property on mustache nodes is deprecated, use trusting instead"), this.trusting = !value;
+          set(value1) {
+            this.trusting = !value1;
           }
         }), node;
       }({
         path: path,
-        params: params,
+        params: params1,
         hash: hash,
         trusting: trusting,
         strip: strip,
@@ -6842,7 +6827,7 @@ const DEFAULT_STRIP = {
     }
     block({
       path: path,
-      params: params,
+      params: params1,
       hash: hash,
       defaultBlock: defaultBlock,
       elseBlock = null,
@@ -6854,7 +6839,7 @@ const DEFAULT_STRIP = {
       return {
         type: "BlockStatement",
         path: path,
-        params: params,
+        params: params1,
         hash: hash,
         program: defaultBlock,
         inverse: elseBlock,
@@ -6865,22 +6850,22 @@ const DEFAULT_STRIP = {
       };
     }
     comment({
-      value: value,
+      value: value1,
       loc: loc
     }) {
       return {
         type: "CommentStatement",
-        value: value,
+        value: value1,
         loc: loc
       };
     }
     mustacheComment({
-      value: value,
+      value: value1,
       loc: loc
     }) {
       return {
         type: "MustacheCommentStatement",
-        value: value,
+        value: value1,
         loc: loc
       };
     }
@@ -6896,23 +6881,23 @@ const DEFAULT_STRIP = {
     }
     element({
       path: path,
-      selfClosing: selfClosing,
+      selfClosing: selfClosing1,
       attributes: attributes,
       modifiers: modifiers,
-      params: params,
+      params: params1,
       comments: comments,
       children: children,
       openTag: openTag,
       closeTag: closeTag,
       loc: loc
     }) {
-      let _selfClosing = selfClosing;
+      let _selfClosing = selfClosing1;
       return {
         type: "ElementNode",
         path: path,
         attributes: attributes,
         modifiers: modifiers,
-        params: params,
+        params: params1,
         comments: comments,
         children: children,
         openTag: openTag,
@@ -6928,9 +6913,9 @@ const DEFAULT_STRIP = {
           return this.params.map(p => p.name);
         },
         set blockParams(params) {
-          this.params = params.map(name => b.var({
-            name: name,
-            loc: SourceSpan.synthetic(name)
+          this.params = params.map(name1 => b.var({
+            name: name1,
+            loc: SourceSpan.synthetic(name1)
           }));
         },
         get selfClosing() {
@@ -6943,27 +6928,27 @@ const DEFAULT_STRIP = {
     }
     elementModifier({
       path: path,
-      params: params,
+      params: params1,
       hash: hash,
       loc: loc
     }) {
       return {
         type: "ElementModifierStatement",
         path: path,
-        params: params,
+        params: params1,
         hash: hash,
         loc: loc
       };
     }
     attr({
-      name: name,
-      value: value,
+      name: name1,
+      value: value1,
       loc: loc
     }) {
       return {
         type: "AttrNode",
-        name: name,
-        value: value,
+        name: name1,
+        value: value1,
         loc: loc
       };
     }
@@ -6979,14 +6964,14 @@ const DEFAULT_STRIP = {
     }
     sexpr({
       path: path,
-      params: params,
+      params: params1,
       hash: hash,
       loc: loc
     }) {
       return {
         type: "SubExpression",
         path: path,
-        params: params,
+        params: params1,
         hash: hash,
         loc: loc
       };
@@ -7009,7 +6994,7 @@ const DEFAULT_STRIP = {
             return [this.head.original, ...this.tail].join(".");
           },
           set original(value) {
-            let [head, ...tail] = asPresentArray(value.split("."));
+            let [head, ...tail] = value.split(".");
             this.head = publicBuilder.head(head, this.head.loc), this.tail = tail;
           },
           loc: loc
@@ -7017,8 +7002,7 @@ const DEFAULT_STRIP = {
         return Object.defineProperty(node, "parts", {
           enumerable: !1,
           get() {
-            deprecate("The parts property on path nodes is deprecated, use head and tail instead");
-            let parts = asPresentArray(this.original.split("."));
+            let parts = this.original.split(".");
             return "this" === parts[0] ?
             // parts does not include `this`
             parts.shift() : parts[0].startsWith("@") && (
@@ -7026,7 +7010,6 @@ const DEFAULT_STRIP = {
             parts[0] = parts[0].slice(1)), Object.freeze(parts);
           },
           set(values) {
-            deprecate("The parts property on mustache nodes is deprecated, use head and tail instead");
             let parts = [...values];
             // you are not supposed to already have `this` or `@` in the parts, but since this is
             // deprecated anyway, we will infer what you meant and allow it
@@ -7035,12 +7018,12 @@ const DEFAULT_STRIP = {
         }), Object.defineProperty(node, "this", {
           enumerable: !1,
           get() {
-            return deprecate("The this property on path nodes is deprecated, use head.type instead"), "ThisHead" === this.head.type;
+            return "ThisHead" === this.head.type;
           }
         }), Object.defineProperty(node, "data", {
           enumerable: !1,
           get() {
-            return deprecate("The data property on path nodes is deprecated, use head.type instead"), "AtHead" === this.head.type;
+            return "AtHead" === this.head.type;
           }
         }), node;
       }({
@@ -7075,7 +7058,7 @@ const DEFAULT_STRIP = {
       };
     }
     atName({
-      name: name,
+      name: name1,
       loc: loc
     }) {
       let _name = "";
@@ -7085,7 +7068,7 @@ const DEFAULT_STRIP = {
           return _name;
         },
         set name(value) {
-          debugAssert("@" === value[0], "call builders.at() with a string that starts with '@'"), debugAssert(-1 === value.indexOf("."), "builder.at() should not be called with a name with dots in it"), _name = value;
+          value[0], value.indexOf("."), _name = value;
         },
         get original() {
           return this.name;
@@ -7096,10 +7079,10 @@ const DEFAULT_STRIP = {
         loc: loc
       };
       // trigger the assertions
-      return node.name = name, node;
+      return node.name = name1, node;
     }
     var({
-      name: name,
+      name: name1,
       loc: loc
     }) {
       let _name = "";
@@ -7109,7 +7092,7 @@ const DEFAULT_STRIP = {
           return _name;
         },
         set name(value) {
-          debugAssert("this" !== value, "You called builders.var() with 'this'. Call builders.this instead"), debugAssert("@" !== value[0], `You called builders.var() with '${name}'. Call builders.at('${name}') instead`), debugAssert(-1 === value.indexOf("."), "builder.var() should not be called with a name with dots in it"), _name = value;
+          value[0], value.indexOf("."), _name = value;
         },
         get original() {
           return this.name;
@@ -7120,7 +7103,7 @@ const DEFAULT_STRIP = {
         loc: loc
       };
       // trigger the assertions
-      return node.name = name, node;
+      return node.name = name1, node;
     }
     hash({
       pairs: pairs,
@@ -7134,56 +7117,50 @@ const DEFAULT_STRIP = {
     }
     pair({
       key: key,
-      value: value,
+      value: value1,
       loc: loc
     }) {
       return {
         type: "HashPair",
         key: key,
-        value: value,
+        value: value1,
         loc: loc
       };
     }
     literal({
       type: type,
-      value: value,
+      value: value1,
       loc: loc
     }) {
       return function ({
         type: type,
-        value: value,
+        value: value1,
         loc: loc
       }) {
         const node = {
           type: type,
-          value: value,
+          value: value1,
           loc: loc
         };
         return Object.defineProperty(node, "original", {
           enumerable: !1,
           get() {
-            return deprecate("The original property on literal nodes is deprecated, use value instead"), this.value;
+            return this.value;
           },
-          set(value) {
-            deprecate("The original property on literal nodes is deprecated, use value instead"), this.value = value;
+          set(value1) {
+            this.value = value1;
           }
         }), node;
       }({
         type: type,
-        value: value,
+        value: value1,
         loc: loc
       });
     }
   }();
 class Parser {
-  elementStack = [];
-  lines;
-  source;
-  currentAttribute = null;
-  currentNode = null;
-  tokenizer;
   constructor(source, entityParser = new EntityParser(namedCharRefs), mode = "precompile") {
-    this.source = source, this.lines = source.source.split(/\r\n?|\n/u), this.tokenizer = new EventedTokenizer(this, entityParser, mode);
+    this.elementStack = [], this.currentAttribute = null, this.currentNode = null, this.source = source, this.lines = source.source.split(/\r\n?|\n/u), this.tokenizer = new EventedTokenizer(this, entityParser, mode);
   }
   offset() {
     let {
@@ -7205,33 +7182,33 @@ class Parser {
     // node.loc = node.loc.withEnd(end);
   }
   get currentAttr() {
-    return expect(this.currentAttribute, "expected attribute");
+    return this.currentAttribute;
   }
   get currentTag() {
     let node = this.currentNode;
-    return debugAssert(node && ("StartTag" === node.type || "EndTag" === node.type), "expected tag"), node;
+    return node && ("StartTag" === node.type || node.type), node;
   }
   get currentStartTag() {
     let node = this.currentNode;
-    return debugAssert(node && "StartTag" === node.type, "expected start tag"), node;
+    return node && node.type, node;
   }
   get currentEndTag() {
     let node = this.currentNode;
-    return debugAssert(node && "EndTag" === node.type, "expected end tag"), node;
+    return node && node.type, node;
   }
   get currentComment() {
     let node = this.currentNode;
-    return debugAssert(node && "CommentStatement" === node.type, "expected a comment"), node;
+    return node && node.type, node;
   }
   get currentData() {
     let node = this.currentNode;
-    return debugAssert(node && "TextNode" === node.type, "expected a text node"), node;
+    return node && node.type, node;
   }
   acceptNode(node) {
     return this[node.type](node);
   }
   currentElement() {
-    return getLast(asPresentArray(this.elementStack));
+    return getLast(this.elementStack);
   }
   sourceForNode(node, endNode) {
     let line,
@@ -7241,20 +7218,13 @@ class Parser {
       currentLine = firstLine - 1,
       firstColumn = node.loc.start.column,
       string = [];
-    for (endNode ? (lastLine = endNode.loc.end.line - 1, lastColumn = endNode.loc.end.column) : (lastLine = node.loc.end.line - 1, lastColumn = node.loc.end.column); currentLine < lastLine;) currentLine++, line = unwrap(this.lines[currentLine]), currentLine === firstLine ? firstLine === lastLine ? string.push(line.slice(firstColumn, lastColumn)) : string.push(line.slice(firstColumn)) : currentLine === lastLine ? string.push(line.slice(0, lastColumn)) : string.push(line);
+    for (endNode ? (lastLine = endNode.loc.end.line - 1, lastColumn = endNode.loc.end.column) : (lastLine = node.loc.end.line - 1, lastColumn = node.loc.end.column); currentLine < lastLine;) currentLine++, line = this.lines[currentLine], currentLine === firstLine ? firstLine === lastLine ? string.push(line.slice(firstColumn, lastColumn)) : string.push(line.slice(firstColumn)) : currentLine === lastLine ? string.push(line.slice(0, lastColumn)) : string.push(line);
     return string.join("\n");
   }
 }
 class HandlebarsNodeVisitors extends Parser {
-  // Because we interleave the HTML and HBS parsing, sometimes the HTML
-  // tokenizer can run out of tokens when we switch into {{...}} or reached
-  // EOF. There are positions where neither of these are expected, and it would
-  // like to generate an error, but there is no span to attach the error to.
-  // This allows the HTML tokenization to stash an error message and the next
-  // mustache visitor will attach the message to the appropriate span and throw
-  // the error.
-  pendingError = null;
   parse(program, blockParams) {
+    program.loc;
     let node = b.template({
         body: [],
         blockParams: blockParams,
@@ -7267,10 +7237,7 @@ class HandlebarsNodeVisitors extends Parser {
     return this.pendingError?.eof(template.loc.getEnd()), template;
   }
   Program(program, blockParams) {
-    // The abstract signature doesn't have the blockParams argument, but in
-    // practice we can only come from this.BlockStatement() which adds the
-    // extra argument for us
-    debugAssert(Array.isArray(blockParams), "[BUG] Program in parser unexpectedly called without block params");
+    program.loc;
     let node = b.blockItself({
       body: [],
       params: blockParams,
@@ -7291,14 +7258,12 @@ class HandlebarsNodeVisitors extends Parser {
     // Ensure that that the element stack is balanced properly.
     if (node !== poppedNode) {
       if ("ElementNode" === poppedNode?.type) throw generateSyntaxError(`Unclosed element \`${poppedNode.tag}\``, poppedNode.loc);
-      // If the stack is not balanced, then it is likely our own bug, because
-      // any unclosed Handlebars blocks should already been caught by now
-      debugAssert(void 0 !== poppedNode, "[BUG] empty parser elementStack"), debugAssert(!1, `[BUG] mismatched parser elementStack node: ${node.type}`);
+      node.type;
     }
     return node;
   }
   BlockStatement(block) {
-    if ("comment" === this.tokenizer.state) return void this.appendToCommentData(this.sourceForNode(block));
+    if ("comment" === this.tokenizer.state) return block.loc, void this.appendToCommentData(this.sourceForNode(block));
     if ("data" !== this.tokenizer.state && "beforeData" !== this.tokenizer.state) throw generateSyntaxError("A block may only be used inside an HTML element or another block.", this.source.spanFor(block.loc));
     const {
         path: path,
@@ -7307,22 +7272,19 @@ class HandlebarsNodeVisitors extends Parser {
       } = acceptCallNodes(this, block),
       loc = this.source.spanFor(block.loc);
     // Backfill block params loc for the default block
-    let blockParams = [];
+    let repairedBlock,
+      blockParams = [];
     if (block.program.blockParams?.length) {
       // Start from right after the hash
       let span = hash.loc.collapse("end");
       // Extend till the beginning of the block
-      span = block.program.loc ? span.withEnd(this.source.spanFor(block.program.loc).getStart()) : block.program.body[0] ? span.withEnd(this.source.spanFor(block.program.body[0].loc).getStart()) : span.withEnd(loc.getEnd());
+      span = block.program.loc ? span.withEnd(this.source.spanFor(block.program.loc).getStart()) : block.program.body[0] ? span.withEnd(this.source.spanFor(block.program.body[0].loc).getStart()) : span.withEnd(loc.getEnd()), repairedBlock = repairBlock(this.source, block, span);
       // Now we have a span for something like this:
-
       //   {{#foo bar baz=bat as |wow wat|}}
       //                     ~~~~~~~~~~~~~~~
-
       // Or, if we are unlucky:
-
       // {{#foo bar baz=bat as |wow wat|}}{{/foo}}
       //                   ~~~~~~~~~~~~~~~~~~~~~~~
-
       // Either way, within this span, there should be exactly two pipes
       // fencing our block params, neatly whitespace separated and with
       // legal identifiers only
@@ -7339,11 +7301,9 @@ class HandlebarsNodeVisitors extends Parser {
           loc: loc
         }));
       }
-    }
-    // These are bugs in Handlebars upstream
-    block.program.loc || (block.program.loc = NON_EXISTENT_LOCATION), block.inverse && !block.inverse.loc && (block.inverse.loc = NON_EXISTENT_LOCATION);
-    const program = this.Program(block.program, blockParams),
-      inverse = block.inverse ? this.Program(block.inverse, []) : null,
+    } else repairedBlock = repairBlock(this.source, block, loc);
+    const program = this.Program(repairedBlock.program, blockParams),
+      inverse = repairedBlock.inverse ? this.Program(repairedBlock.inverse, []) : null,
       node = b.block({
         path: path,
         params: params,
@@ -7459,7 +7419,7 @@ class HandlebarsNodeVisitors extends Parser {
           lineCount = lines.length - 1;
         return {
           lines: lineCount,
-          columns: unwrap(lines[lineCount]).length
+          columns: lines[lineCount].length
         };
       }(content.original, content.value);
       line += offsets.lines, offsets.lines ? column = offsets.columns : column += offsets.columns, tokenizer.line = line, tokenizer.column = column;
@@ -7630,6 +7590,17 @@ class HandlebarsNodeVisitors extends Parser {
       loc: this.source.spanFor(nul.loc)
     });
   }
+  constructor(...args) {
+    super(...args),
+    // Because we interleave the HTML and HBS parsing, sometimes the HTML
+    // tokenizer can run out of tokens when we switch into {{...}} or reached
+    // EOF. There are positions where neither of these are expected, and it would
+    // like to generate an error, but there is no span to attach the error to.
+    // This allows the HTML tokenization to stash an error message and the next
+    // mustache visitor will attach the message to the appropriate span and throw
+    // the error.
+    this.pendingError = null;
+  }
 }
 function acceptCallNodes(compiler, node) {
   let path;
@@ -7650,7 +7621,7 @@ function acceptCallNodes(compiler, node) {
         throw value = "BooleanLiteral" === node.path.type ? node.path.original.toString() : "StringLiteral" === node.path.type ? `"${node.path.original}"` : "NullLiteral" === node.path.type ? "null" : "NumberLiteral" === node.path.type ? node.path.value.toString() : "undefined", generateSyntaxError(`${node.path.type} "${"StringLiteral" === node.path.type ? node.path.original : value}" cannot be called as a sub-expression, replace (${value}) with ${value}`, compiler.source.spanFor(node.path.loc));
       }
   }
-  const params = node.params ? node.params.map(e => compiler.acceptNode(e)) : [],
+  const params = node.params.map(e => compiler.acceptNode(e)),
     end = isPresentArray(params) ? getLast(params).loc : path.loc;
   // if there is no hash, position it as a collapsed node immediately after the last param (or the
   // path, if there are also no params)
@@ -7684,14 +7655,28 @@ function addElementModifier(element, mustache) {
   });
   element.modifiers.push(modifier);
 }
+function repairBlock(source, block, fallbackStart) {
+  // Extend till the beginning of the block
+  if (!block.program.loc) {
+    const start = block.program.body.at(0),
+      end = block.program.body.at(-1);
+    if (start && end) block.program.loc = {
+      ...start.loc,
+      end: end.loc.end
+    };else {
+      const loc = source.spanFor(block.loc);
+      block.program.loc = fallbackStart.withEnd(loc.getEnd());
+    }
+  }
+  let endProgram = source.spanFor(block.program.loc).getEnd();
+  return block.inverse && !block.inverse.loc && (block.inverse.loc = endProgram.collapsed()), block;
+}
 
 // vendored from simple-html-tokenizer because it's unexported
 function isSpace(char) {
   return /[\t\n\f ]/u.test(char);
 }
 class TokenizerEventHandlers extends HandlebarsNodeVisitors {
-  tagOpenLine = 0;
-  tagOpenColumn = 0;
   reset() {
     this.currentNode = null;
   }
@@ -7756,18 +7741,16 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         end: this.offset().toJSON()
       }));
       (voidMap.has(tag.name) || tag.selfClosing) && this.finishEndTag(!0);
-    } else "EndTag" === tag.type && this.finishEndTag(!1);
+    } else tag.type, tag.type, this.finishEndTag(!1);
   }
   finishStartTag() {
     let {
-      name: name,
-      nameStart: nameStart,
-      nameEnd: nameEnd
-    } = this.currentStartTag;
-    // <> should probably be a syntax error, but s-h-t is currently broken for that case
-    debugAssert("" !== name, "tag name cannot be empty"), debugAssert(null !== nameStart, "nameStart unexpectedly null"), debugAssert(null !== nameEnd, "nameEnd unexpectedly null");
-    let nameLoc = nameStart.until(nameEnd),
-      [head, ...tail] = asPresentArray(name.split(".")),
+        name: name,
+        nameStart: nameStart,
+        nameEnd: nameEnd
+      } = this.currentStartTag,
+      nameLoc = nameStart.until(nameEnd),
+      [head, ...tail] = name.split("."),
       path = b.path({
         head: b.head({
           original: head,
@@ -7808,7 +7791,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
       element = this.elementStack.pop();
     this.validateEndTag(tag, element, isVoid);
     let parent = this.currentElement();
-    isVoid ? element.closeTag = null : element.selfClosing ? debugAssert(null === element.closeTag, "element.closeTag unexpectedly present") : element.closeTag = closeTagStart.until(this.offset()), element.loc = element.loc.withEnd(this.offset()), appendChild(parent, b.element(element));
+    isVoid ? element.closeTag = null : element.selfClosing ? element.closeTag : element.closeTag = closeTagStart.until(this.offset()), element.loc = element.loc.withEnd(this.offset()), appendChild(parent, b.element(element));
   }
   markTagAsSelfClosing() {
     let tag = this.currentTag;
@@ -7823,7 +7806,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
     let tag = this.currentTag;
     if (tag.name += char, "StartTag" === tag.type) {
       let offset = this.offset();
-      null === tag.nameStart && (debugAssert(null === tag.nameEnd, "nameStart and nameEnd must both be null"),
+      null === tag.nameStart && (tag.nameEnd,
       // Note that the tokenizer already consumed the token here
       tag.nameStart = offset.move(-1)), tag.nameEnd = offset;
     }
@@ -7897,7 +7880,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
   parsePossibleBlockParams() {
     // const enums that we can't use directly
     const ID_INVERSE_PATTERN = /[!"#%&'()*+./;<=>@[\\\]^`{|}~]/u;
-    debugAssert("attributeName" === this.tokenizer.state, "must be in TokenizerState.attributeName");
+    this.tokenizer.state;
     const element = this.currentStartTag,
       as = this.currentAttr;
     let state = {
@@ -7905,7 +7888,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
     };
     const handlers = {
       PossibleAs: next => {
-        if (debugAssert("PossibleAs" === state.state, "bug in block params parser"), isSpace(next))
+        if (state.state, isSpace(next))
           // " as ..."
           state = {
             state: "BeforeStartPipe"
@@ -7922,7 +7905,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         }
       },
       BeforeStartPipe: next => {
-        debugAssert("BeforeStartPipe" === state.state, "bug in block params parser"), isSpace(next) ? this.tokenizer.consume() : "|" === next ? (state = {
+        state.state, isSpace(next) ? this.tokenizer.consume() : "|" === next ? (state = {
           state: "BeforeBlockParamName"
         }, this.tokenizer.transitionTo("beforeAttributeName"), this.tokenizer.consume()) :
         // " as {{...", " as bs...", " as =...", " as ...", " as/>..."
@@ -7932,7 +7915,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         };
       },
       BeforeBlockParamName: next => {
-        if (debugAssert("BeforeBlockParamName" === state.state, "bug in block params parser"), isSpace(next)) this.tokenizer.consume();else if ("" === next)
+        if (state.state, isSpace(next)) this.tokenizer.consume();else if ("" === next)
           // The HTML tokenizer ran out of characters, so we are either
           // encountering mustache or <EOF>
           state = {
@@ -7962,7 +7945,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         }
       },
       BlockParamName: next => {
-        if (debugAssert("BlockParamName" === state.state, "bug in block params parser"), "" === next)
+        if (state.state, "" === next)
           // The HTML tokenizer ran out of characters, so we are either
           // encountering mustache or <EOF>, HBS side will attach the error
           // to the next span
@@ -7993,7 +7976,7 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         }
       },
       AfterEndPipe: next => {
-        debugAssert("AfterEndPipe" === state.state, "bug in block params parser"), isSpace(next) ? this.tokenizer.consume() : "" === next ? (
+        state.state, isSpace(next) ? this.tokenizer.consume() : "" === next ? (
         // The HTML tokenizer ran out of characters, so we are either
         // encountering mustache or <EOF>, HBS side will attach the error
         // to the next span
@@ -8019,26 +8002,22 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
         }, this.tokenizer.consume());
       },
       Error: next => {
-        if (debugAssert("Error" === state.state, "bug in block params parser"), "" === next || "/" === next || ">" === next || isSpace(next)) throw generateSyntaxError(state.message, state.start.until(this.offset()));
+        if (state.state, "" === next || "/" === next || ">" === next || isSpace(next)) throw generateSyntaxError(state.message, state.start.until(this.offset()));
         // Slurp up the next "token" for the error span
         this.tokenizer.consume();
       },
-      Done: () => {
-        debugAssert(!1, "This should never be called");
-      }
+      Done: () => {}
     };
     let next;
     do {
       next = this.tokenizer.peek(), handlers[state.state](next);
     } while ("Done" !== state.state && "" !== next);
-    debugAssert("Done" === state.state, "bug in block params parser");
+    state.state;
   }
   reportSyntaxError(message) {
     throw generateSyntaxError(message, this.offset().collapsed());
   }
   assembleConcatenatedValue(parts) {
-    for (const part of parts) if ("MustacheStatement" !== part.type && "TextNode" !== part.type) throw generateSyntaxError(`Unsupported node in quoted attribute value: ${part.type}`, part.loc);
-    assertPresentArray(parts, "the concatenation parts of an element should not be empty");
     let first = getFirst(parts),
       last = getLast(parts);
     return b.concat({
@@ -8052,14 +8031,13 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
       // <input> or <br />, so we need to check for that here. Otherwise, we would
       // throw an error for those cases.
       throw generateSyntaxError(`<${tag.name}> elements do not need end tags. You should remove it`, tag.loc);
-    if (void 0 === element.tag) throw generateSyntaxError(`Closing tag </${tag.name}> without an open tag`, tag.loc);
+    if ("ElementNode" !== element.type) throw generateSyntaxError(`Closing tag </${tag.name}> without an open tag`, tag.loc);
     if (element.tag !== tag.name) throw generateSyntaxError(`Closing tag </${tag.name}> did not match last open tag <${element.tag}> (on line ${element.loc.startPosition.line})`, tag.loc);
   }
   assembleAttributeValue(parts, isQuoted, isDynamic, span) {
     if (isDynamic) {
       if (isQuoted) return this.assembleConcatenatedValue(parts);
       {
-        assertPresentArray(parts);
         const [head, a] = parts;
         if (void 0 === a || "TextNode" === a.type && "/" === a.chars) return head;
         throw generateSyntaxError("An unquoted attribute value must be a string or a mustache, preceded by whitespace or a '=' character, and followed by whitespace, a '>' character, or '/>'", span);
@@ -8070,12 +8048,10 @@ class TokenizerEventHandlers extends HandlebarsNodeVisitors {
       loc: span
     });
   }
+  constructor(...args) {
+    super(...args), this.tagOpenLine = 0, this.tagOpenColumn = 0;
+  }
 }
-
-/**
-  ASTPlugins can make changes to the Glimmer template AST before
-  compilation begins.
-*/
 const syntax = {
   parse: preprocess,
   builders: publicBuilder,
@@ -8103,48 +8079,18 @@ function preprocess(input, options = {}) {
     end: offsets.endPosition
   };
   let template = new TokenizerEventHandlers(source, entityParser, mode).parse(ast, options.locals ?? []);
-  if (options?.plugins?.ast) for (const transform of options.plugins.ast) traverse(template, transform(assign({}, options, {
+  if (options.plugins?.ast) for (const transform of options.plugins.ast) traverse(template, transform(assign({}, options, {
     syntax: syntax
   }, {
     plugins: void 0
   })).visitor);
   return template;
 }
-
-/**
- * This is a convenience function for creating ASTv2 nodes, with an optional name and the node's
- * options.
- *
- * ```ts
- * export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}
- * ```
- *
- * This creates a new ASTv2 node with the name `'HtmlText'` and one field `chars: string` (in
- * addition to a `loc: SourceOffsets` field, which all nodes have).
- *
- * ```ts
- * export class Args extends node().fields<{
- *  positional: PositionalArguments;
- *  named: NamedArguments
- * }>() {}
- * ```
- *
- * This creates a new un-named ASTv2 node with two fields (`positional: Positional` and `named:
- * Named`, in addition to the generic `loc: SourceOffsets` field).
- *
- * Once you create a node using `node`, it is instantiated with all of its fields (including `loc`):
- *
- * ```ts
- * new HtmlText({ loc: offsets, chars: someString });
- * ```
- */
 function node(name) {
   if (void 0 !== name) {
     const type = name;
     return {
       fields: () => class {
-        // SAFETY: initialized via `assign` in the constructor.
-        type;
         constructor(fields) {
           this.type = type, assign(this, fields);
         }
@@ -8153,7 +8099,6 @@ function node(name) {
   }
   return {
     fields: () => class {
-      // SAFETY: initialized via `assign` in the constructor.
       constructor(fields) {
         assign(this, fields);
       }
@@ -8258,30 +8203,11 @@ class NamedArguments extends node().fields() {
  * ```
  */
 class NamedArgument {
-  loc;
-  name;
-  value;
   constructor(options) {
     this.loc = options.name.loc.extend(options.value.loc), this.name = options.name, this.value = options.value;
   }
 }
 
-/**
- * Attr nodes look like HTML attributes, but are classified as:
- *
- * 1. `HtmlAttr`, which means a regular HTML attribute in Glimmer
- * 2. `SplatAttr`, which means `...attributes`
- * 3. `ComponentArg`, which means an attribute whose name begins with `@`, and it is therefore a
- *    component argument.
- */
-/**
- * `HtmlAttr` and `SplatAttr` are grouped together because the order of the `SplatAttr` node,
- * relative to other attributes, matters.
- */
-/**
- * "Attr Block" nodes are allowed inside an open element tag in templates. They interact with the
- * element (or component).
- */
 /**
  * `HtmlAttr` nodes are valid HTML attributes, with or without a value.
  *
@@ -8312,13 +8238,6 @@ class ComponentArg extends node().fields() {
  * An `ElementModifier` is just a normal call node in modifier position.
  */
 class ElementModifier extends node("ElementModifier").fields() {}
-
-/**
- * Content Nodes are allowed in content positions in templates. They correspond to behavior in the
- * [Data][data] tokenization state in HTML.
- *
- * [data]: https://html.spec.whatwg.org/multipage/parsing.html#data-state
- */
 class GlimmerComment extends node("GlimmerComment").fields() {}
 class HtmlText extends node("HtmlText").fields() {}
 class HtmlComment extends node("HtmlComment").fields() {}
@@ -8361,11 +8280,6 @@ class SimpleElement extends node("SimpleElement").fields() {
   }
 }
 
-/**
- * A Handlebars literal.
- *
- * {@link https://handlebarsjs.com/guide/expressions.html#literal-segments}
- */
 /**
  * Corresponds to a Handlebars literal.
  *
@@ -8441,9 +8355,6 @@ class Block extends node().fields() {}
  * Corresponds to a collection of named blocks.
  */
 class NamedBlocks extends node().fields() {
-  /**
-  * Get the `NamedBlock` for a given name.
-  */
   get(name) {
     return this.blocks.filter(block => block.name.chars === name)[0] || null;
   }
@@ -8490,18 +8401,7 @@ class LocalVarReference extends node("Local").fields() {}
  */
 class FreeVarReference extends node("Free").fields() {}
 
-/**
- * A free variable is resolved according to a resolution rule:
- *
- * 1. Strict resolution
- * 2. Namespaced resolution
- */
-/**
- * Strict resolution is used:
- *
- * 1. in a strict mode template
- * 2. in an local variable invocation with dot paths
- */
+/// FreeVarNamespace ///
 const STRICT_RESOLUTION = {
     resolution: () => opcodes.GetStrictKeyword,
     serialize: () => "Strict",
@@ -8545,7 +8445,7 @@ class LooseModeResolution {
   * ^ In either case, `x` should be resolved in the `component` and `helper` namespaces.
   */
   static append() {
-    return new LooseModeResolution([FreeVarNamespace.Component, FreeVarNamespace.Helper]);
+    return new LooseModeResolution(["Component", "Helper"]);
   }
   /**
   * Trusting append resolution is used when the variable should be resolved only in the
@@ -8562,7 +8462,7 @@ class LooseModeResolution {
   * ^ In either case, `x` should be resolved in the `helper` namespace.
   */
   static trustingAppend() {
-    return this.namespaced(FreeVarNamespace.Helper);
+    return this.namespaced("Helper");
   }
   constructor(namespaces, isAngleBracket = !1) {
     this.namespaces = namespaces, this.isAngleBracket = isAngleBracket;
@@ -8570,11 +8470,11 @@ class LooseModeResolution {
   resolution() {
     if (1 !== this.namespaces.length) return opcodes.GetFreeAsComponentOrHelperHead;
     switch (this.namespaces[0]) {
-      case FreeVarNamespace.Helper:
+      case "Helper":
         return opcodes.GetFreeAsHelperHead;
-      case FreeVarNamespace.Modifier:
+      case "Modifier":
         return opcodes.GetFreeAsModifierHead;
-      case FreeVarNamespace.Component:
+      case "Component":
         return opcodes.GetFreeAsComponentHead;
     }
   }
@@ -8582,26 +8482,19 @@ class LooseModeResolution {
     return 1 === this.namespaces.length ? this.namespaces[0] : "ComponentOrHelper";
   }
 }
-let FreeVarNamespace = function (FreeVarNamespace) {
-  return FreeVarNamespace.Helper = "Helper", FreeVarNamespace.Modifier = "Modifier", FreeVarNamespace.Component = "Component", FreeVarNamespace;
-}({});
-const HELPER_NAMESPACE = FreeVarNamespace.Helper,
-  MODIFIER_NAMESPACE = FreeVarNamespace.Modifier,
-  COMPONENT_NAMESPACE = FreeVarNamespace.Component;
-var api$1 = Object.freeze({
+var api = Object.freeze({
   __proto__: null,
   AppendContent: AppendContent,
   ArgReference: ArgReference,
   Args: Args,
   Block: Block,
-  COMPONENT_NAMESPACE: COMPONENT_NAMESPACE,
+  COMPONENT_NAMESPACE: "Component",
   CallExpression: CallExpression,
   ComponentArg: ComponentArg,
   ElementModifier: ElementModifier,
-  FreeVarNamespace: FreeVarNamespace,
   FreeVarReference: FreeVarReference,
   GlimmerComment: GlimmerComment,
-  HELPER_NAMESPACE: HELPER_NAMESPACE,
+  HELPER_NAMESPACE: "Helper",
   HTML_RESOLUTION: HTML_RESOLUTION,
   HtmlAttr: HtmlAttr,
   HtmlComment: HtmlComment,
@@ -8613,7 +8506,7 @@ var api$1 = Object.freeze({
   LiteralExpression: LiteralExpression,
   LocalVarReference: LocalVarReference,
   LooseModeResolution: LooseModeResolution,
-  MODIFIER_NAMESPACE: MODIFIER_NAMESPACE,
+  MODIFIER_NAMESPACE: "Modifier",
   NamedArgument: NamedArgument,
   NamedArguments: NamedArguments,
   NamedBlock: NamedBlock,
@@ -8631,30 +8524,7 @@ var api$1 = Object.freeze({
   isStrictResolution: function (value) {
     return value === STRICT_RESOLUTION;
   },
-  loadResolution:
-  /**
-  * A `Namespaced` must be resolved in one or more namespaces.
-  *
-  * ```hbs
-  * <X />
-  * ```
-  *
-  * ^ `X` is resolved in the `component` namespace
-  *
-  * ```hbs
-  * (x)
-  * ```
-  *
-  * ^ `x` is resolved in the `helper` namespace
-  *
-  * ```hbs
-  * <a {{x}} />
-  * ```
-  *
-  * ^ `x` is resolved in the `modifier` namespace
-  */
-  // Serialization
-  function (resolution) {
+  loadResolution: function (resolution) {
     return "Strict" === resolution ? STRICT_RESOLUTION : "ComponentOrHelper" === resolution ? LooseModeResolution.append() : LooseModeResolution.namespaced(resolution);
   },
   node: node
@@ -8670,15 +8540,11 @@ class SymbolTable {
 }
 class ProgramSymbolTable extends SymbolTable {
   constructor(templateLocals, keywords, options) {
-    super(), this.templateLocals = templateLocals, this.keywords = keywords, this.options = options;
-  }
-  symbols = [];
-  upvars = [];
-  size = 1;
-  named = dict();
-  blocks = dict();
-  usedTemplateLocals = [];
-  #hasDebugger = !1;
+    super(), this.templateLocals = templateLocals, this.keywords = keywords, this.options = options, this.symbols = [], this.upvars = [], this.size = 1, this.named = dict(), this.blocks = dict(), this.usedTemplateLocals = [];
+  }
+  root() {
+    return this;
+  }
   hasLexical(name) {
     return this.options.lexicalScope(name);
   }
@@ -8691,12 +8557,6 @@ class ProgramSymbolTable extends SymbolTable {
   getUsedTemplateLocals() {
     return this.usedTemplateLocals;
   }
-  setHasDebugger() {
-    this.#hasDebugger = !0;
-  }
-  get hasEval() {
-    return this.#hasDebugger;
-  }
   has(name) {
     return this.templateLocals.includes(name);
   }
@@ -8708,7 +8568,7 @@ class ProgramSymbolTable extends SymbolTable {
     return dict();
   }
   getDebugInfo() {
-    return Object.values(this.getLocalsMap());
+    return [this.getLocalsMap(), this.named];
   }
   allocateFree(name, resolution) {
     // If the name in question is an uppercase (i.e. angle-bracket) component invocation, run
@@ -8734,6 +8594,9 @@ class BlockSymbolTable extends SymbolTable {
   constructor(parent, symbols, slots) {
     super(), this.parent = parent, this.symbols = symbols, this.slots = slots;
   }
+  root() {
+    return this.parent.root();
+  }
   get locals() {
     return this.symbols;
   }
@@ -8755,17 +8618,19 @@ class BlockSymbolTable extends SymbolTable {
   }
   #get(name) {
     let slot = this.symbols.indexOf(name);
-    return -1 === slot ? null : unwrap(this.slots[slot]);
+    return -1 === slot ? null : this.slots[slot];
   }
   getLocalsMap() {
     let dict = this.parent.getLocalsMap();
     return this.symbols.forEach(symbol => dict[symbol] = this.get(symbol)[0]), dict;
   }
   getDebugInfo() {
-    return Object.values(this.getLocalsMap());
-  }
-  setHasDebugger() {
-    this.parent.setHasDebugger();
+    const locals = this.getLocalsMap(),
+      root = this.root();
+    return [{
+      ...locals,
+      ...root.named
+    }, Object.fromEntries(root.upvars.map((s, i) => [s, i]))];
   }
   allocateFree(name, resolution) {
     return this.parent.allocateFree(name, resolution);
@@ -8898,8 +8763,7 @@ class Builder {
     });
   }
   at(name, symbol, loc) {
-    // the `@` should be included so we have a complete source range
-    return debugAssert("@" === name[0], "call builders.at() with a string that starts with '@'"), new ArgReference({
+    return name[0], new ArgReference({
       loc: loc,
       name: new SourceSlice({
         loc: loc,
@@ -8914,7 +8778,7 @@ class Builder {
     symbol: symbol,
     loc: loc
   }) {
-    return debugAssert("this" !== name, "You called builders.freeVar() with 'this'. Call builders.this instead"), debugAssert("@" !== name[0], `You called builders.freeVar() with '${name}'. Call builders.at('${name}') instead`), new FreeVarReference({
+    return name[0], new FreeVarReference({
       name: name,
       resolution: context,
       symbol: symbol,
@@ -8922,7 +8786,7 @@ class Builder {
     });
   }
   localVar(name, symbol, isTemplateLocal, loc) {
-    return debugAssert("this" !== name, "You called builders.var() with 'this'. Call builders.this instead"), debugAssert("@" !== name[0], `You called builders.var() with '${name}'. Call builders.at('${name}') instead`), new LocalVarReference({
+    return name[0], new LocalVarReference({
       loc: loc,
       name: name,
       isTemplateLocal: isTemplateLocal,
@@ -8937,7 +8801,7 @@ class Builder {
     });
   }
   interpolate(parts, loc) {
-    return assertPresentArray(parts), new InterpolateExpression({
+    return new InterpolateExpression({
       loc: loc,
       parts: parts
     });
@@ -8996,7 +8860,6 @@ class Builder {
   }
 }
 class BuildElement {
-  builder;
   constructor(base) {
     this.base = base, this.builder = new Builder();
   }
@@ -9049,16 +8912,16 @@ class BuildElement {
   }
 }
 function SexpSyntaxContext(node) {
-  return isSimpleCallee(node) ? LooseModeResolution.namespaced(HELPER_NAMESPACE) : null;
+  return isSimpleCallee(node) ? LooseModeResolution.namespaced("Helper") : null;
 }
 function ModifierSyntaxContext(node) {
-  return isSimpleCallee(node) ? LooseModeResolution.namespaced(MODIFIER_NAMESPACE) : null;
+  return isSimpleCallee(node) ? LooseModeResolution.namespaced("Modifier") : null;
 }
 function BlockSyntaxContext(node) {
-  return isSimpleCallee(node) ? LooseModeResolution.namespaced(COMPONENT_NAMESPACE) : null;
+  return isSimpleCallee(node) ? LooseModeResolution.namespaced("Component") : null;
 }
 function ComponentSyntaxContext(node) {
-  return isSimplePath(node) ? LooseModeResolution.namespaced(COMPONENT_NAMESPACE, !0) : null;
+  return isSimplePath(node) ? LooseModeResolution.namespaced("Component", !0) : null;
 }
 
 /**
@@ -9066,7 +8929,7 @@ function ComponentSyntaxContext(node) {
  * In strict mode, this also corresponds to arg curlies.
  */
 function AttrValueSyntaxContext(node) {
-  return isSimpleCallee(node) ? LooseModeResolution.namespaced(HELPER_NAMESPACE) : null;
+  return isSimpleCallee(node) ? LooseModeResolution.namespaced("Helper") : null;
 }
 
 /**
@@ -9142,7 +9005,6 @@ function normalize(source, options = {
  * `BlockContext` is stateless.
  */
 class BlockContext {
-  builder;
   constructor(source, options, table) {
     this.source = source, this.options = options, this.table = table, this.builder = new Builder();
   }
@@ -9199,12 +9061,6 @@ class ExpressionNormalizer {
   constructor(block) {
     this.block = block;
   }
-  /**
-  * The `normalize` method takes an arbitrary expression and its original syntax context and
-  * normalizes it to an ASTv2 expression.
-  *
-  * @see {SyntaxContext}
-  */
   normalize(expr, resolution) {
     switch (expr.type) {
       case "NullLiteral":
@@ -9214,7 +9070,7 @@ class ExpressionNormalizer {
       case "UndefinedLiteral":
         return this.block.builder.literal(expr.value, this.block.loc(expr.loc));
       case "PathExpression":
-        return debugAssert(resolution, "[BUG] resolution is required"), this.path(expr, resolution);
+        return this.path(expr, resolution);
       case "SubExpression":
         {
           // expr.path used to incorrectly have the type ASTv1.Expression
@@ -9300,6 +9156,10 @@ class ExpressionNormalizer {
       offsets = block.loc(head.loc);
     switch (head.type) {
       case "ThisHead":
+        if (block.hasBinding("this")) {
+          let [symbol, isRoot] = table.get("this");
+          return block.builder.localVar("this", symbol, isRoot, offsets);
+        }
         return builder.self(offsets);
       case "AtHead":
         {
@@ -9464,7 +9324,7 @@ class ElementNormalizer {
         comments: comments
       } = element,
       loc = this.ctx.loc(element.loc),
-      [tagHead, ...rest] = asPresentArray(tag.split(".")),
+      [tagHead, ...rest] = tag.split("."),
       path = this.classifyTag(tagHead, rest, element.loc),
       attrs = element.attributes.filter(a => "@" !== a.name[0]).map(a => this.attr(a)),
       args = element.attributes.filter(a => "@" === a.name[0]).map(a => this.arg(a)),
@@ -9557,7 +9417,7 @@ class ElementNormalizer {
     return this.attrPart(part);
   }
   attr(m) {
-    if (debugAssert("@" !== m.name[0], "An attr name must not start with `@`"), "...attributes" === m.name) return this.ctx.builder.splatAttr(this.ctx.table.allocateBlock("attrs"), this.ctx.loc(m.loc));
+    if (m.name[0], "...attributes" === m.name) return this.ctx.builder.splatAttr(this.ctx.table.allocateBlock("attrs"), this.ctx.loc(m.loc));
     let offsets = this.ctx.loc(m.loc),
       nameSlice = offsets.sliceStartChars({
         chars: m.name.length
@@ -9586,7 +9446,7 @@ class ElementNormalizer {
     if ("error" === resolution.result && "has-block" !== resolution.path) throw generateSyntaxError(`You attempted to pass a path as argument (\`${arg.name}={{${resolution.path}}}\`) but ${resolution.head} was not in scope. Try:\n* \`${arg.name}={{this.${resolution.path}}}\` if this is meant to be a property lookup, or\n* \`${arg.name}={{(${resolution.path})}}\` if this is meant to invoke the resolved helper, or\n* \`${arg.name}={{helper "${resolution.path}"}}\` if this is meant to pass the resolved helper by value`, arg.loc);
   }
   arg(arg) {
-    debugAssert("@" === arg.name[0], "An arg name must start with `@`"), this.checkArgCall(arg);
+    arg.name[0], this.checkArgCall(arg);
     let offsets = this.ctx.loc(arg.loc),
       nameSlice = offsets.sliceStartChars({
         chars: arg.name.length
@@ -9658,9 +9518,6 @@ class ElementNormalizer {
   }
 }
 class Children {
-  namedBlocks;
-  hasSemanticContent;
-  nonBlockChildren;
   constructor(loc, children, block) {
     this.loc = loc, this.children = children, this.block = block, this.namedBlocks = children.filter(c => c instanceof NamedBlock), this.hasSemanticContent = Boolean(children.filter(c => {
       if (c instanceof NamedBlock) return !1;
@@ -9827,4 +9684,4 @@ function transformParams(b, params, type, moduleName, loc) {
   }
 }
 
-export { KEYWORDS_TYPES as K, SourceSlice as S, api$2 as a, api$1 as b, normalize as c, generateSyntaxError as g, isKeyword as i, loc as l, maybeLoc as m, node as n, transformResolutions as t };
+export { KEYWORDS_TYPES as K, SourceSlice as S, api$1 as a, api as b, normalize as c, generateSyntaxError as g, isKeyword as i, loc as l, maybeLoc as m, node as n, transformResolutions as t };