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

package/dist/ember-template-compiler.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.4.0-alpha.2
+ * @version   6.4.0-alpha.3
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -424,7 +424,7 @@ var define, require;
             @private
             @function isObject
           */
-          function isObject$1(value) {
+          function isObject(value) {
             return value !== null && (typeof value === 'object' || typeof value === 'function');
           }
 
@@ -499,7 +499,7 @@ var define, require;
           */
           function generateGuid(obj, prefix = GUID_PREFIX) {
             let guid = prefix + uuid().toString();
-            if (isObject$1(obj)) {
+            if (isObject(obj)) {
               OBJECT_GUIDS.set(obj, guid);
             }
             return guid;
@@ -521,7 +521,7 @@ var define, require;
           */
           function guidFor(value) {
             let guid;
-            if (isObject$1(value)) {
+            if (isObject(value)) {
               guid = OBJECT_GUIDS.get(value);
               if (guid === undefined) {
                 guid = `${GUID_PREFIX}${uuid()}`;
@@ -753,7 +753,7 @@ var define, require;
 
           const NAMES = new WeakMap();
           function setName(obj, name) {
-            if (isObject$1(obj)) NAMES.set(obj, name);
+            if (isObject(obj)) NAMES.set(obj, name);
           }
           function getName(obj) {
             return NAMES.get(obj);
@@ -796,13 +796,13 @@ var define, require;
 
           const PROXIES = new WeakSet();
           function isProxy(value) {
-            if (isObject$1(value)) {
+            if (isObject(value)) {
               return PROXIES.has(value);
             }
             return false;
           }
           function setProxy(object) {
-            if (isObject$1(object)) {
+            if (isObject(object)) {
               PROXIES.add(object);
             }
           }
@@ -964,7 +964,7 @@ var define, require;
           let missingOptionsDeprecation$1;
           let missingOptionsIdDeprecation$1;
           let missingOptionDeprecation = () => '';
-          let deprecate$2 = () => {};
+          let deprecate$1 = () => {};
           {
             registerHandler$1 = function registerHandler(handler) {
               registerHandler$2('deprecate', handler);
@@ -1095,7 +1095,7 @@ var define, require;
               @public
               @since 1.0.0
             */
-            deprecate$2 = function deprecate(message, test, options) {
+            deprecate$1 = function deprecate(message, test, options) {
               assert(missingOptionsDeprecation$1, Boolean(options && (options.id || options.until)));
               assert(missingOptionsIdDeprecation$1, Boolean(options.id));
               assert(missingOptionDeprecation(options.id, 'until'), Boolean(options.until));
@@ -1104,7 +1104,7 @@ var define, require;
               invoke('deprecate', message, test, options);
             };
           }
-          const defaultDeprecate = deprecate$2;
+          const defaultDeprecate = deprecate$1;
 
           const emberDebugLibDeprecate = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,
@@ -1348,523 +1348,6 @@ var define, require;
                     default: inspect
           }, Symbol.toStringTag, { value: 'Module' });
 
-          const EMPTY_ARRAY = Object.freeze([]);
-          function emptyArray() {
-            return EMPTY_ARRAY;
-          }
-          const EMPTY_STRING_ARRAY = emptyArray(),
-            EMPTY_NUMBER_ARRAY = emptyArray();
-
-          /**
-           * This function returns `true` if the input array is the special empty array sentinel,
-           * which is sometimes used for optimizations.
-           */
-          function isEmptyArray(input) {
-            return input === EMPTY_ARRAY;
-          }
-          function* reverse(input) {
-            for (let i = input.length - 1; i >= 0; i--) yield input[i];
-          }
-          function* enumerate(input) {
-            let i = 0;
-            for (const item of input) yield [i++, item];
-          }
-
-          // import Logger from './logger';
-          // let alreadyWarned = false;
-          function debugAssert(test, msg) {
-            // if (!alreadyWarned) {
-            //   alreadyWarned = true;
-            //   Logger.warn("Don't leave debug assertions on in public builds");
-            // }
-            if (!test) throw new Error(msg || "assertion failure");
-          }
-          function deprecate$1(desc) {
-            LOCAL_LOGGER.warn(`DEPRECATION: ${desc}`);
-          }
-          function keys(obj) {
-            return Object.keys(obj);
-          }
-          function unwrap(val) {
-            if (null == val) throw new Error("Expected value to be present");
-            return val;
-          }
-          function expect(val, message) {
-            if (null == val) throw new Error(message);
-            return val;
-          }
-          function unreachable(message = "unreachable") {
-            return new Error(message);
-          }
-          function exhausted(value) {
-            throw new Error(`Exhausted ${String(value)}`);
-          }
-          const tuple = (...args) => args;
-          function isPresent(value) {
-            return null != value;
-          }
-          function assertPresent(value, message) {
-            if (!isPresent(value)) throw new Error(`Expected present, got ${"string" == typeof value ? value : message}`);
-          }
-          function isPresentArray(list) {
-            return list.length > 0;
-          }
-          function ifPresent(list, ifPresent, otherwise) {
-            return isPresentArray(list) ? ifPresent(list) : otherwise();
-          }
-          function arrayToOption(list) {
-            return isPresentArray(list) ? list : null;
-          }
-          function assertPresentArray(list, message = "unexpected empty list") {
-            if (!isPresentArray(list)) throw new Error(message);
-          }
-          function asPresentArray(list, message = "unexpected empty list") {
-            return assertPresentArray(list, message), list;
-          }
-          function getLast(list) {
-            return 0 === list.length ? void 0 : list[list.length - 1];
-          }
-          function getFirst(list) {
-            return 0 === list.length ? void 0 : list[0];
-          }
-          function mapPresentArray(list, mapper) {
-            if (null === list) return null;
-            let out = [];
-            for (let item of list) out.push(mapper(item));
-            return out;
-          }
-          function dict() {
-            return Object.create(null);
-          }
-          function isDict(u) {
-            return null != u;
-          }
-          function isObject(u) {
-            return "function" == typeof u || "object" == typeof u && null !== u;
-          }
-          class StackImpl {
-            stack;
-            current = null;
-            constructor(values = []) {
-              this.stack = values;
-            }
-            get size() {
-              return this.stack.length;
-            }
-            push(item) {
-              this.current = item, this.stack.push(item);
-            }
-            pop() {
-              let item = this.stack.pop();
-              return this.current = getLast(this.stack) ?? null, void 0 === item ? null : item;
-            }
-            nth(from) {
-              let len = this.stack.length;
-              return len < from ? null : unwrap(this.stack[len - from]);
-            }
-            isEmpty() {
-              return 0 === this.stack.length;
-            }
-            toArray() {
-              return this.stack;
-            }
-          }
-
-          /// <reference types="qunit" />
-          let beginTestSteps, endTestSteps, verifySteps, logStep, debugToString;
-          {
-            let getFunctionName = fn => {
-                let functionName = fn.name;
-                if (void 0 === functionName) {
-                  let match = /function (\w+)\s*\(/u.exec(String(fn));
-                  functionName = match && match[1] || "";
-                }
-                return functionName.replace(/^bound /u, "");
-              },
-              getObjectName = obj => {
-                let name, className;
-                // If the class has a decent looking name, and the `toString` is one of the
-                // default Ember toStrings, replace the constructor portion of the toString
-                // with the class name. We check the length of the class name to prevent doing
-                // this when the value is minified.
-                return obj.constructor && "function" == typeof obj.constructor && (className = getFunctionName(obj.constructor)), "toString" in obj && obj.toString !== Object.prototype.toString && obj.toString !== Function.prototype.toString && (name = obj.toString()), name && /<.*:ember\d+>/u.test(name) && className && "_" !== className[0] && className.length > 2 && "Class" !== className ? name.replace(/<.*:/u, `<${className}:`) : name || className;
-              },
-              getPrimitiveName = value => String(value);
-            debugToString = value => "function" == typeof value ? getFunctionName(value) || "(unknown function)" : "object" == typeof value && null !== value ? getObjectName(value) || "(unknown object)" : getPrimitiveName(value);
-          }
-          var debugToString$1 = debugToString;
-          function clearElement(parent) {
-            let current = parent.firstChild;
-            for (; current;) {
-              let next = current.nextSibling;
-              parent.removeChild(current), current = next;
-            }
-          }
-          const RAW_NODE = -1,
-            ELEMENT_NODE = 1,
-            TEXT_NODE = 3,
-            COMMENT_NODE = 8,
-            DOCUMENT_NODE = 9,
-            DOCUMENT_TYPE_NODE = 10,
-            DOCUMENT_FRAGMENT_NODE = 11,
-            NS_HTML = "http://www.w3.org/1999/xhtml",
-            NS_MATHML = "http://www.w3.org/1998/Math/MathML",
-            NS_SVG = "http://www.w3.org/2000/svg",
-            NS_XLINK = "http://www.w3.org/1999/xlink",
-            NS_XML = "http://www.w3.org/XML/1998/namespace",
-            NS_XMLNS = "http://www.w3.org/2000/xmlns/",
-            INSERT_BEFORE_BEGIN = "beforebegin",
-            INSERT_AFTER_BEGIN = "afterbegin",
-            INSERT_BEFORE_END = "beforeend",
-            INSERT_AFTER_END = "afterend";
-
-          /*
-            Encoding notes
-
-            We use 30 bit integers for encoding, so that we don't ever encode a non-SMI
-            integer to push on the stack.
-
-            Handles are >= 0
-            Immediates are < 0
-
-            True, False, Undefined and Null are pushed as handles into the symbol table,
-            with well known handles (0, 1, 2, 3)
-
-            The negative space is divided into positives and negatives. Positives are
-            higher numbers (-1, -2, -3, etc), negatives are lower.
-
-            We only encode immediates for two reasons:
-
-            1. To transfer over the wire, so they're smaller in general
-            2. When pushing values onto the stack from the low level/inner VM, which may
-               be converted into WASM one day.
-
-            This allows the low-level VM to always use SMIs, and to minimize using JS
-            values via handles for things like the stack pointer and frame pointer.
-            Externally, most code pushes values as JS values, except when being pulled
-            from the append byte code where it was already encoded.
-
-            Logically, this is because the low level VM doesn't really care about these
-            higher level values. For instance, the result of a userland helper may be a
-            number, or a boolean, or undefined/null, but it's extra work to figure that
-            out and push it correctly, vs. just pushing the value as a JS value with a
-            handle.
-
-            Note: The details could change here in the future, this is just the current
-            strategy.
-          */
-          let ImmediateConstants = function (ImmediateConstants) {
-            return ImmediateConstants[ImmediateConstants.MAX_SMI = 1073741823] = "MAX_SMI", ImmediateConstants[ImmediateConstants.MIN_SMI = -1073741824] = "MIN_SMI", ImmediateConstants[ImmediateConstants.SIGN_BIT = -536870913] = "SIGN_BIT", ImmediateConstants[ImmediateConstants.MAX_INT = 536870911] = "MAX_INT", ImmediateConstants[ImmediateConstants.MIN_INT = -536870912] = "MIN_INT", ImmediateConstants[ImmediateConstants.FALSE_HANDLE = 0] = "FALSE_HANDLE", ImmediateConstants[ImmediateConstants.TRUE_HANDLE = 1] = "TRUE_HANDLE", ImmediateConstants[ImmediateConstants.NULL_HANDLE = 2] = "NULL_HANDLE", ImmediateConstants[ImmediateConstants.UNDEFINED_HANDLE = 3] = "UNDEFINED_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_FALSE_HANDLE = 0] = "ENCODED_FALSE_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_TRUE_HANDLE = 1] = "ENCODED_TRUE_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_NULL_HANDLE = 2] = "ENCODED_NULL_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_UNDEFINED_HANDLE = 3] = "ENCODED_UNDEFINED_HANDLE", ImmediateConstants;
-          }({});
-          function isHandle(value) {
-            return value >= 0;
-          }
-          function isNonPrimitiveHandle(value) {
-            return value > ImmediateConstants.ENCODED_UNDEFINED_HANDLE;
-          }
-          function constants(...values) {
-            return [!1, !0, null, void 0, ...values];
-          }
-          function isSmallInt(value) {
-            return value % 1 == 0 && value <= ImmediateConstants.MAX_INT && value >= ImmediateConstants.MIN_INT;
-          }
-          function encodeNegative(num) {
-            return num & ImmediateConstants.SIGN_BIT;
-          }
-          function decodeNegative(num) {
-            return num | ~ImmediateConstants.SIGN_BIT;
-          }
-          function encodePositive(num) {
-            return ~num;
-          }
-          function decodePositive(num) {
-            return ~num;
-          }
-          function encodeHandle(num) {
-            return num;
-          }
-          function decodeHandle(num) {
-            return num;
-          }
-          function encodeImmediate(num) {
-            return (num |= 0) < 0 ? encodeNegative(num) : encodePositive(num);
-          }
-          function decodeImmediate(num) {
-            return (num |= 0) > ImmediateConstants.SIGN_BIT ? decodePositive(num) : decodeNegative(num);
-          }
-
-          /**
-            Strongly hint runtimes to intern the provided string.
-
-            When do I need to use this function?
-
-            For the most part, never. Pre-mature optimization is bad, and often the
-            runtime does exactly what you need it to, and more often the trade-off isn't
-            worth it.
-
-            Why?
-
-            Runtimes store strings in at least 2 different representations:
-            Ropes and Symbols (interned strings). The Rope provides a memory efficient
-            data-structure for strings created from concatenation or some other string
-            manipulation like splitting.
-
-            Unfortunately checking equality of different ropes can be quite costly as
-            runtimes must resort to clever string comparison algorithms. These
-            algorithms typically cost in proportion to the length of the string.
-            Luckily, this is where the Symbols (interned strings) shine. As Symbols are
-            unique by their string content, equality checks can be done by pointer
-            comparison.
-
-            How do I know if my string is a rope or symbol?
-
-            Typically (warning general sweeping statement, but truthy in runtimes at
-            present) static strings created as part of the JS source are interned.
-            Strings often used for comparisons can be interned at runtime if some
-            criteria are met.  One of these criteria can be the size of the entire rope.
-            For example, in chrome 38 a rope longer then 12 characters will not
-            intern, nor will segments of that rope.
-
-            Some numbers: http://jsperf.com/eval-vs-keys/8
-
-            Known Trick™
-
-            @private
-            @return {String} interned version of the provided string
-          */
-          function intern(str) {
-            let obj = {};
-            obj[str] = 1;
-            for (let key in obj) if (key === str) return key;
-            return str;
-          }
-          [1, -1].forEach(x => decodeImmediate(encodeImmediate(x)));
-          const SERIALIZATION_FIRST_NODE_STRING = "%+b:0%";
-          function isSerializationFirstNode(node) {
-            return "%+b:0%" === node.nodeValue;
-          }
-          let assign = Object.assign;
-          function values(obj) {
-            return Object.values(obj);
-          }
-          function entries(dict) {
-            return Object.entries(dict);
-          }
-          function castToSimple(node) {
-            return isDocument(node) || isSimpleElement(node), node;
-          }
-
-          // If passed a document, verify we're in the browser and return it as a Document
-          // If we don't know what this is, but the check requires it to be an element,
-          // the cast will mandate that it's a browser element
-          // Finally, if it's a more generic check, the cast will mandate that it's a
-          // browser node and return a BrowserNodeUtils corresponding to the check
-          function castToBrowser(node, sugaryCheck) {
-            if (null == node) return null;
-            if (void 0 === typeof document) throw new Error("Attempted to cast to a browser node in a non-browser context");
-            if (isDocument(node)) return node;
-            if (node.ownerDocument !== document) throw new Error("Attempted to cast to a browser node with a node that was not created from this document");
-            return checkBrowserNode(node, sugaryCheck);
-          }
-          function isDocument(node) {
-            return node.nodeType === DOCUMENT_NODE;
-          }
-          function isSimpleElement(node) {
-            return node?.nodeType === ELEMENT_NODE;
-          }
-          function isElement(node) {
-            return node?.nodeType === ELEMENT_NODE && node instanceof Element;
-          }
-          function checkBrowserNode(node, check) {
-            let isMatch = !1;
-            if (null !== node) if ("string" == typeof check) isMatch = stringCheckNode(node, check);else {
-              if (!Array.isArray(check)) throw unreachable();
-              isMatch = check.some(c => stringCheckNode(node, c));
-            }
-            if (isMatch && node instanceof Node) return node;
-            throw function (from, check) {
-              return new Error(`cannot cast a ${from} into ${String(check)}`);
-            }(`SimpleElement(${node?.constructor?.name ?? "null"})`, check);
-          }
-          function stringCheckNode(node, check) {
-            switch (check) {
-              case "NODE":
-                return !0;
-              case "HTML":
-                return node instanceof HTMLElement;
-              case "SVG":
-                return node instanceof SVGElement;
-              case "ELEMENT":
-                return node instanceof Element;
-              default:
-                if (check.toUpperCase() === check) throw new Error("BUG: this code is missing handling for a generic node type");
-                return node instanceof Element && node.tagName.toLowerCase() === check;
-            }
-          }
-          function strip(strings, ...args) {
-            let out = "";
-            for (const [i, string] of enumerate(strings)) out += `${string}${void 0 !== args[i] ? String(args[i]) : ""}`;
-            let lines = out.split("\n");
-            for (; isPresentArray(lines) && /^\s*$/u.test(getFirst(lines));) lines.shift();
-            for (; isPresentArray(lines) && /^\s*$/u.test(getLast(lines));) lines.pop();
-            let min = 1 / 0;
-            for (let line of lines) {
-              let leading = /^\s*/u.exec(line)[0].length;
-              min = Math.min(min, leading);
-            }
-            let stripped = [];
-            for (let line of lines) stripped.push(line.slice(min));
-            return stripped.join("\n");
-          }
-          function unwrapHandle(handle) {
-            if ("number" == typeof handle) return handle;
-            {
-              let error = handle.errors[0];
-              throw new Error(`Compile Error: ${error.problem} @ ${error.span.start}..${error.span.end}`);
-            }
-          }
-          function unwrapTemplate(template) {
-            if ("error" === template.result) throw new Error(`Compile Error: ${template.problem} @ ${template.span.start}..${template.span.end}`);
-            return template;
-          }
-          function extractHandle(handle) {
-            return "number" == typeof handle ? handle : handle.handle;
-          }
-          function isOkHandle(handle) {
-            return "number" == typeof handle;
-          }
-          function isErrHandle(handle) {
-            return "number" == typeof handle;
-          }
-          function buildUntouchableThis(source) {
-            let context = null;
-            {
-              let assertOnProperty = property => {
-                let access = "symbol" == typeof property || "number" == typeof property ? `[${String(property)}]` : `.${property}`;
-                throw new Error(`You accessed \`this${access}\` from a function passed to the ${source}, but the function itself was not bound to a valid \`this\` context. Consider updating to use a bound function (for instance, use an arrow function, \`() => {}\`).`);
-              };
-              context = new Proxy({}, {
-                get(_target, property) {
-                  assertOnProperty(property);
-                },
-                set: (_target, property) => (assertOnProperty(property), !1),
-                has: (_target, property) => (assertOnProperty(property), !1)
-              });
-            }
-            return context;
-          }
-
-          /**
-           * This constant exists to make it easier to differentiate normal logs from
-           * errant console.logs. LOCAL_LOGGER should only be used inside a
-           * LOCAL_SHOULD_LOG check.
-           *
-           * It does not alleviate the need to check LOCAL_SHOULD_LOG, which is used
-           * for stripping.
-           */
-          const LOCAL_LOGGER = console,
-            LOGGER = console;
-
-          /**
-           * This constant exists to make it easier to differentiate normal logs from
-           * errant console.logs. LOGGER can be used outside of LOCAL_SHOULD_LOG checks,
-           * and is meant to be used in the rare situation where a console.* call is
-           * actually appropriate.
-           */
-          function assertNever(value, desc = "unexpected unreachable branch") {
-            throw LOGGER.log("unreachable", value), LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`), new Error("code reached unreachable");
-          }
-
-          const glimmerUtil = /*#__PURE__*/Object.defineProperty({
-                    __proto__: null,
-                    COMMENT_NODE,
-                    DOCUMENT_FRAGMENT_NODE,
-                    DOCUMENT_NODE,
-                    DOCUMENT_TYPE_NODE,
-                    ELEMENT_NODE,
-                    EMPTY_ARRAY,
-                    EMPTY_NUMBER_ARRAY,
-                    EMPTY_STRING_ARRAY,
-                    INSERT_AFTER_BEGIN,
-                    INSERT_AFTER_END,
-                    INSERT_BEFORE_BEGIN,
-                    INSERT_BEFORE_END,
-                    ImmediateConstants,
-                    LOCAL_LOGGER,
-                    LOGGER,
-                    NS_HTML,
-                    NS_MATHML,
-                    NS_SVG,
-                    NS_XLINK,
-                    NS_XML,
-                    NS_XMLNS,
-                    RAW_NODE,
-                    SERIALIZATION_FIRST_NODE_STRING,
-                    Stack: StackImpl,
-                    TEXT_NODE,
-                    arrayToOption,
-                    asPresentArray,
-                    assert: debugAssert,
-                    assertNever,
-                    assertPresent,
-                    assertPresentArray,
-                    assign,
-                    beginTestSteps,
-                    buildUntouchableThis,
-                    castToBrowser,
-                    castToSimple,
-                    checkNode: checkBrowserNode,
-                    clearElement,
-                    constants,
-                    debugToString: debugToString$1,
-                    decodeHandle,
-                    decodeImmediate,
-                    decodeNegative,
-                    decodePositive,
-                    deprecate: deprecate$1,
-                    dict,
-                    emptyArray,
-                    encodeHandle,
-                    encodeImmediate,
-                    encodeNegative,
-                    encodePositive,
-                    endTestSteps,
-                    entries,
-                    enumerate,
-                    exhausted,
-                    expect,
-                    extractHandle,
-                    getFirst,
-                    getLast,
-                    ifPresent,
-                    intern,
-                    isDict,
-                    isElement,
-                    isEmptyArray,
-                    isErrHandle,
-                    isHandle,
-                    isNonPrimitiveHandle,
-                    isObject,
-                    isOkHandle,
-                    isPresent,
-                    isPresentArray,
-                    isSerializationFirstNode,
-                    isSimpleElement,
-                    isSmallInt,
-                    keys,
-                    logStep,
-                    mapPresentArray,
-                    reverse,
-                    strip,
-                    tuple,
-                    unreachable,
-                    unwrap,
-                    unwrapHandle,
-                    unwrapTemplate,
-                    values,
-                    verifySteps
-          }, Symbol.toStringTag, { value: 'Module' });
-
           /**
             @module @ember/debug
           */
@@ -1882,9 +1365,13 @@ var define, require;
             @since 3.14.0
           */
           function captureRenderTree(app) {
+            let domRenderer = app.lookup('renderer:-dom');
+            if (!domRenderer) {
+              throw new Error(`BUG: owner is missing renderer`);
+            }
             // SAFETY: Ideally we'd assert here but that causes awkward circular requires since this is also in @ember/debug.
             // This is only for debug stuff so not very risky.
-            let renderer = expect(app.lookup('renderer:-dom'), `BUG: owner is missing renderer`);
+            let renderer = domRenderer;
             return renderer.debugRenderTree.capture();
           }
 
@@ -2235,7 +1722,7 @@ var define, require;
                     guidFor,
                     intern: intern$1,
                     isInternalSymbol,
-                    isObject: isObject$1,
+                    isObject,
                     isProxy,
                     lookupDescriptor,
                     observerListenerMetaFor,
@@ -2268,70 +1755,291 @@ var define, require;
           };
 
           /**
-            The hash of enabled Canary features. Add to this, any canary features
-            before creating your application.
+            The hash of enabled Canary features. Add to this, any canary features
+            before creating your application.
+
+            @class FEATURES
+            @static
+            @since 1.1.0
+            @public
+          */
+          const FEATURES = Object.assign(DEFAULT_FEATURES, ENV.FEATURES);
+
+          /**
+            Determine whether the specified `feature` is enabled. Used by Ember's
+            build tools to exclude experimental features from beta/stable builds.
+
+            You can define the following configuration options:
+
+            * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+              enabled/disabled.
+
+            @method isEnabled
+            @param {String} feature The feature to check
+            @return {Boolean}
+            @since 1.1.0
+            @public
+          */
+          function isEnabled(feature) {
+            let value = FEATURES[feature];
+            if (value === true || value === false) {
+              return value;
+            } else if (ENV.ENABLE_OPTIONAL_FEATURES) {
+              return true;
+            } else {
+              return false;
+            }
+          }
+
+          // Uncomment the below when features are present:
+
+          // function featureValue(value: null | boolean) {
+          //   if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {
+          //     return true;
+          //   }
+
+          //   return value;
+          // }
+          //
+          // export const FLAG_NAME = featureValue(FEATURES.FLAG_NAME);
+
+          const emberCanaryFeaturesIndex = /*#__PURE__*/Object.defineProperty({
+                    __proto__: null,
+                    DEFAULT_FEATURES,
+                    FEATURES,
+                    isEnabled
+          }, Symbol.toStringTag, { value: 'Module' });
+
+          // These versions should be the version that the deprecation was _introduced_,
+          // not the version that the feature will be removed.
+
+          /** Introduced in 4.0.0-beta.1 */
+          const ASSIGN = true;
+
+          const emberDeprecatedFeaturesIndex = /*#__PURE__*/Object.defineProperty({
+                    __proto__: null,
+                    ASSIGN
+          }, Symbol.toStringTag, { value: 'Module' });
+
+          const EMPTY_ARRAY = Object.freeze([]);
+          function emptyArray() {
+            return EMPTY_ARRAY;
+          }
+          const EMPTY_STRING_ARRAY = emptyArray(),
+            EMPTY_NUMBER_ARRAY = emptyArray();
+
+          /**
+           * This function returns `true` if the input array is the special empty array sentinel,
+           * which is sometimes used for optimizations.
+           */
+          function isEmptyArray(input) {
+            return input === EMPTY_ARRAY;
+          }
+          function* reverse(input) {
+            for (let i = input.length - 1; i >= 0; i--)
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+            yield input[i];
+          }
+          function* enumerate(input) {
+            let i = 0;
+            for (const item of input) yield [i++, item];
+          }
+
+          /**
+           * Zip two tuples with the same type and number of elements.
+           */
+          function* zipTuples(left, right) {
+            for (let i = 0; i < left.length; i++) yield [i, left[i], right[i]];
+          }
+          function* zipArrays(left, right) {
+            for (let i = 0; i < left.length; i++) {
+              const perform = i < right.length ? "retain" : "pop";
+              yield [perform, i, left[i], right[i]];
+            }
+            for (let i = left.length; i < right.length; i++) yield ["push", i, void 0, right[i]];
+          }
+          function isPresentArray$2(list) {
+            return !!list && list.length > 0;
+          }
+          function getLast$1(list) {
+            return 0 === list.length ? void 0 : list[list.length - 1];
+          }
+          function dict() {
+            return Object.create(null);
+          }
+          function isDict(u) {
+            return null != u;
+          }
+          function isIndexable(u) {
+            return "function" == typeof u || "object" == typeof u && null !== u;
+          }
+          class StackImpl {
+            constructor(values = []) {
+              this.current = null, this.stack = values;
+            }
+            get size() {
+              return this.stack.length;
+            }
+            push(item) {
+              this.current = item, this.stack.push(item);
+            }
+            pop() {
+              let item = this.stack.pop();
+              return this.current = getLast$1(this.stack) ?? null, void 0 === item ? null : item;
+            }
+            nth(from) {
+              let len = this.stack.length;
+              return len < from ? null : this.stack[len - from];
+            }
+            isEmpty() {
+              return 0 === this.stack.length;
+            }
+            snapshot() {
+              return [...this.stack];
+            }
+            toArray() {
+              return this.stack;
+            }
+          }
+
+          /// <reference types="qunit" />
+          let beginTestSteps, endTestSteps, verifySteps, logStep;
+          function clearElement(parent) {
+            let current = parent.firstChild;
+            for (; current;) {
+              let next = current.nextSibling;
+              parent.removeChild(current), current = next;
+            }
+          }
+
+          /**
+            Strongly hint runtimes to intern the provided string.
 
-            @class FEATURES
-            @static
-            @since 1.1.0
-            @public
-          */
-          const FEATURES = Object.assign(DEFAULT_FEATURES, ENV.FEATURES);
+            When do I need to use this function?
 
-          /**
-            Determine whether the specified `feature` is enabled. Used by Ember's
-            build tools to exclude experimental features from beta/stable builds.
+            For the most part, never. Pre-mature optimization is bad, and often the
+            runtime does exactly what you need it to, and more often the trade-off isn't
+            worth it.
 
-            You can define the following configuration options:
+            Why?
 
-            * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
-              enabled/disabled.
+            Runtimes store strings in at least 2 different representations:
+            Ropes and Symbols (interned strings). The Rope provides a memory efficient
+            data-structure for strings created from concatenation or some other string
+            manipulation like splitting.
 
-            @method isEnabled
-            @param {String} feature The feature to check
-            @return {Boolean}
-            @since 1.1.0
-            @public
-          */
-          function isEnabled(feature) {
-            let value = FEATURES[feature];
-            if (value === true || value === false) {
-              return value;
-            } else if (ENV.ENABLE_OPTIONAL_FEATURES) {
-              return true;
-            } else {
-              return false;
-            }
-          }
+            Unfortunately checking equality of different ropes can be quite costly as
+            runtimes must resort to clever string comparison algorithms. These
+            algorithms typically cost in proportion to the length of the string.
+            Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+            unique by their string content, equality checks can be done by pointer
+            comparison.
 
-          // Uncomment the below when features are present:
+            How do I know if my string is a rope or symbol?
 
-          // function featureValue(value: null | boolean) {
-          //   if (ENV.ENABLE_OPTIONAL_FEATURES && value === null) {
-          //     return true;
-          //   }
+            Typically (warning general sweeping statement, but truthy in runtimes at
+            present) static strings created as part of the JS source are interned.
+            Strings often used for comparisons can be interned at runtime if some
+            criteria are met.  One of these criteria can be the size of the entire rope.
+            For example, in chrome 38 a rope longer then 12 characters will not
+            intern, nor will segments of that rope.
 
-          //   return value;
-          // }
-          //
-          // export const FLAG_NAME = featureValue(FEATURES.FLAG_NAME);
+            Some numbers: http://jsperf.com/eval-vs-keys/8
 
-          const emberCanaryFeaturesIndex = /*#__PURE__*/Object.defineProperty({
-                    __proto__: null,
-                    DEFAULT_FEATURES,
-                    FEATURES,
-                    isEnabled
-          }, Symbol.toStringTag, { value: 'Module' });
+            Known Trick™
 
-          // These versions should be the version that the deprecation was _introduced_,
-          // not the version that the feature will be removed.
+            @private
+            @return {String} interned version of the provided string
+          */
+          function intern(str) {
+            let obj = {};
+            obj[str] = 1;
+            for (let key in obj) if (key === str) return key;
+            return str;
+          }
+          const SERIALIZATION_FIRST_NODE_STRING = "%+b:0%";
+          function isSerializationFirstNode(node) {
+            return "%+b:0%" === node.nodeValue;
+          }
+          const assign = Object.assign;
+          function values(obj) {
+            return Object.values(obj);
+          }
+          function entries(dict) {
+            return Object.entries(dict);
+          }
+          function keys(obj) {
+            return Object.keys(obj);
+          }
+          function strip(strings, ...args) {
+            let out = "";
+            for (const [i, string] of enumerate(strings)) out += `${string}${void 0 !== args[i] ? String(args[i]) : ""}`;
+            let lines = out.split("\n");
+            for (; isPresentArray$2(lines) && /^\s*$/u.test(0 === (list = lines).length ? void 0 : list[0]);) lines.shift();
+            for (var list; isPresentArray$2(lines) && /^\s*$/u.test(getLast$1(lines));) lines.pop();
+            let min = 1 / 0;
+            for (let line of lines) {
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+              let leading = /^\s*/u.exec(line)[0].length;
+              min = Math.min(min, leading);
+            }
+            let stripped = [];
+            for (let line of lines) stripped.push(line.slice(min));
+            return stripped.join("\n");
+          }
 
-          /** Introduced in 4.0.0-beta.1 */
-          const ASSIGN = true;
+          /**
+           * This constant exists to make it easier to differentiate normal logs from
+           * errant console.logs. LOCAL_LOGGER should only be used inside a
+           * LOCAL_TRACE_LOGGING check.
+           *
+           * It does not alleviate the need to check LOCAL_TRACE_LOGGING, which is used
+           * for stripping.
+           */
+          const LOCAL_LOGGER = console,
+            LOGGER = console;
 
-          const emberDeprecatedFeaturesIndex = /*#__PURE__*/Object.defineProperty({
+          /**
+           * This constant exists to make it easier to differentiate normal logs from
+           * errant console.logs. LOGGER can be used outside of LOCAL_TRACE_LOGGING checks,
+           * and is meant to be used in the rare situation where a console.* call is
+           * actually appropriate.
+           */
+          function assertNever(value, desc = "unexpected unreachable branch") {
+            throw LOGGER.log("unreachable", value), LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`), new Error("code reached unreachable");
+          }
+
+          const glimmerUtil = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,
-                    ASSIGN
+                    EMPTY_ARRAY,
+                    EMPTY_NUMBER_ARRAY,
+                    EMPTY_STRING_ARRAY,
+                    LOCAL_LOGGER,
+                    LOGGER,
+                    SERIALIZATION_FIRST_NODE_STRING,
+                    Stack: StackImpl,
+                    assertNever,
+                    assign,
+                    beginTestSteps,
+                    clearElement,
+                    dict,
+                    emptyArray,
+                    endTestSteps,
+                    entries,
+                    enumerate,
+                    intern,
+                    isDict,
+                    isEmptyArray,
+                    isIndexable,
+                    isSerializationFirstNode,
+                    keys,
+                    logStep,
+                    reverse,
+                    strip,
+                    values,
+                    verifySteps,
+                    zipArrays,
+                    zipTuples
           }, Symbol.toStringTag, { value: 'Module' });
 
           const opcodes = {
@@ -2404,9 +2112,8 @@ var define, require;
               p: 2,
               a: 3
             };
-
-          // eslint-disable-next-line @typescript-eslint/naming-convention
           function is(variant) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return function (value) {
               return Array.isArray(value) && value[0] === variant;
             };
@@ -7692,20 +7399,19 @@ var define, require;
                     tokenize
           }, Symbol.toStringTag, { value: 'Module' });
 
-          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;
@@ -7713,13 +7419,13 @@ var define, require;
           }
           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;
@@ -7747,10 +7453,8 @@ var define, require;
             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`,
@@ -7973,10 +7677,10 @@ var define, require;
               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");
@@ -7998,6 +7702,7 @@ var define, require;
           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) {
@@ -8009,28 +7714,39 @@ var define, require;
            * 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$1(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
             }),
@@ -8049,33 +7765,19 @@ var define, require;
               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;
             }
             first(kind) {
               for (const when of this._whens) {
                 const value = when.match(kind);
-                if (isPresentArray(value)) return value[0];
+                if (isPresentArray$1(value)) return value[0];
               }
               return null;
             }
           }
           class When {
-            _map = new Map();
             get(pattern, or) {
               let value = this._map.get(pattern);
               return value || (value = or(), this._map.set(pattern, value), value);
@@ -8086,9 +7788,9 @@ var define, require;
             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;
@@ -8099,30 +7801,32 @@ var define, require;
                 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$1(), 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) {
@@ -8138,8 +7842,6 @@ var define, require;
                 chars: slice[0]
               });
             }
-            chars;
-            loc;
             constructor(options) {
               this.loc = options.loc, this.chars = options.chars;
             }
@@ -8151,9 +7853,6 @@ var define, require;
             }
           }
 
-          /**
-           * All spans have these details in common.
-           */
           /**
            * A `SourceSpan` object represents a span of characters inside of a template source.
            *
@@ -8190,10 +7889,10 @@ var define, require;
            */
           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),
@@ -8212,14 +7911,22 @@ var define, require;
               }).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();
@@ -8359,10 +8066,9 @@ var define, require;
             }
           }
           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);
@@ -8381,11 +8087,11 @@ var define, require;
             }
             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
                 });
@@ -8408,24 +8114,23 @@ var define, require;
             }
           }
           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
               };
@@ -8459,12 +8164,12 @@ var define, require;
               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
                 });
@@ -8482,10 +8187,10 @@ var define, require;
             }
             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 || "";
               }
             }
@@ -8521,25 +8226,21 @@ var define, require;
               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
@@ -8570,7 +8271,7 @@ var define, require;
             * 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;
@@ -8615,7 +8316,7 @@ var define, require;
               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();
               }
             }
             /**
@@ -8634,11 +8335,8 @@ var define, require;
             }
           }
           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`.
@@ -8681,10 +8379,8 @@ var define, require;
             }
           }
           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
@@ -8754,17 +8450,17 @@ var define, require;
            *
            * @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 {
@@ -8777,7 +8473,7 @@ var define, require;
             /**
             * 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) {
@@ -8808,7 +8504,6 @@ var define, require;
               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 {
@@ -8832,7 +8527,7 @@ var define, require;
                   if (seenChars + column > nextLine) return nextLine;
                   {
                     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;
                 }
@@ -8846,7 +8541,6 @@ var define, require;
             static range(span, fallback = SourceSpan.NON_EXISTENT) {
               return new SpanList(span.map(loc)).getRangeOffset(fallback);
             }
-            _span;
             constructor(span = []) {
               this._span = span;
             }
@@ -8854,7 +8548,7 @@ var define, require;
               this._span.push(offset);
             }
             getRangeOffset(fallback) {
-              if (isPresentArray(this._span)) {
+              if (isPresentArray$1(this._span)) {
                 let first = getFirst(this._span),
                   last = getLast(this._span);
                 return first.extend(last);
@@ -8876,7 +8570,7 @@ var define, require;
           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,
@@ -8934,7 +8628,10 @@ var define, require;
                 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);
@@ -8946,9 +8643,6 @@ var define, require;
             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;
             }
@@ -8962,7 +8656,6 @@ var define, require;
             }
           }
           class PathParentsIterator {
-            path;
             constructor(path) {
               this.path = path;
             }
@@ -8992,7 +8685,10 @@ var define, require;
                 parentKey: parentKey
               } = path,
               handler = function (visitor, nodeType) {
-                if (visitor.Program && ("Template" === nodeType && !visitor.Template || "Block" === nodeType && !visitor.Block)) return deprecate$1(`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);
@@ -9037,9 +8733,11 @@ var define, require;
                 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);
@@ -9050,7 +8748,7 @@ var define, require;
           }
           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);
             }
@@ -9062,9 +8760,8 @@ var define, require;
             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());
@@ -9104,9 +8801,6 @@ var define, require;
           function SOURCE() {
             return _SOURCE || (_SOURCE = new Source("", "(synthetic)")), _SOURCE;
           }
-
-          // const SOURCE = new Source('', '(tests)');
-          // Statements
           function buildVar$1(name, loc) {
             return b.var({
               name: name,
@@ -9118,7 +8812,7 @@ var define, require;
             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
@@ -9139,7 +8833,7 @@ var define, require;
               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)
@@ -9226,11 +8920,11 @@ var define, require;
             block: function (path, params, hash, _defaultBlock, _elseBlock = null, loc, openStrip, inverseStrip, closeStrip) {
               let defaultBlock,
                 elseBlock = null;
-              return "Template" === _defaultBlock.type ? (deprecate$1("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$1("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
@@ -9258,9 +8952,7 @@ var define, require;
                 loc: buildLoc(loc || null)
               });
             },
-            element:
-            // Nodes
-            function (tag, options = {}) {
+            element: function (tag, options = {}) {
               let path,
                 selfClosing,
                 {
@@ -9274,10 +8966,10 @@ var define, require;
                   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$1(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 || [],
@@ -9323,7 +9015,7 @@ var define, require;
               });
             },
             concat: function (parts, loc) {
-              if (!isPresentArray(parts)) throw new Error("b.concat requires at least one part");
+              if (!isPresentArray$1(parts)) throw new Error("b.concat requires at least one part");
               return b.concat({
                 parts: parts,
                 loc: buildLoc(loc || null)
@@ -9339,7 +9031,7 @@ var define, require;
             },
             literal: buildLiteral,
             program: function (body, blockParams, loc) {
-              return deprecate$1("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,
@@ -9410,21 +9102,21 @@ var define, require;
               }
               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,
@@ -9445,7 +9137,7 @@ var define, require;
               }
               mustache({
                 path: path,
-                params: params,
+                params: params1,
                 hash: hash,
                 trusting: trusting,
                 loc: loc,
@@ -9471,15 +9163,15 @@ var define, require;
                   return Object.defineProperty(node, "escaped", {
                     enumerable: !1,
                     get() {
-                      return deprecate$1("The escaped property on mustache nodes is deprecated, use trusting instead"), !this.trusting;
+                      return !this.trusting;
                     },
-                    set(value) {
-                      deprecate$1("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,
@@ -9488,7 +9180,7 @@ var define, require;
               }
               block({
                 path: path,
-                params: params,
+                params: params1,
                 hash: hash,
                 defaultBlock: defaultBlock,
                 elseBlock = null,
@@ -9500,7 +9192,7 @@ var define, require;
                 return {
                   type: "BlockStatement",
                   path: path,
-                  params: params,
+                  params: params1,
                   hash: hash,
                   program: defaultBlock,
                   inverse: elseBlock,
@@ -9511,22 +9203,22 @@ var define, require;
                 };
               }
               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
                 };
               }
@@ -9542,23 +9234,23 @@ var define, require;
               }
               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,
@@ -9574,9 +9266,9 @@ var define, require;
                     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() {
@@ -9589,27 +9281,27 @@ var define, require;
               }
               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
                 };
               }
@@ -9625,14 +9317,14 @@ var define, require;
               }
               sexpr({
                 path: path,
-                params: params,
+                params: params1,
                 hash: hash,
                 loc: loc
               }) {
                 return {
                   type: "SubExpression",
                   path: path,
-                  params: params,
+                  params: params1,
                   hash: hash,
                   loc: loc
                 };
@@ -9655,7 +9347,7 @@ var define, require;
                       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
@@ -9663,8 +9355,7 @@ var define, require;
                   return Object.defineProperty(node, "parts", {
                     enumerable: !1,
                     get() {
-                      deprecate$1("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("@") && (
@@ -9672,7 +9363,6 @@ var define, require;
                       parts[0] = parts[0].slice(1)), Object.freeze(parts);
                     },
                     set(values) {
-                      deprecate$1("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
@@ -9681,12 +9371,12 @@ var define, require;
                   }), Object.defineProperty(node, "this", {
                     enumerable: !1,
                     get() {
-                      return deprecate$1("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$1("The data property on path nodes is deprecated, use head.type instead"), "AtHead" === this.head.type;
+                      return "AtHead" === this.head.type;
                     }
                   }), node;
                 }({
@@ -9721,7 +9411,7 @@ var define, require;
                 };
               }
               atName({
-                name: name,
+                name: name1,
                 loc: loc
               }) {
                 let _name = "";
@@ -9731,7 +9421,7 @@ var define, require;
                     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;
@@ -9742,10 +9432,10 @@ var define, require;
                   loc: loc
                 };
                 // trigger the assertions
-                return node.name = name, node;
+                return node.name = name1, node;
               }
               var({
-                name: name,
+                name: name1,
                 loc: loc
               }) {
                 let _name = "";
@@ -9755,7 +9445,7 @@ var define, require;
                     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;
@@ -9766,7 +9456,7 @@ var define, require;
                   loc: loc
                 };
                 // trigger the assertions
-                return node.name = name, node;
+                return node.name = name1, node;
               }
               hash({
                 pairs: pairs,
@@ -9780,56 +9470,50 @@ var define, require;
               }
               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$1("The original property on literal nodes is deprecated, use value instead"), this.value;
+                      return this.value;
                     },
-                    set(value) {
-                      deprecate$1("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 {
@@ -9851,33 +9535,33 @@ var define, require;
               // 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,
@@ -9887,20 +9571,13 @@ var define, require;
                 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,
@@ -9913,10 +9590,7 @@ var define, require;
               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,
@@ -9937,14 +9611,12 @@ var define, require;
               // 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,
@@ -9953,22 +9625,19 @@ var define, require;
                 } = 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
@@ -9985,11 +9654,9 @@ var define, require;
                     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,
@@ -10105,7 +9772,7 @@ var define, require;
                     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;
@@ -10276,6 +9943,17 @@ var define, require;
                 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;
@@ -10296,8 +9974,8 @@ var define, require;
                   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)) : [],
-              end = isPresentArray(params) ? getLast(params).loc : path.loc;
+            const params = node.params.map(e => compiler.acceptNode(e)),
+              end = isPresentArray$1(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)
             return {
@@ -10330,14 +10008,28 @@ var define, require;
             });
             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;
             }
@@ -10402,18 +10094,16 @@ var define, require;
                   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,
@@ -10454,7 +10144,7 @@ var define, require;
                 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;
@@ -10469,7 +10159,7 @@ var define, require;
               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;
               }
@@ -10543,7 +10233,7 @@ var define, require;
             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 = {
@@ -10551,7 +10241,7 @@ var define, require;
               };
               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"
@@ -10568,7 +10258,7 @@ var define, require;
                   }
                 },
                 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/>..."
@@ -10578,7 +10268,7 @@ var define, require;
                   };
                 },
                 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 = {
@@ -10608,7 +10298,7 @@ var define, require;
                   }
                 },
                 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
@@ -10639,7 +10329,7 @@ var define, require;
                   }
                 },
                 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
@@ -10665,26 +10355,22 @@ var define, require;
                   }, 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({
@@ -10698,30 +10384,27 @@ var define, require;
                 // <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);
                 }
               }
-              return isPresentArray(parts) ? parts[0] : b.text({
+              return isPresentArray$1(parts) ? parts[0] : b.text({
                 chars: "",
                 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,
@@ -10749,7 +10432,7 @@ var define, require;
               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
@@ -10764,7 +10447,7 @@ var define, require;
            * Adds tokens to the tokensSet based on their node.type
            */
           function addTokens(tokensSet, node, scopedTokens, options) {
-            const maybeTokens = function (node, scopedTokens, options) {
+            const maybePathName = function (node, scopedTokens, options) {
               if ("PathExpression" === node.type) {
                 if ("AtHead" === node.head.type || "ThisHead" === node.head.type) return;
                 const possbleToken = node.head.name;
@@ -10776,6 +10459,7 @@ var define, require;
                   char = tag.charAt(0);
                 if (":" === char || "@" === char) return;
                 if (!options.includeHtmlElements && -1 === tag.indexOf(".") && tag.toLowerCase() === tag) return;
+                // eslint-disable-next-line @typescript-eslint/no-deprecated -- @fixme
                 if ("this." === tag.substr(0, 5)) return;
                 // the tag may be from a yielded object
                 // example:
@@ -10790,12 +10474,10 @@ var define, require;
                 return tag;
               }
             }(node, scopedTokens, options);
-            (Array.isArray(maybeTokens) ? maybeTokens : [maybeTokens]).forEach(maybeToken => {
-              if (void 0 !== maybeToken && "@" !== maybeToken[0]) {
-                const maybeTokenFirstSegment = maybeToken.split(".")[0];
-                scopedTokens.includes(maybeTokenFirstSegment) || tokensSet.add(maybeToken.split(".")[0]);
-              }
-            });
+            if (void 0 !== maybePathName && "@" !== maybePathName[0]) {
+              const maybeFirstPathSegment = maybePathName.split(".")[0];
+              maybeFirstPathSegment && !scopedTokens.includes(maybeFirstPathSegment) && tokensSet.add(maybeFirstPathSegment);
+            }
           }
 
           /**
@@ -10838,51 +10520,21 @@ var define, require;
                 }) {
                   blockParams.forEach(() => {
                     scopedTokens.pop();
-                  });
-                }
-              },
-              PathExpression(node) {
-                addTokens(tokensSet, node, scopedTokens, options);
-              }
-            });
-            let tokens = [];
-            return tokensSet.forEach(s => tokens.push(s)), options?.includeKeywords || (tokens = tokens.filter(token => !isKeyword(token))), tokens;
-          }
-
-          /**
-           * 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 });
-           * ```
-           */
+                  });
+                }
+              },
+              PathExpression(node) {
+                addTokens(tokensSet, node, scopedTokens, options);
+              }
+            });
+            let tokens = [];
+            return tokensSet.forEach(s => tokens.push(s)), options.includeKeywords || (tokens = tokens.filter(token => !isKeyword(token))), tokens;
+          }
           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);
                   }
@@ -10891,7 +10543,6 @@ var define, require;
             }
             return {
               fields: () => class {
-                // SAFETY: initialized via `assign` in the constructor.
                 constructor(fields) {
                   assign(this, fields);
                 }
@@ -10996,30 +10647,11 @@ var define, require;
            * ```
            */
           let NamedArgument$1 = 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.
            *
@@ -11050,13 +10682,6 @@ var define, require;
            * 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() {}
@@ -11099,11 +10724,6 @@ var define, require;
             }
           };
 
-          /**
-           * A Handlebars literal.
-           *
-           * {@link https://handlebarsjs.com/guide/expressions.html#literal-segments}
-           */
           /**
            * Corresponds to a Handlebars literal.
            *
@@ -11179,9 +10799,6 @@ var define, require;
            * Corresponds to a collection of named blocks.
            */
           let NamedBlocks$1 = 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;
             }
@@ -11228,18 +10845,7 @@ var define, require;
            */
           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",
@@ -11283,7 +10889,7 @@ var define, require;
             * ^ 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
@@ -11300,7 +10906,7 @@ var define, require;
             * ^ 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;
@@ -11308,11 +10914,11 @@ var define, require;
             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;
               }
             }
@@ -11320,26 +10926,19 @@ var define, require;
               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$1,
             Block: Block,
-            COMPONENT_NAMESPACE: COMPONENT_NAMESPACE,
+            COMPONENT_NAMESPACE: "Component",
             CallExpression: CallExpression$1,
             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,
@@ -11351,7 +10950,7 @@ var define, require;
             LiteralExpression: LiteralExpression,
             LocalVarReference: LocalVarReference,
             LooseModeResolution: LooseModeResolution,
-            MODIFIER_NAMESPACE: MODIFIER_NAMESPACE,
+            MODIFIER_NAMESPACE: "Modifier",
             NamedArgument: NamedArgument$1,
             NamedArguments: NamedArguments$1,
             NamedBlock: NamedBlock$1,
@@ -11369,30 +10968,7 @@ var define, require;
             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
@@ -11408,15 +10984,11 @@ var define, require;
           }
           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);
             }
@@ -11429,12 +11001,6 @@ var define, require;
             getUsedTemplateLocals() {
               return this.usedTemplateLocals;
             }
-            setHasDebugger() {
-              this.#hasDebugger = !0;
-            }
-            get hasEval() {
-              return this.#hasDebugger;
-            }
             has(name) {
               return this.templateLocals.includes(name);
             }
@@ -11446,7 +11012,7 @@ var define, require;
               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
@@ -11472,6 +11038,9 @@ var define, require;
             constructor(parent, symbols, slots) {
               super(), this.parent = parent, this.symbols = symbols, this.slots = slots;
             }
+            root() {
+              return this.parent.root();
+            }
             get locals() {
               return this.symbols;
             }
@@ -11493,17 +11062,19 @@ var define, require;
             }
             #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);
@@ -11518,10 +11089,7 @@ var define, require;
               return this.parent.allocate(identifier);
             }
           }
-          var api = Object.freeze({
-            __proto__: null
-          });
-          let Builder$1 = class Builder {
+          class Builder {
             // TEMPLATE //
             template(symbols, body, loc) {
               return new Template$1({
@@ -11639,8 +11207,7 @@ var define, require;
               });
             }
             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,
@@ -11655,7 +11222,7 @@ var define, require;
               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,
@@ -11663,7 +11230,7 @@ var define, require;
               });
             }
             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,
@@ -11678,7 +11245,7 @@ var define, require;
               });
             }
             interpolate(parts, loc) {
-              return assertPresentArray(parts), new InterpolateExpression$1({
+              return new InterpolateExpression$1({
                 loc: loc,
                 parts: parts
               });
@@ -11735,11 +11302,10 @@ var define, require;
             element(options) {
               return new BuildElement(options);
             }
-          };
+          }
           class BuildElement {
-            builder;
             constructor(base) {
-              this.base = base, this.builder = new Builder$1();
+              this.base = base, this.builder = new Builder();
             }
             simple(tag, body, loc) {
               return new SimpleElement$1(assign({
@@ -11790,16 +11356,16 @@ var define, require;
             }
           }
           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;
           }
 
           /**
@@ -11807,7 +11373,7 @@ var define, require;
            * 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;
           }
 
           /**
@@ -11883,9 +11449,8 @@ var define, require;
            * `BlockContext` is stateless.
            */
           class BlockContext {
-            builder;
             constructor(source, options, table) {
-              this.source = source, this.options = options, this.table = table, this.builder = new Builder$1();
+              this.source = source, this.options = options, this.table = table, this.builder = new Builder();
             }
             get strict() {
               return this.options.strictMode || !1;
@@ -11940,12 +11505,6 @@ var define, require;
             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":
@@ -11955,7 +11514,7 @@ var define, require;
                 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
@@ -12041,6 +11600,10 @@ var define, require;
                 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":
                   {
@@ -12205,7 +11768,7 @@ var define, require;
                   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)),
@@ -12298,7 +11861,7 @@ var define, require;
               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
@@ -12327,7 +11890,7 @@ var define, require;
               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
@@ -12399,9 +11962,6 @@ var define, require;
             }
           }
           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$1), this.hasSemanticContent = Boolean(children.filter(c => {
                 if (c instanceof NamedBlock$1) return !1;
@@ -12419,13 +11979,13 @@ var define, require;
           }
           class TemplateChildren extends Children {
             assertTemplate(table) {
-              if (isPresentArray(this.namedBlocks)) throw generateSyntaxError("Unexpected named block at the top-level of a template", this.loc);
+              if (isPresentArray$1(this.namedBlocks)) throw generateSyntaxError("Unexpected named block at the top-level of a template", this.loc);
               return this.block.builder.template(table, this.nonBlockChildren, this.block.loc(this.loc));
             }
           }
           class BlockChildren extends Children {
             assertBlock(table) {
-              if (isPresentArray(this.namedBlocks)) throw generateSyntaxError("Unexpected named block nested in a normal block", this.loc);
+              if (isPresentArray$1(this.namedBlocks)) throw generateSyntaxError("Unexpected named block nested in a normal block", this.loc);
               return this.block.builder.block(table, this.nonBlockChildren, this.loc);
             }
           }
@@ -12435,7 +11995,7 @@ var define, require;
             }
             assertNamedBlock(name, table) {
               if (this.el.base.selfClosing) throw generateSyntaxError(`<:${name.chars}/> is not a valid named block: named blocks cannot be self-closing`, this.loc);
-              if (isPresentArray(this.namedBlocks)) throw generateSyntaxError(`Unexpected named block inside <:${name.chars}> named block: named blocks cannot contain nested named blocks`, this.loc);
+              if (isPresentArray$1(this.namedBlocks)) throw generateSyntaxError(`Unexpected named block inside <:${name.chars}> named block: named blocks cannot contain nested named blocks`, this.loc);
               if ((tag = name.chars)[0] !== tag[0]?.toLowerCase() || tag[0] === tag[0]?.toUpperCase()) throw generateSyntaxError(`<:${name.chars}> is not a valid named block, and named blocks must begin with a lowercase letter`, this.loc);
               var tag;
               if (this.el.base.attrs.length > 0 || this.el.base.componentArgs.length > 0 || this.el.base.modifiers.length > 0) throw generateSyntaxError(`named block <:${name.chars}> cannot have attributes, arguments, or modifiers`, this.loc);
@@ -12444,7 +12004,7 @@ var define, require;
             }
             assertElement(name, hasBlockParams) {
               if (hasBlockParams) throw generateSyntaxError(`Unexpected block params in <${name.chars}>: simple elements cannot have block params`, this.loc);
-              if (isPresentArray(this.namedBlocks)) {
+              if (isPresentArray$1(this.namedBlocks)) {
                 let names = this.namedBlocks.map(b => b.name);
                 if (1 === names.length) throw generateSyntaxError(`Unexpected named block <:foo> inside <${name.chars}> HTML element`, this.loc);
                 {
@@ -12455,8 +12015,8 @@ var define, require;
               return this.el.simple(name, this.nonBlockChildren, this.loc);
             }
             assertComponent(name, table, hasBlockParams) {
-              if (isPresentArray(this.namedBlocks) && this.hasSemanticContent) throw generateSyntaxError(`Unexpected content inside <${name}> component invocation: when using named blocks, the tag cannot contain other content`, this.loc);
-              if (isPresentArray(this.namedBlocks)) {
+              if (isPresentArray$1(this.namedBlocks) && this.hasSemanticContent) throw generateSyntaxError(`Unexpected content inside <${name}> component invocation: when using named blocks, the tag cannot contain other content`, this.loc);
+              if (isPresentArray$1(this.namedBlocks)) {
                 if (hasBlockParams) throw generateSyntaxError(`Unexpected block params list on <${name}> component invocation: when passing named blocks, the invocation tag cannot take block params`, this.loc);
                 let seenNames = new Set();
                 for (let block of this.namedBlocks) {
@@ -12498,9 +12058,7 @@ var define, require;
 
           const glimmerSyntax = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,
-                    AST: api,
-                    ASTv1: api,
-                    ASTv2: api$1,
+                    ASTv2: api,
                     BlockSymbolTable,
                     KEYWORDS_TYPES,
                     Path: Walker,
@@ -12526,242 +12084,35 @@ var define, require;
                     preprocess,
                     print: build,
                     sortByLoc,
-                    src: api$2,
+                    src: api$1,
                     traverse,
                     visitorKeys
           }, Symbol.toStringTag, { value: 'Module' });
 
-          const ContentType = {
-              Component: 0,
-              Helper: 1,
-              String: 2,
-              Empty: 3,
-              SafeString: 4,
-              Fragment: 5,
-              Node: 6,
-              Other: 8
-            },
-            CurriedTypes = {
-              Component: 0,
-              Helper: 1,
-              Modifier: 2
-            },
-            InternalComponentCapabilities = {
-              Empty: 0,
-              dynamicLayout: 1,
-              dynamicTag: 2,
-              prepareArgs: 4,
-              createArgs: 8,
-              attributeHook: 16,
-              elementHook: 32,
-              dynamicScope: 64,
-              createCaller: 128,
-              updateHook: 256,
-              createInstance: 512,
-              wrapped: 1024,
-              willDestroy: 2048,
-              hasSubOwner: 4096
-            },
-            ARG_SHIFT = 8,
-            MAX_SIZE = 2147483647,
-            TYPE_SIZE = 255,
-            TYPE_MASK = 255,
-            OPERAND_LEN_MASK = 768,
-            MACHINE_MASK = 1024,
-            MachineOp = {
-              PushFrame: 0,
-              PopFrame: 1,
-              InvokeVirtual: 2,
-              InvokeStatic: 3,
-              Jump: 4,
-              Return: 5,
-              ReturnTo: 6,
-              Size: 7
-            },
-            Op = {
-              Helper: 16,
-              SetNamedVariables: 17,
-              SetBlocks: 18,
-              SetVariable: 19,
-              SetBlock: 20,
-              GetVariable: 21,
-              GetProperty: 22,
-              GetBlock: 23,
-              SpreadBlock: 24,
-              HasBlock: 25,
-              HasBlockParams: 26,
-              Concat: 27,
-              Constant: 28,
-              ConstantReference: 29,
-              Primitive: 30,
-              PrimitiveReference: 31,
-              ReifyU32: 32,
-              Dup: 33,
-              Pop: 34,
-              Load: 35,
-              Fetch: 36,
-              RootScope: 37,
-              VirtualRootScope: 38,
-              ChildScope: 39,
-              PopScope: 40,
-              Text: 41,
-              Comment: 42,
-              AppendHTML: 43,
-              AppendSafeHTML: 44,
-              AppendDocumentFragment: 45,
-              AppendNode: 46,
-              AppendText: 47,
-              OpenElement: 48,
-              OpenDynamicElement: 49,
-              PushRemoteElement: 50,
-              StaticAttr: 51,
-              DynamicAttr: 52,
-              ComponentAttr: 53,
-              FlushElement: 54,
-              CloseElement: 55,
-              PopRemoteElement: 56,
-              Modifier: 57,
-              BindDynamicScope: 58,
-              PushDynamicScope: 59,
-              PopDynamicScope: 60,
-              CompileBlock: 61,
-              PushBlockScope: 62,
-              PushSymbolTable: 63,
-              InvokeYield: 64,
-              JumpIf: 65,
-              JumpUnless: 66,
-              JumpEq: 67,
-              AssertSame: 68,
-              Enter: 69,
-              Exit: 70,
-              ToBoolean: 71,
-              EnterList: 72,
-              ExitList: 73,
-              Iterate: 74,
-              Main: 75,
-              ContentType: 76,
-              Curry: 77,
-              PushComponentDefinition: 78,
-              PushDynamicComponentInstance: 79,
-              ResolveDynamicComponent: 80,
-              ResolveCurriedComponent: 81,
-              PushArgs: 82,
-              PushEmptyArgs: 83,
-              PopArgs: 84,
-              PrepareArgs: 85,
-              CaptureArgs: 86,
-              CreateComponent: 87,
-              RegisterComponentDestructor: 88,
-              PutComponentOperations: 89,
-              GetComponentSelf: 90,
-              GetComponentTagName: 91,
-              GetComponentLayout: 92,
-              BindEvalScope: 93,
-              SetupForEval: 94,
-              PopulateLayout: 95,
-              InvokeComponentLayout: 96,
-              BeginComponentTransaction: 97,
-              CommitComponentTransaction: 98,
-              DidCreateElement: 99,
-              DidRenderLayout: 100,
-              ResolveMaybeLocal: 102,
-              Debugger: 103,
-              Size: 104,
-              StaticComponentAttr: 105,
-              DynamicContentType: 106,
-              DynamicHelper: 107,
-              DynamicModifier: 108,
-              IfInline: 109,
-              Not: 110,
-              GetDynamicVar: 111,
-              Log: 112
-            };
-          function isMachineOp(value) {
-            return value >= 0 && value <= 15;
-          }
-          function isOp(value) {
-            return value >= 16;
+          /// Builder ///
+          const CURRIED_COMPONENT = 0,
+            CURRIED_HELPER = 1,
+            CURRIED_MODIFIER = 2,
+            NS_XMLNS = "http://www.w3.org/2000/xmlns/";
+          function isPresentArray(list) {
+            return !!list && list.length > 0;
           }
-
-          /**
-           * Registers
-           *
-           * For the most part, these follows MIPS naming conventions, however the
-           * register numbers are different.
-           */
-          // $0 or $pc (program counter): pointer into `program` for the next insturction; -1 means exit
-          const $pc = 0,
-            $ra = 1,
-            $fp = 2,
-            $sp = 3,
-            $s0 = 4,
-            $s1 = 5,
-            $t0 = 6,
-            $t1 = 7,
-            $v0 = 8;
-
-          // $1 or $ra (return address): pointer into `program` for the return
-          let MachineRegister = function (MachineRegister) {
-            return MachineRegister[MachineRegister.pc = 0] = "pc", MachineRegister[MachineRegister.ra = 1] = "ra", MachineRegister[MachineRegister.fp = 2] = "fp", MachineRegister[MachineRegister.sp = 3] = "sp", MachineRegister;
-          }({});
-          function isLowLevelRegister(register) {
-            return register <= 3;
+          function mapPresentArray(list, mapper) {
+            if (null === list) return null;
+            let out = [];
+            for (let item of list) out.push(mapper(item));
+            return out;
           }
-          let SavedRegister = function (SavedRegister) {
-              return SavedRegister[SavedRegister.s0 = 4] = "s0", SavedRegister[SavedRegister.s1 = 5] = "s1", SavedRegister;
-            }({}),
-            TemporaryRegister = function (TemporaryRegister) {
-              return TemporaryRegister[TemporaryRegister.t0 = 6] = "t0", TemporaryRegister[TemporaryRegister.t1 = 7] = "t1", TemporaryRegister;
-            }({});
-
-          const glimmerVm = /*#__PURE__*/Object.defineProperty({
-                    __proto__: null,
-                    $fp,
-                    $pc,
-                    $ra,
-                    $s0,
-                    $s1,
-                    $sp,
-                    $t0,
-                    $t1,
-                    $v0,
-                    ARG_SHIFT,
-                    ContentType,
-                    CurriedType: CurriedTypes,
-                    CurriedTypes,
-                    InternalComponentCapabilities,
-                    InternalComponentCapability: InternalComponentCapabilities,
-                    MACHINE_MASK,
-                    MAX_SIZE,
-                    MachineOp,
-                    MachineRegister,
-                    OPERAND_LEN_MASK,
-                    Op,
-                    SavedRegister,
-                    TYPE_MASK,
-                    TYPE_SIZE,
-                    TemporaryRegister,
-                    isLowLevelRegister,
-                    isMachineOp,
-                    isOp
-          }, Symbol.toStringTag, { value: 'Module' });
-
-          let HeadKind = function (HeadKind) {
-              return HeadKind.Block = "Block", HeadKind.Call = "Call", HeadKind.Element = "Element", HeadKind.AppendPath = "AppendPath", HeadKind.AppendExpr = "AppendExpr", HeadKind.Literal = "Literal", HeadKind.Modifier = "Modifier", HeadKind.DynamicComponent = "DynamicComponent", HeadKind.Comment = "Comment", HeadKind.Splat = "Splat", HeadKind.Keyword = "Keyword", HeadKind;
-            }({}),
-            VariableKind = function (VariableKind) {
-              return VariableKind.Local = "Local", VariableKind.Free = "Free", VariableKind.Arg = "Arg", VariableKind.Block = "Block", VariableKind.This = "This", VariableKind;
-            }({});
           function normalizeStatement(statement) {
-            if (Array.isArray(statement)) return function (statement) {
+            return Array.isArray(statement) ? function (statement) {
               if (!Array.isArray(statement)) return !1;
               const name = statement[0];
               if ("number" == typeof name) switch (name) {
-                case Builder.Literal:
-                case Builder.Get:
-                case Builder.Concat:
-                case Builder.HasBlock:
-                case Builder.HasBlockParams:
+                case 0:
+                case 5:
+                case 6:
+                case 7:
+                case 8:
                   return !0;
                 default:
                   return !1;
@@ -12786,7 +12137,7 @@ var define, require;
                     let params = null,
                       hash = null;
                     return 3 === statement.length ? (params = normalizeParams(statement[1]), hash = normalizeHash(statement[2])) : 2 === statement.length && (Array.isArray(statement[1]) ? params = normalizeParams(statement[1]) : hash = normalizeHash(statement[1])), {
-                      kind: HeadKind.Call,
+                      kind: "Call",
                       head: normalizeCallHead(name),
                       params: params,
                       hash: hash,
@@ -12803,7 +12154,7 @@ var define, require;
                       blockParams: blockParams
                     } = normalizeBuilderBlockStatement(statement);
                     return {
-                      kind: HeadKind.Block,
+                      kind: "Block",
                       head: path,
                       params: params,
                       hash: hash,
@@ -12821,7 +12172,7 @@ var define, require;
                         blockParams: blockParams
                       } = normalizeBuilderBlockStatement(statement);
                     return {
-                      kind: HeadKind.Keyword,
+                      kind: "Keyword",
                       name: name,
                       params: params,
                       hash: hash,
@@ -12834,8 +12185,8 @@ var define, require;
                     let attrs = dict(),
                       block = [];
                     return 3 === statement.length ? (attrs = normalizeAttrs(statement[1]), block = normalizeBlock(statement[2])) : 2 === statement.length && (Array.isArray(statement[1]) ? block = normalizeBlock(statement[1]) : attrs = normalizeAttrs(statement[1])), {
-                      kind: HeadKind.Element,
-                      name: expect(extractElement(name), `BUG: expected ${name} to look like a tag name`),
+                      kind: "Element",
+                      name: extractElement(name),
                       attrs: attrs,
                       block: block
                     };
@@ -12845,43 +12196,41 @@ var define, require;
               }
             }(statement) : function (statement) {
               switch (statement[0]) {
-                case Builder.Literal:
+                case 0:
                   return {
-                    kind: HeadKind.Literal,
+                    kind: "Literal",
                     value: statement[1]
                   };
-                case Builder.Append:
+                case 2:
                   return normalizeAppendExpression(statement[1], statement[2]);
-                case Builder.Modifier:
+                case 3:
                   return {
-                    kind: HeadKind.Modifier,
+                    kind: "Modifier",
                     params: normalizeParams(statement[1]),
                     hash: normalizeHash(statement[2])
                   };
-                case Builder.DynamicComponent:
+                case 4:
                   return {
-                    kind: HeadKind.DynamicComponent,
+                    kind: "DynamicComponent",
                     expr: normalizeExpression(statement[1]),
                     hash: normalizeHash(statement[2]),
                     block: normalizeBlock(statement[3])
                   };
-                case Builder.Comment:
+                case 1:
                   return {
-                    kind: HeadKind.Comment,
+                    kind: "Comment",
                     value: statement[1]
                   };
               }
-            }(statement);
-            if ("string" == typeof statement) return normalizeAppendHead(normalizeDottedPath(statement), !1);
-            throw assertNever(statement);
+            }(statement) : "string" == typeof statement ? normalizeAppendHead(normalizeDottedPath(statement), !1) : void assertNever(statement);
           }
           function normalizeAppendHead(head, trusted) {
-            return head.type === ExpressionKind.GetPath ? {
-              kind: HeadKind.AppendPath,
+            return "GetPath" === head.type ? {
+              kind: "AppendPath",
               path: head,
               trusted: trusted
             } : {
-              kind: HeadKind.AppendExpr,
+              kind: "AppendExpr",
               expr: head,
               trusted: trusted
             };
@@ -12899,13 +12248,13 @@ var define, require;
           function normalizePath(head, tail = []) {
             const pathHead = normalizePathHead(head);
             return isPresentArray(tail) ? {
-              type: ExpressionKind.GetPath,
+              type: "GetPath",
               path: {
                 head: pathHead,
                 tail: tail
               }
             } : {
-              type: ExpressionKind.GetVar,
+              type: "GetVar",
               variable: pathHead
             };
           }
@@ -12921,35 +12270,35 @@ var define, require;
                 mode: "loose"
               };
             return isPresentArray(tail) ? {
-              type: ExpressionKind.GetPath,
+              type: "GetPath",
               path: {
                 head: variable,
                 tail: tail
               }
             } : {
-              type: ExpressionKind.GetVar,
+              type: "GetVar",
               variable: variable
             };
           }
           function normalizePathHead(whole) {
             let kind, name;
             if (/^this(?:\.|$)/u.test(whole)) return {
-              kind: VariableKind.This,
+              kind: "This",
               name: whole,
               mode: "loose"
             };
             switch (whole[0]) {
               case "^":
-                kind = VariableKind.Free, name = whole.slice(1);
+                kind = "Free", name = whole.slice(1);
                 break;
               case "@":
-                kind = VariableKind.Arg, name = whole.slice(1);
+                kind = "Arg", name = whole.slice(1);
                 break;
               case "&":
-                kind = VariableKind.Block, name = whole.slice(1);
+                kind = "Block", name = whole.slice(1);
                 break;
               default:
-                kind = VariableKind.Local, name = whole;
+                kind = "Local", name = whole;
             }
             return {
               kind: kind,
@@ -12966,7 +12315,7 @@ var define, require;
             return 2 === statement.length ? blocks = normalizeBlocks(statement[1]) : 3 === statement.length ? (Array.isArray(statement[1]) ? params = normalizeParams(statement[1]) : ({
               hash: hash,
               blockParams: blockParams
-            } = normalizeBlockHash(statement[1])), blocks = normalizeBlocks(statement[2])) : 4 === statement.length && (params = normalizeParams(statement[1]), ({
+            } = normalizeBlockHash(statement[1])), blocks = normalizeBlocks(statement[2])) : (params = normalizeParams(statement[1]), ({
               hash: hash,
               blockParams: blockParams
             } = normalizeBlockHash(statement[2])), blocks = normalizeBlocks(statement[3])), {
@@ -13007,7 +12356,7 @@ var define, require;
           function normalizeAttrs(attrs) {
             return mapObject(attrs, a => {
               return (attr = a, "splat" === attr ? {
-                expr: HeadKind.Splat,
+                expr: "Splat",
                 trusted: !1
               } : {
                 expr: normalizeExpression(attr),
@@ -13026,135 +12375,121 @@ var define, require;
             const match = /^<([\d\-a-z][\d\-A-Za-z]*)>$/u.exec(input);
             return match?.[1] ?? null;
           }
-          let Builder = function (Builder) {
-              return Builder[Builder.Literal = 0] = "Literal", Builder[Builder.Comment = 1] = "Comment", Builder[Builder.Append = 2] = "Append", Builder[Builder.Modifier = 3] = "Modifier", Builder[Builder.DynamicComponent = 4] = "DynamicComponent", Builder[Builder.Get = 5] = "Get", Builder[Builder.Concat = 6] = "Concat", Builder[Builder.HasBlock = 7] = "HasBlock", Builder[Builder.HasBlockParams = 8] = "HasBlockParams", Builder;
-            }({}),
-            ExpressionKind = function (ExpressionKind) {
-              return ExpressionKind.Literal = "Literal", ExpressionKind.Call = "Call", ExpressionKind.GetPath = "GetPath", ExpressionKind.GetVar = "GetVar", ExpressionKind.Concat = "Concat", ExpressionKind.HasBlock = "HasBlock", ExpressionKind.HasBlockParams = "HasBlockParams", ExpressionKind;
-            }({});
           function normalizeAppendExpression(expression, forceTrusted = !1) {
             if (null == expression) return {
               expr: {
-                type: ExpressionKind.Literal,
+                type: "Literal",
                 value: expression
               },
-              kind: HeadKind.AppendExpr,
+              kind: "AppendExpr",
               trusted: !1
             };
             if (Array.isArray(expression)) switch (expression[0]) {
-              case Builder.Literal:
+              case 0:
                 return {
                   expr: {
-                    type: ExpressionKind.Literal,
+                    type: "Literal",
                     value: expression[1]
                   },
-                  kind: HeadKind.AppendExpr,
+                  kind: "AppendExpr",
                   trusted: !1
                 };
-              case Builder.Get:
+              case 5:
                 return normalizeAppendHead(normalizePath(expression[1], expression[2]), forceTrusted);
-              case Builder.Concat:
+              case 6:
                 return {
                   expr: {
-                    type: ExpressionKind.Concat,
+                    type: "Concat",
                     params: normalizeParams(expression.slice(1))
                   },
-                  kind: HeadKind.AppendExpr,
+                  kind: "AppendExpr",
                   trusted: forceTrusted
                 };
-              case Builder.HasBlock:
+              case 7:
                 return {
                   expr: {
-                    type: ExpressionKind.HasBlock,
+                    type: "HasBlock",
                     name: expression[1]
                   },
-                  kind: HeadKind.AppendExpr,
+                  kind: "AppendExpr",
                   trusted: forceTrusted
                 };
-              case Builder.HasBlockParams:
+              case 8:
                 return {
                   expr: {
-                    type: ExpressionKind.HasBlockParams,
+                    type: "HasBlockParams",
                     name: expression[1]
                   },
-                  kind: HeadKind.AppendExpr,
+                  kind: "AppendExpr",
                   trusted: forceTrusted
                 };
               default:
                 if (isBuilderCallExpression(expression)) return {
                   expr: normalizeCallExpression(expression),
-                  kind: HeadKind.AppendExpr,
+                  kind: "AppendExpr",
                   trusted: forceTrusted
                 };
                 throw new Error(`Unexpected array in expression position (wasn't a tuple expression and ${expression[0]} isn't wrapped in parens, so it isn't a call): ${JSON.stringify(expression)}`);
-              // BuilderCallExpression
-            } else {
-              if ("object" == typeof expression) throw assertNever(expression);
-              switch (typeof expression) {
-                case "string":
-                  return normalizeAppendHead(normalizeDottedPath(expression), forceTrusted);
-                case "boolean":
-                case "number":
-                  return {
-                    expr: {
-                      type: ExpressionKind.Literal,
-                      value: expression
-                    },
-                    kind: HeadKind.AppendExpr,
-                    trusted: !0
-                  };
-                default:
-                  throw assertNever(expression);
-              }
-            }
+            } else if ("object" != typeof expression) switch (typeof expression) {
+              case "string":
+                return normalizeAppendHead(normalizeDottedPath(expression), forceTrusted);
+              case "boolean":
+              case "number":
+                return {
+                  expr: {
+                    type: "Literal",
+                    value: expression
+                  },
+                  kind: "AppendExpr",
+                  trusted: !0
+                };
+              default:
+                assertNever(expression);
+            } else assertNever(expression);
           }
           function normalizeExpression(expression) {
             if (null == expression) return {
-              type: ExpressionKind.Literal,
+              type: "Literal",
               value: expression
             };
             if (Array.isArray(expression)) switch (expression[0]) {
-              case Builder.Literal:
+              case 0:
                 return {
-                  type: ExpressionKind.Literal,
+                  type: "Literal",
                   value: expression[1]
                 };
-              case Builder.Get:
+              case 5:
                 return normalizePath(expression[1], expression[2]);
-              case Builder.Concat:
+              case 6:
                 return {
-                  type: ExpressionKind.Concat,
+                  type: "Concat",
                   params: normalizeParams(expression.slice(1))
                 };
-              case Builder.HasBlock:
+              case 7:
                 return {
-                  type: ExpressionKind.HasBlock,
+                  type: "HasBlock",
                   name: expression[1]
                 };
-              case Builder.HasBlockParams:
+              case 8:
                 return {
-                  type: ExpressionKind.HasBlockParams,
+                  type: "HasBlockParams",
                   name: expression[1]
                 };
               default:
                 if (isBuilderCallExpression(expression)) return normalizeCallExpression(expression);
                 throw new Error(`Unexpected array in expression position (wasn't a tuple expression and ${expression[0]} isn't wrapped in parens, so it isn't a call): ${JSON.stringify(expression)}`);
-              // BuilderCallExpression
-            } else {
-              if ("object" == typeof expression) throw assertNever(expression);
-              switch (typeof expression) {
-                case "string":
-                  return normalizeDottedPath(expression);
-                case "boolean":
-                case "number":
-                  return {
-                    type: ExpressionKind.Literal,
-                    value: expression
-                  };
-                default:
-                  throw assertNever(expression);
-              }
-            }
+            } else if ("object" != typeof expression) switch (typeof expression) {
+              case "string":
+                return normalizeDottedPath(expression);
+              case "boolean":
+              case "number":
+                return {
+                  type: "Literal",
+                  value: expression
+                };
+              default:
+                assertNever(expression);
+            } else assertNever(expression);
           }
           function isBuilderCallExpression(value) {
             return "string" == typeof value[0] && "(" === value[0][0];
@@ -13169,26 +12504,26 @@ var define, require;
             switch (expr.length) {
               case 1:
                 return {
-                  type: ExpressionKind.Call,
+                  type: "Call",
                   head: normalizeCallHead(expr[0]),
                   params: null,
                   hash: null
                 };
               case 2:
                 return Array.isArray(expr[1]) ? {
-                  type: ExpressionKind.Call,
+                  type: "Call",
                   head: normalizeCallHead(expr[0]),
                   params: normalizeParams(expr[1]),
                   hash: null
                 } : {
-                  type: ExpressionKind.Call,
+                  type: "Call",
                   head: normalizeCallHead(expr[0]),
                   params: null,
                   hash: normalizeHash(expr[1])
                 };
               case 3:
                 return {
-                  type: ExpressionKind.Call,
+                  type: "Call",
                   head: normalizeCallHead(expr[0]),
                   params: normalizeParams(expr[1]),
                   hash: normalizeHash(expr[2])
@@ -13196,9 +12531,6 @@ var define, require;
             }
           }
           class ProgramSymbols {
-            _freeVariables = [];
-            _symbols = ["this"];
-            top = this;
             toSymbols() {
               return this._symbols.slice(1);
             }
@@ -13230,11 +12562,13 @@ var define, require;
             child(locals) {
               return new LocalSymbols(this, locals);
             }
+            constructor() {
+              this._freeVariables = [], this._symbols = ["this"], this.top = this;
+            }
           }
           class LocalSymbols {
-            locals = dict();
             constructor(parent, locals) {
-              this.parent = parent;
+              this.parent = parent, this.locals = dict();
               for (let local of locals) this.locals[local] = parent.top.symbol(local);
             }
             get paramSymbols() {
@@ -13282,11 +12616,11 @@ var define, require;
           }
           function buildStatement(normalized, symbols = new ProgramSymbols()) {
             switch (normalized.kind) {
-              case HeadKind.AppendPath:
+              case "AppendPath":
                 return [[normalized.trusted ? opcodes.TrustingAppend : opcodes.Append, buildGetPath(normalized.path, symbols)]];
-              case HeadKind.AppendExpr:
+              case "AppendExpr":
                 return [[normalized.trusted ? opcodes.TrustingAppend : opcodes.Append, buildExpression(normalized.expr, normalized.trusted ? "TrustedAppend" : "Append", symbols)]];
-              case HeadKind.Call:
+              case "Call":
                 {
                   let {
                       head: path,
@@ -13299,11 +12633,11 @@ var define, require;
                     builtExpr = buildCallHead(path, trusted ? resolution.ResolveAsHelperHead : resolution.ResolveAsComponentOrHelperHead, symbols);
                   return [[trusted ? opcodes.TrustingAppend : opcodes.Append, [opcodes.Call, builtExpr, builtParams, builtHash]]];
                 }
-              case HeadKind.Literal:
+              case "Literal":
                 return [[opcodes.Append, normalized.value]];
-              case HeadKind.Comment:
+              case "Comment":
                 return [[opcodes.Comment, normalized.value]];
-              case HeadKind.Block:
+              case "Block":
                 {
                   let blocks = function (blocks, blockParams, parent) {
                       let keys = [],
@@ -13319,9 +12653,9 @@ var define, require;
                     path = buildCallHead(normalized.head, resolution.ResolveAsComponentHead, symbols);
                   return [[opcodes.Block, path, params, hash, blocks]];
                 }
-              case HeadKind.Keyword:
+              case "Keyword":
                 return [buildKeyword(normalized, symbols)];
-              case HeadKind.Element:
+              case "Element":
                 return function ({
                   name: name,
                   attrs: attrs,
@@ -13330,13 +12664,12 @@ var define, require;
                   let out = [hasSplat(attrs) ? [opcodes.OpenElementWithSplat, name] : [opcodes.OpenElement, name]];
                   if (attrs) {
                     let {
-                      params: params,
-                      args: args
+                      params: params
                     } = function (attrs, symbols) {
                       let params = [],
                         keys = [],
                         values = [];
-                      for (const [key, value] of Object.entries(attrs)) value === HeadKind.Splat ? params.push([opcodes.AttrSplat, symbols.block("&attrs")]) : "@" === key[0] ? (keys.push(key), values.push(buildExpression(value, "Strict", symbols))) : params.push(...buildAttributeValue(key, value,
+                      for (const [key, value] of Object.entries(attrs)) "Splat" === value ? params.push([opcodes.AttrSplat, symbols.block("&attrs")]) : "@" === key[0] ? (keys.push(key), values.push(buildExpression(value, "Strict", symbols))) : params.push(...buildAttributeValue(key, value,
                       // TODO: extract namespace from key
                       extractNamespace(key), symbols));
                       return {
@@ -13344,26 +12677,27 @@ var define, require;
                         args: isPresentArray(keys) && isPresentArray(values) ? [keys, values] : null
                       };
                     }(attrs, symbols);
-                    out.push(...params), debugAssert(null === args, "Can't pass args to a simple element");
+                    out.push(...params);
                   }
-                  if (out.push([opcodes.FlushElement]), Array.isArray(block)) block.forEach(s => out.push(...buildStatement(s, symbols)));else if (null !== block) throw assertNever(block);
-                  return out.push([opcodes.CloseElement]), out;
+                  return out.push([opcodes.FlushElement]), Array.isArray(block) && block.forEach(s => out.push(...buildStatement(s, symbols))), out.push([opcodes.CloseElement]), out;
                 }(normalized, symbols);
-              case HeadKind.Modifier:
+              case "Modifier":
                 throw unimpl("modifier");
-              case HeadKind.DynamicComponent:
+              case "DynamicComponent":
                 throw unimpl("dynamic component");
               default:
-                throw assertNever(normalized);
+                assertNever(normalized);
             }
           }
           function s(arr, ...interpolated) {
-            let result = arr.reduce((result, string, i) => result + `${string}${interpolated[i] ? String(interpolated[i]) : ""}`, "");
-            return [Builder.Literal, result];
+            return [0, arr.reduce(
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+            (result, string, i) => result + `${string}${interpolated[i] ? String(interpolated[i]) : ""}`, "")];
           }
           function c(arr, ...interpolated) {
-            let result = arr.reduce((result, string, i) => result + `${string}${interpolated[i] ? String(interpolated[i]) : ""}`, "");
-            return [Builder.Comment, result];
+            return [1, arr.reduce(
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+            (result, string, i) => result + `${string}${interpolated[i] ? String(interpolated[i]) : ""}`, "")];
           }
           function unicode(charCode) {
             return String.fromCharCode(parseInt(charCode, 16));
@@ -13379,21 +12713,21 @@ var define, require;
               inverse = normalized.blocks.else ? buildBlock(normalized.blocks.else, symbols, []) : null;
             switch (name) {
               case "let":
-                return [opcodes.Let, expect(params, "let requires params"), block];
+                return [opcodes.Let, params, block];
               case "if":
-                return [opcodes.If, expect(params, "if requires params")[0], block, inverse];
+                return [opcodes.If, params[0], block, inverse];
               case "each":
                 {
                   let keyExpr = normalized.hash ? normalized.hash.key : null,
                     key = keyExpr ? buildExpression(keyExpr, "Strict", symbols) : null;
-                  return [opcodes.Each, expect(params, "if requires params")[0], key, block, inverse];
+                  return [opcodes.Each, params[0], key, block, inverse];
                 }
               default:
                 throw new Error("unimplemented keyword");
             }
           }
           function hasSplat(attrs) {
-            return null !== attrs && Object.keys(attrs).some(a => attrs[a] === HeadKind.Splat);
+            return null !== attrs && Object.keys(attrs).some(a => "Splat" === attrs[a]);
           }
           function extractNamespace(name) {
             if ("xmlns" === name) return NS_XMLNS;
@@ -13401,16 +12735,16 @@ var define, require;
             if (null === match) return null;
             switch (match[1]) {
               case "xlink":
-                return NS_XLINK;
+                return "http://www.w3.org/1999/xlink";
               case "xml":
-                return NS_XML;
+                return "http://www.w3.org/XML/1998/namespace";
               case "xmlns":
                 return NS_XMLNS;
             }
             return null;
           }
           function buildAttributeValue(name, value, namespace, symbols) {
-            if (value.type === ExpressionKind.Literal) {
+            if ("Literal" === value.type) {
               let val = value.value;
               if (!1 === val) return [];
               if (!0 === val) return [[opcodes.StaticAttr, name, "", namespace ?? void 0]];
@@ -13433,39 +12767,37 @@ var define, require;
           }
           function buildExpression(expr, context, symbols) {
             switch (expr.type) {
-              case ExpressionKind.GetPath:
+              case "GetPath":
                 return buildGetPath(expr, symbols);
-              case ExpressionKind.GetVar:
+              case "GetVar":
                 return buildVar(expr.variable, varContext(context, !0), symbols);
-              case ExpressionKind.Concat:
+              case "Concat":
                 return [opcodes.Concat, buildConcat(expr.params, symbols)];
-              case ExpressionKind.Call:
+              case "Call":
                 {
                   let builtParams = buildParams(expr.params, symbols),
                     builtHash = buildHash(expr.hash, symbols),
                     builtExpr = buildCallHead(expr.head, "Strict" === context ? "SubExpression" : varContext(context, !1), symbols);
                   return [opcodes.Call, builtExpr, builtParams, builtHash];
                 }
-              case ExpressionKind.HasBlock:
+              case "HasBlock":
                 return [opcodes.HasBlock, buildVar({
-                  kind: VariableKind.Block,
-                  name: expr.name,
-                  mode: "loose"
+                  kind: "Block",
+                  name: expr.name
                 }, resolution.Strict, symbols)];
-              case ExpressionKind.HasBlockParams:
+              case "HasBlockParams":
                 return [opcodes.HasBlockParams, buildVar({
-                  kind: VariableKind.Block,
-                  name: expr.name,
-                  mode: "loose"
+                  kind: "Block",
+                  name: expr.name
                 }, resolution.Strict, symbols)];
-              case ExpressionKind.Literal:
+              case "Literal":
                 return void 0 === expr.value ? [opcodes.Undefined] : expr.value;
               default:
                 assertNever(expr);
             }
           }
           function buildCallHead(callHead, context, symbols) {
-            return callHead.type === ExpressionKind.GetVar ? buildVar(callHead.variable, context, symbols) : buildGetPath(callHead, symbols);
+            return "GetVar" === callHead.type ? buildVar(callHead.variable, context, symbols) : buildGetPath(callHead, symbols);
           }
           function buildGetPath(head, symbols) {
             return buildVar(head.path.head, resolution.Strict, symbols, head.path.tail);
@@ -13473,7 +12805,7 @@ var define, require;
           function buildVar(head, context, symbols, path) {
             let sym,
               op = opcodes.GetSymbol;
-            return head.kind === VariableKind.Free ? (op = "Strict" === context ? opcodes.GetStrictKeyword : "AppendBare" === context || "AppendInvoke" === context ? opcodes.GetFreeAsComponentOrHelperHead : "TrustedAppendBare" === context || "TrustedAppendInvoke" === context || "AttrValueBare" === context || "AttrValueInvoke" === context || "SubExpression" === context ? opcodes.GetFreeAsHelperHead : function (context) {
+            return "Free" === head.kind ? (op = "Strict" === context ? opcodes.GetStrictKeyword : "AppendBare" === context || "AppendInvoke" === context ? opcodes.GetFreeAsComponentOrHelperHead : "TrustedAppendBare" === context || "TrustedAppendInvoke" === context || "AttrValueBare" === context || "AttrValueInvoke" === context || "SubExpression" === context ? opcodes.GetFreeAsHelperHead : function (context) {
               switch (context) {
                 case resolution.Strict:
                   return opcodes.GetStrictKeyword;
@@ -13486,22 +12818,22 @@ var define, require;
                 case resolution.ResolveAsComponentHead:
                   return opcodes.GetFreeAsComponentHead;
                 default:
-                  return exhausted(context);
+                  return;
               }
             }(context), sym = symbols.freeVar(head.name)) : (op = opcodes.GetSymbol, sym = function (kind, symbols, name) {
               switch (kind) {
-                case VariableKind.Arg:
+                case "Arg":
                   return symbols.arg(name);
-                case VariableKind.Block:
+                case "Block":
                   return symbols.block(name);
-                case VariableKind.Local:
+                case "Local":
                   return symbols.local(name);
-                case VariableKind.This:
+                case "This":
                   return symbols.this();
                 default:
-                  return exhausted(kind);
+                  return;
               }
-            }(head.kind, symbols, head.name)), void 0 === path || 0 === path.length ? [op, sym] : (debugAssert(op !== opcodes.GetStrictKeyword, "[BUG] keyword with a path"), [op, sym, path]);
+            }(head.kind, symbols, head.name)), void 0 === path || 0 === path.length ? [op, sym] : (opcodes.GetStrictKeyword, [op, sym, path]);
           }
           function buildParams(exprs, symbols) {
             return null !== exprs && isPresentArray(exprs) ? exprs.map(e => buildExpression(e, "Strict", symbols)) : null;
@@ -13582,7 +12914,6 @@ var define, require;
             }
           }
           class EmptyList {
-            list = [];
             map(_callback) {
               return new EmptyList();
             }
@@ -13600,6 +12931,9 @@ var define, require;
             }) {
               return ifEmpty();
             }
+            constructor() {
+              this.list = [];
+            }
           }
 
           // export type OptionalList<T> = PresentList<T> | EmptyList<T>;
@@ -13618,10 +12952,8 @@ var define, require;
           }
           const Result = ResultImpl;
           class OkImpl extends ResultImpl {
-            isOk = !0;
-            isErr = !1;
             constructor(value) {
-              super(), this.value = value;
+              super(), this.value = value, this.isOk = !0, this.isErr = !1;
             }
             expect(_message) {
               return this.value;
@@ -13643,10 +12975,8 @@ var define, require;
             }
           }
           class ErrImpl extends ResultImpl {
-            isOk = !1;
-            isErr = !0;
             constructor(reason) {
-              super(), this.reason = reason;
+              super(), this.reason = reason, this.isOk = !1, this.isErr = !0;
             }
             expect(message) {
               throw new Error(message || "expected an Ok, got Err");
@@ -13692,9 +13022,9 @@ var define, require;
             }
           }
           function convertPathToCallIfKeyword(path) {
-            return "Path" === path.type && "Free" === path.ref.type && path.ref.name in KEYWORDS_TYPES ? new api$1.CallExpression({
+            return "Path" === path.type && "Free" === path.ref.type && path.ref.name in KEYWORDS_TYPES ? new api.CallExpression({
               callee: path,
-              args: api$1.Args.empty(path.loc),
+              args: api.Args.empty(path.loc),
               loc: path.loc
             }) : path;
           }
@@ -13731,7 +13061,7 @@ var define, require;
                   tail: tail
                 } = path;
               if (isPresentArray(tail)) {
-                let tailLoc = tail[0].loc.extend(getLast(tail).loc);
+                let tailLoc = tail[0].loc.extend((list = tail, 0 === list.length ? void 0 : list[list.length - 1]).loc);
                 return Ok(new PathExpression({
                   loc: path.loc,
                   head: ref,
@@ -13742,6 +13072,7 @@ var define, require;
                 }));
               }
               return Ok(ref);
+              var list;
             }
             VariableReference(ref) {
               return ref;
@@ -13800,7 +13131,6 @@ var define, require;
             }
           }();
           class KeywordImpl {
-            types;
             constructor(keyword, type, delegate) {
               this.keyword = keyword, this.delegate = delegate;
               let nodes = new Set();
@@ -13829,11 +13159,6 @@ var define, require;
             Append: ["AppendContent"],
             Modifier: ["ElementModifier"]
           };
-
-          /**
-           * A "generic" keyword is something like `has-block`, which makes sense in the context
-           * of sub-expression or append
-           */
           function getCalleeExpression(node) {
             switch (node.type) {
               // This covers the inside of attributes and expressions, as well as the callee
@@ -13851,15 +13176,11 @@ var define, require;
             }
           }
           class Keywords {
-            _keywords = [];
-            _type;
             constructor(type) {
-              this._type = type;
+              this._keywords = [], this._type = type;
             }
             kw(name, delegate) {
-              return this._keywords.push(function (keyword, type, delegate) {
-                return new KeywordImpl(keyword, type, delegate);
-              }(name, this._type, delegate)), this;
+              return this._keywords.push(new KeywordImpl(name, this._type, delegate)), this;
             }
             translate(node, state) {
               for (let keyword of this._keywords) {
@@ -13885,7 +13206,7 @@ var define, require;
             case "Modifier":
               return `- As a modifier, as in: <div {{${name}}}></div>`;
             default:
-              return exhausted(type);
+              return;
           }
         }).join("\n\n");
       }
@@ -14002,14 +13323,14 @@ var define, require;
             };
           }
           const CurriedTypeToReadableType = {
-            [CurriedTypes.Component]: "component",
-            [CurriedTypes.Helper]: "helper",
-            [CurriedTypes.Modifier]: "modifier"
+            [CURRIED_COMPONENT]: "component",
+            [CURRIED_HELPER]: "helper",
+            [CURRIED_MODIFIER]: "modifier"
           };
           function assertCurryKeyword(curriedType) {
             return (node, state) => {
               let readableType = CurriedTypeToReadableType[curriedType],
-                stringsAllowed = curriedType === CurriedTypes.Component,
+                stringsAllowed = 0 === curriedType,
                 {
                   args: args
                 } = node,
@@ -14019,8 +13340,8 @@ var define, require;
                 if (stringsAllowed && state.isStrict) return Err(generateSyntaxError(`(${readableType}) cannot resolve string values in strict mode templates`, node.loc));
                 if (!stringsAllowed) return Err(generateSyntaxError(`(${readableType}) cannot resolve string values, you must pass a ${readableType} definition directly`, node.loc));
               }
-              return args = new api$1.Args({
-                positional: new api$1.PositionalArguments({
+              return args = new api.Args({
+                positional: new api.PositionalArguments({
                   exprs: args.positional.exprs.slice(1),
                   loc: args.positional.loc
                 }),
@@ -14084,7 +13405,7 @@ var define, require;
               if (!positionals || positionals.isEmpty()) return Ok(SourceSlice.synthetic("default"));
               if (1 === positionals.exprs.length) {
                 let positional = positionals.exprs[0];
-                return api$1.isLiteral(positional, "string") ? Ok(positional.toSlice()) : Err(generateSyntaxError(`(${type}) can only receive a string literal as its first argument`, call.loc));
+                return api.isLiteral(positional, "string") ? Ok(positional.toSlice()) : Err(generateSyntaxError(`(${type}) can only receive a string literal as its first argument`, call.loc));
               }
               return Err(generateSyntaxError(`(${type}) only takes a single positional argument`, call.loc));
             };
@@ -14122,7 +13443,7 @@ var define, require;
               if (!positional || !condition) return Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Did not receive any parameters`, originalNode.loc));
               let truthy = positional.nth(1),
                 falsy = positional.nth(2);
-              return null === truthy ? Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Received only one parameter, the condition`, originalNode.loc)) : positional.size > 3 ? Err(generateSyntaxError(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${inverted ? "false" : "true"}, and 3. the value to return if the condition is ${inverted ? "true" : "false"}. Received ${positional?.size ?? 0} parameters`, originalNode.loc)) : Ok({
+              return null === truthy ? Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Received only one parameter, the condition`, originalNode.loc)) : positional.size > 3 ? Err(generateSyntaxError(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${inverted ? "false" : "true"}, and 3. the value to return if the condition is ${inverted ? "true" : "false"}. Received ${positional.size} parameters`, originalNode.loc)) : Ok({
                 condition: condition,
                 truthy: truthy,
                 falsy: falsy
@@ -14167,7 +13488,7 @@ var define, require;
                     positional: positional
                   }
                 } = node;
-                return named && !named.isEmpty() ? Err(generateSyntaxError("(log) does not take any named arguments", node.loc)) : Ok(positional);
+                return named.isEmpty() ? Ok(positional) : Err(generateSyntaxError("(log) does not take any named arguments", node.loc));
               },
               translate: function ({
                 node: node,
@@ -14185,12 +13506,12 @@ var define, require;
                   args: args
                 } = node;
                 if (args.named.isEmpty()) return Ok({
-                  target: api$2.SourceSpan.synthetic("default").toSlice(),
+                  target: api$1.SourceSpan.synthetic("default").toSlice(),
                   positional: args.positional
                 });
                 {
                   let target = args.named.get("to");
-                  return args.named.size > 1 || null === target ? Err(generateSyntaxError("yield only takes a single named argument: 'to'", args.named.loc)) : api$1.isLiteral(target, "string") ? Ok({
+                  return args.named.size > 1 || null === target ? Err(generateSyntaxError("yield only takes a single named argument: 'to'", args.named.loc)) : api.isLiteral(target, "string") ? Ok({
                     target: target.toSlice(),
                     positional: args.positional
                   }) : Err(generateSyntaxError("you can only yield to a literal string value", target.loc));
@@ -14223,12 +13544,12 @@ var define, require;
                 state: {
                   scope: scope
                 }
-              }) => (scope.setHasDebugger(), Ok(new Debugger({
+              }) => Ok(new Debugger({
                 loc: node.loc,
                 scope: scope
-              })))
+              }))
             }).kw("component", {
-              assert: assertCurryKeyword(CurriedTypes.Component),
+              assert: assertCurryKeyword(0),
               translate({
                 node: node,
                 state: state
@@ -14246,7 +13567,7 @@ var define, require;
                 }));
               }
             }).kw("helper", {
-              assert: assertCurryKeyword(CurriedTypes.Helper),
+              assert: assertCurryKeyword(1),
               translate({
                 node: node,
                 state: state
@@ -14458,7 +13779,7 @@ var define, require;
                 }));
               }
             }).kw("component", {
-              assert: assertCurryKeyword(CurriedTypes.Component),
+              assert: assertCurryKeyword(0),
               translate({
                 node: node,
                 state: state
@@ -14477,7 +13798,7 @@ var define, require;
                 }));
               }
             }),
-            CALL_KEYWORDS = keywords("Call").kw("has-block", hasBlockKeyword("has-block")).kw("has-block-params", hasBlockKeyword("has-block-params")).kw("-get-dynamic-var", getDynamicVarKeyword).kw("log", logKeyword).kw("if", ifUnlessInlineKeyword("if")).kw("unless", ifUnlessInlineKeyword("unless")).kw("component", curryKeyword(CurriedTypes.Component)).kw("helper", curryKeyword(CurriedTypes.Helper)).kw("modifier", curryKeyword(CurriedTypes.Modifier)),
+            CALL_KEYWORDS = keywords("Call").kw("has-block", hasBlockKeyword("has-block")).kw("has-block-params", hasBlockKeyword("has-block-params")).kw("-get-dynamic-var", getDynamicVarKeyword).kw("log", logKeyword).kw("if", ifUnlessInlineKeyword("if")).kw("unless", ifUnlessInlineKeyword("unless")).kw("component", curryKeyword(0)).kw("helper", curryKeyword(1)).kw("modifier", curryKeyword(2)),
             MODIFIER_KEYWORDS = keywords("Modifier"),
             XLINK = "http://www.w3.org/1999/xlink",
             XML = "http://www.w3.org/XML/1998/namespace",
@@ -14523,7 +13844,6 @@ var define, require;
             return "string" == typeof attrName ? attrName : INFLATE_ATTR_TABLE[attrName];
           }
           class ClassifiedElement {
-            delegate;
             constructor(element, delegate, state) {
               this.element = element, this.state = state, this.delegate = delegate;
             }
@@ -14535,7 +13855,7 @@ var define, require;
                 rawValue = attr.value,
                 namespace = (attrName = name.chars, WHITELIST[attrName] || void 0);
               var attrName;
-              return api$1.isLiteral(rawValue, "string") ? Ok(new StaticAttr({
+              return api.isLiteral(rawValue, "string") ? Ok(new StaticAttr({
                 loc: attr.loc,
                 name: name,
                 value: rawValue.toSlice(),
@@ -14581,7 +13901,7 @@ var define, require;
               return typeAttr && attrs.add(this.attr(typeAttr)), Result.all(args.toArray(), attrs.toArray()).mapOk(([args, attrs]) => ({
                 attrs: attrs,
                 args: new NamedArguments({
-                  loc: maybeLoc(args, api$2.SourceSpan.NON_EXISTENT),
+                  loc: maybeLoc(args, api$1.SourceSpan.NON_EXISTENT),
                   entries: OptionalList(args)
                 })
               }));
@@ -14598,7 +13918,7 @@ var define, require;
                 return {
                   args: args,
                   params: new ElementParameters({
-                    loc: maybeLoc(elementParams, api$2.SourceSpan.NON_EXISTENT),
+                    loc: maybeLoc(elementParams, api$1.SourceSpan.NON_EXISTENT),
                     body: OptionalList(elementParams)
                   })
                 };
@@ -14606,9 +13926,8 @@ var define, require;
             }
           }
           class ClassifiedComponent {
-            dynamicFeatures = !0;
             constructor(tag, element) {
-              this.tag = tag, this.element = element;
+              this.tag = tag, this.element = element, this.dynamicFeatures = !0;
             }
             arg(attr, {
               state: state
@@ -14642,9 +13961,8 @@ var define, require;
           }
           class ClassifiedSimpleElement {
             constructor(tag, element, dynamicFeatures) {
-              this.tag = tag, this.element = element, this.dynamicFeatures = dynamicFeatures;
+              this.tag = tag, this.element = element, this.dynamicFeatures = dynamicFeatures, this.isComponent = !1;
             }
-            isComponent = !1;
             arg(attr) {
               return Err(generateSyntaxError(`${attr.name.chars} is not a valid attribute name. @arguments are only allowed on components, but the tag for this element (\`${this.tag.chars}\`) is a regular, non-component HTML element.`, attr.loc));
             }
@@ -14738,7 +14056,7 @@ var define, require;
             TextNode(text) {
               return new AppendTextNode({
                 loc: text.loc,
-                text: new api$1.LiteralExpression({
+                text: new api.LiteralExpression({
                   loc: text.loc,
                   value: text.chars
                 })
@@ -14756,10 +14074,8 @@ var define, require;
            * This is the mutable state for this compiler pass.
            */
           class NormalizationState {
-            _currentScope;
-            _cursorCount = 0;
             constructor(block, isStrict) {
-              this.isStrict = isStrict, this._currentScope = block;
+              this.isStrict = isStrict, this._cursorCount = 0, this._currentScope = block;
             }
             generateUniqueCursor() {
               return `%cursor:${this._cursorCount++}%`;
@@ -14777,9 +14093,8 @@ var define, require;
               }
             }
           }
-          var ResolutionType = function (ResolutionType) {
-            return ResolutionType.Value = "value", ResolutionType.Component = "component", ResolutionType.Helper = "helper", ResolutionType.Modifier = "modifier", ResolutionType.ComponentOrHelper = "component or helper", ResolutionType;
-          }(ResolutionType || {});
+
+          /// ResolutionType ///
           class StrictModeValidationPass {
             // This is done at the end of all the keyword normalizations
             // At this point any free variables that isn't a valid keyword
@@ -14867,7 +14182,7 @@ var define, require;
                 case "InterpolateExpression":
                   return this.InterpolateExpression(expression, span, resolution);
                 case "CallExpression":
-                  return this.CallExpression(expression, span, resolution ?? ResolutionType.Helper);
+                  return this.CallExpression(expression, span, resolution ?? "helper");
                 case "Not":
                   return this.Expression(expression.value, span, resolution);
                 case "IfInline":
@@ -14887,6 +14202,7 @@ var define, require;
               // For cases like {{yield foo}}, when there is only a single argument, it
               // makes for a slightly better error to report that entire span. However,
               // when there are more than one, we need to be specific.
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme PresentArray
               return result = 1 === expressions.length ? this.Expression(expressions[0], span) : this.Expressions(expressions), result;
             }
             NamedArguments({
@@ -14897,7 +14213,7 @@ var define, require;
               return result;
             }
             NamedArgument(arg) {
-              return "CallExpression" === arg.value.type ? this.Expression(arg.value, arg, ResolutionType.Helper) : this.Expression(arg.value, arg);
+              return "CallExpression" === arg.value.type ? this.Expression(arg.value, arg, "helper") : this.Expression(arg.value, arg);
             }
             ElementParameters({
               body: body
@@ -14918,10 +14234,10 @@ var define, require;
               }
             }
             DynamicAttr(attr) {
-              return "CallExpression" === attr.value.type ? this.Expression(attr.value, attr, ResolutionType.Helper) : this.Expression(attr.value, attr);
+              return "CallExpression" === attr.value.type ? this.Expression(attr.value, attr, "helper") : this.Expression(attr.value, attr);
             }
             Modifier(modifier) {
-              return this.Expression(modifier.callee, modifier, ResolutionType.Modifier).andThen(() => this.Args(modifier.args));
+              return this.Expression(modifier.callee, modifier, "modifier").andThen(() => this.Args(modifier.args));
             }
             InElement(inElement) {
               return this.Expression(inElement.destination).andThen(() => this.Expression(inElement.insertBefore)).andThen(() => this.NamedBlock(inElement.block));
@@ -14933,16 +14249,16 @@ var define, require;
               return this.Expression(statement.html, statement);
             }
             AppendTextNode(statement) {
-              return "CallExpression" === statement.text.type ? this.Expression(statement.text, statement, ResolutionType.ComponentOrHelper) : this.Expression(statement.text, statement);
+              return "CallExpression" === statement.text.type ? this.Expression(statement.text, statement, "component or helper") : this.Expression(statement.text, statement);
             }
             Component(statement) {
-              return this.Expression(statement.tag, statement, ResolutionType.Component).andThen(() => this.ElementParameters(statement.params)).andThen(() => this.NamedArguments(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
+              return this.Expression(statement.tag, statement, "component").andThen(() => this.ElementParameters(statement.params)).andThen(() => this.NamedArguments(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
             }
             SimpleElement(statement) {
               return this.ElementParameters(statement.params).andThen(() => this.Statements(statement.body));
             }
             InvokeBlock(statement) {
-              return this.Expression(statement.head, statement.head, ResolutionType.Component).andThen(() => this.Args(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
+              return this.Expression(statement.head, statement.head, "component").andThen(() => this.Args(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
             }
             If(statement) {
               return this.Expression(statement.condition, statement).andThen(() => this.NamedBlock(statement.block)).andThen(() => statement.inverse ? this.NamedBlock(statement.inverse) : Ok(null));
@@ -14957,7 +14273,7 @@ var define, require;
               return this.NamedArguments(statement.named).andThen(() => this.NamedBlock(statement.block));
             }
             InvokeComponent(statement) {
-              return this.Expression(statement.definition, statement, ResolutionType.Component).andThen(() => this.Args(statement.args)).andThen(() => statement.blocks ? this.NamedBlocks(statement.blocks) : Ok(null));
+              return this.Expression(statement.definition, statement, "component").andThen(() => this.Args(statement.args)).andThen(() => statement.blocks ? this.NamedBlocks(statement.blocks) : Ok(null));
             }
             InterpolateExpression(expression, span, resolution) {
               let expressions = expression.parts.toArray();
@@ -14971,12 +14287,12 @@ var define, require;
             }
             Curry(expression) {
               let resolution;
-              return resolution = expression.curriedType === CurriedTypes.Component ? ResolutionType.Component : expression.curriedType === CurriedTypes.Helper ? ResolutionType.Helper : ResolutionType.Modifier, this.Expression(expression.definition, expression, resolution).andThen(() => this.Args(expression.args));
+              return resolution = 0 === expression.curriedType ? "component" : 1 === expression.curriedType ? "helper" : "modifier", this.Expression(expression.definition, expression, resolution).andThen(() => this.Args(expression.args));
             }
             Log(expression) {
               return this.Positional(expression.positional, expression);
             }
-            errorFor(name, span, type = ResolutionType.Value) {
+            errorFor(name, span, type = "value") {
               return Err(generateSyntaxError(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${name}`, loc(span)));
             }
           }
@@ -15020,9 +14336,7 @@ var define, require;
            * ```
            */
           class WireFormatDebugger {
-            upvars;
-            symbols;
-            constructor([_statements, symbols, _hasEval, upvars]) {
+            constructor([_statements, symbols, upvars]) {
               this.upvars = upvars, this.symbols = symbols;
             }
             format(program) {
@@ -15125,14 +14439,12 @@ var define, require;
             }
             formatCurryType(value) {
               switch (value) {
-                case CurriedTypes.Component:
+                case 0:
                   return "component";
-                case CurriedTypes.Helper:
+                case 1:
                   return "helper";
-                case CurriedTypes.Modifier:
+                case 2:
                   return "modifier";
-                default:
-                  throw exhausted(value);
               }
             }
             formatElementParams(opcodes) {
@@ -15232,7 +14544,7 @@ var define, require;
               tail: tail
             }) {
               let getOp = EXPR.expr(head);
-              return debugAssert(getOp[0] !== opcodes.GetStrictKeyword, "[BUG] keyword in a PathExpression"), [...getOp, EXPR.Tail(tail)];
+              return getOp[0], opcodes.GetStrictKeyword, [...getOp, EXPR.Tail(tail)];
             }
             InterpolateExpression({
               parts: parts
@@ -15278,7 +14590,7 @@ var define, require;
                   let [name, value] = EXPR.NamedArgument(pair);
                   names.push(name), values.push(value);
                 }
-                return assertPresentArray(names), assertPresentArray(values), [names, values];
+                return [names, values];
               }
               return null;
             }
@@ -15319,7 +14631,7 @@ var define, require;
               let out = [];
               for (let statement of statements) {
                 let result = CONTENT.content(statement);
-                result && result instanceof WireStatements ? out.push(...result.toArray()) : out.push(result);
+                result instanceof WireStatements ? out.push(...result.toArray()) : out.push(result);
               }
               return out;
             }
@@ -15329,7 +14641,7 @@ var define, require;
             visitContent(stmt) {
               switch (stmt.type) {
                 case "Debugger":
-                  return [opcodes.Debugger, stmt.scope.getDebugInfo()];
+                  return [opcodes.Debugger, ...stmt.scope.getDebugInfo(), {}];
                 case "AppendComment":
                   return this.AppendComment(stmt);
                 case "AppendTextNode":
@@ -15357,7 +14669,7 @@ var define, require;
                 case "InvokeComponent":
                   return this.InvokeComponent(stmt);
                 default:
-                  return exhausted(stmt);
+                  return;
               }
             }
             Yield({
@@ -15549,7 +14861,7 @@ var define, require;
            * @return {string} a template javascript string
            */
           function precompileJSON(string, options = defaultOptions) {
-            const source = new api$2.Source(string ?? "", options.meta?.moduleName),
+            const source = new api$1.Source(string ?? "", options.meta?.moduleName),
               [ast, locals] = normalize(source, {
                 lexicalScope: () => !1,
                 ...options
@@ -15566,7 +14878,7 @@ var define, require;
               }(0, ast, options.strictMode ?? !1).mapOk(pass2In => function (template) {
                 let statements = CONTENT.list(template.body),
                   scope = template.scope;
-                return [statements, scope.symbols, scope.hasEval, scope.upvars];
+                return [statements, scope.symbols, scope.upvars];
               }(pass2In));
             if (block.isOk) return [block.value, locals];
             throw block.reason;
@@ -15589,8 +14901,9 @@ var define, require;
            * @return {string} a template javascript string
            */
           function precompile$1(source, options = defaultOptions) {
-            const [block, usedLocals] = precompileJSON(source, options),
-              moduleName = options.meta?.moduleName,
+            const [block, usedLocals] = precompileJSON(source, options);
+            "emit" in options && options.emit?.debugSymbols && usedLocals.length > 0 && block.push(usedLocals);
+            const moduleName = options.meta?.moduleName,
               idFn = options.id || defaultId,
               blockJSON = JSON.stringify(block),
               templateJSONObject = {
@@ -15614,7 +14927,6 @@ var define, require;
 
           const glimmerCompiler = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,
-                    Builder,
                     NEWLINE,
                     ProgramSymbols,
                     WireFormatDebugger,
@@ -15637,8 +14949,76 @@ var define, require;
                     DEBUG
           }, Symbol.toStringTag, { value: 'Module' });
 
+          const ContentType = {
+              Component: 0,
+              Helper: 1,
+              String: 2,
+              Empty: 3,
+              SafeString: 4,
+              Fragment: 5,
+              Node: 6,
+              Other: 8
+            },
+            InternalComponentCapabilities = {
+              Empty: 0,
+              dynamicLayout: 1,
+              dynamicTag: 2,
+              prepareArgs: 4,
+              createArgs: 8,
+              attributeHook: 16,
+              elementHook: 32,
+              dynamicScope: 64,
+              createCaller: 128,
+              updateHook: 256,
+              createInstance: 512,
+              wrapped: 1024,
+              willDestroy: 2048,
+              hasSubOwner: 4096
+            },
+            ARG_SHIFT = 8,
+            MAX_SIZE = 2147483647,
+            TYPE_SIZE = 255,
+            TYPE_MASK = 255,
+            OPERAND_LEN_MASK = 768,
+            MACHINE_MASK = 1024,
+            $pc = 0,
+            $ra = 1,
+            $fp = 2,
+            $sp = 3,
+            $s0 = 4,
+            $s1 = 5,
+            $t0 = 6,
+            $t1 = 7,
+            $v0 = 8;
+          function isLowLevelRegister(register) {
+            return register <= 3;
+          }
+
+          const glimmerVm = /*#__PURE__*/Object.defineProperty({
+                    __proto__: null,
+                    $fp,
+                    $pc,
+                    $ra,
+                    $s0,
+                    $s1,
+                    $sp,
+                    $t0,
+                    $t1,
+                    $v0,
+                    ARG_SHIFT,
+                    ContentType,
+                    InternalComponentCapabilities,
+                    InternalComponentCapability: InternalComponentCapabilities,
+                    MACHINE_MASK,
+                    MAX_SIZE,
+                    OPERAND_LEN_MASK,
+                    TYPE_MASK,
+                    TYPE_SIZE,
+                    isLowLevelRegister
+          }, Symbol.toStringTag, { value: 'Module' });
+
           // this file gets replaced with the real value during the build
-          const version = '6.4.0-alpha.2';
+          const version = '6.4.0-alpha.3';
 
           const emberVersion = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,