ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/{packages/shared-chunks/transform-resolutions-vHYYonpB.js → dev/packages/shared-chunks/transform-resolutions-fXGQKGsL.js}

@@ -1,6 +1,5 @@
 import '../@ember/debug/index.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
+import './debug-to-string-CFb7h0lY.js';
 import { a as assert } from './assert-CUCJBR2C.js';
 import { i as isPresentArray, a as getFirst, g as getLast } from './present-B1rrjAVM.js';
 import { assertNever } from '../@glimmer/util/index.js';
@@ -524,9 +523,9 @@ function build(ast, options = {
   return printer.print(ast);
 }
 
-var errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack'];
+const errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack'];
 function Exception(message, node) {
-  var loc = node && node.loc,
+  let loc = node && node.loc,
     line,
     endLineNumber,
     column,
@@ -538,11 +537,13 @@ function Exception(message, node) {
     endColumn = loc.end.column;
     message += ' - ' + line + ':' + column;
   }
-  var tmp = Error.prototype.constructor.call(this, message);
+  let tmp = Error.prototype.constructor.call(this, message);
+
   // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
-  for (var idx = 0; idx < errorProps.length; idx++) {
+  for (let idx = 0; idx < errorProps.length; idx++) {
     this[errorProps[idx]] = tmp[errorProps[idx]];
   }
+
   /* istanbul ignore else */
   if (Error.captureStackTrace) {
     Error.captureStackTrace(this, Exception);
@@ -551,6 +552,7 @@ function Exception(message, node) {
     if (loc) {
       this.lineNumber = line;
       this.endLineNumber = endLineNumber;
+
       // Work around issue under safari where we can't directly set the column value
       /* istanbul ignore next */
       if (Object.defineProperty) {
@@ -581,7 +583,7 @@ Visitor.prototype = {
   mutating: false,
   // Visits a given value. If mutating, will replace the value if necessary.
   acceptKey: function (node, name) {
-    var value = this.accept(node[name]);
+    let value = this.accept(node[name]);
     if (this.mutating) {
       // Hacky sanity check: This may have a few false positives for type for the helper
       // methods but will generally do the right thing without a lot of overhead.
@@ -602,7 +604,7 @@ Visitor.prototype = {
   // Traverses a given array. If mutating, empty responses will be removed
   // for child elements.
   acceptArray: function (array) {
-    for (var i = 0, l = array.length; i < l; i++) {
+    for (let i = 0, l = array.length; i < l; i++) {
       this.acceptKey(array, i);
       if (!array[i]) {
         array.splice(i, 1);
@@ -615,6 +617,7 @@ Visitor.prototype = {
     if (!object) {
       return;
     }
+
     /* istanbul ignore next: Sanity code */
     if (!this[object.type]) {
       throw new Exception('Unknown type: ' + object.type, object);
@@ -623,7 +626,7 @@ Visitor.prototype = {
       this.parents.unshift(this.current);
     }
     this.current = object;
-    var ret = this[object.type](object);
+    let ret = this[object.type](object);
     this.current = this.parents.shift();
     if (!this.mutating || ret) {
       return ret;
@@ -675,25 +678,22 @@ function visitPartial(partial) {
   this.acceptKey(partial, 'hash');
 }
 
-function WhitespaceControl(options) {
-  if (options === void 0) {
-    options = {};
-  }
+function WhitespaceControl(options = {}) {
   this.options = options;
 }
 WhitespaceControl.prototype = new Visitor();
 WhitespaceControl.prototype.Program = function (program) {
-  var doStandalone = !this.options.ignoreStandalone;
-  var isRoot = !this.isRootSeen;
+  const doStandalone = !this.options.ignoreStandalone;
+  let isRoot = !this.isRootSeen;
   this.isRootSeen = true;
-  var body = program.body;
-  for (var i = 0, l = body.length; i < l; i++) {
-    var current = body[i],
+  let body = program.body;
+  for (let i = 0, l = body.length; i < l; i++) {
+    let current = body[i],
       strip = this.accept(current);
     if (!strip) {
       continue;
     }
-    var _isPrevWhitespace = isPrevWhitespace(body, i, isRoot),
+    let _isPrevWhitespace = isPrevWhitespace(body, i, isRoot),
       _isNextWhitespace = isNextWhitespace(body, i, isRoot),
       openStandalone = strip.openStandalone && _isPrevWhitespace,
       closeStandalone = strip.closeStandalone && _isNextWhitespace,
@@ -716,6 +716,7 @@ WhitespaceControl.prototype.Program = function (program) {
     }
     if (doStandalone && openStandalone) {
       omitRight((current.program || current.inverse).body);
+
       // Strip out the previous content node if it's whitespace only
       omitLeft(body, i);
     }
@@ -730,19 +731,21 @@ WhitespaceControl.prototype.Program = function (program) {
 WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.DecoratorBlock = WhitespaceControl.prototype.PartialBlockStatement = function (block) {
   this.accept(block.program);
   this.accept(block.inverse);
+
   // Find the inverse program that is involved with whitespace stripping.
-  var program = block.program || block.inverse,
+  let program = block.program || block.inverse,
     inverse = block.program && block.inverse,
     firstInverse = inverse,
     lastInverse = inverse;
   if (inverse && inverse.chained) {
     firstInverse = inverse.body[0].program;
+
     // Walk the inverse chain to find the last inverse that is actually in the chain.
     while (lastInverse.chained) {
       lastInverse = lastInverse.body[lastInverse.body.length - 1].program;
     }
   }
-  var strip = {
+  let strip = {
     open: block.openStrip.open,
     close: block.closeStrip.close,
     // Determine the standalone candidacy. Basically flag our content as being possibly standalone
@@ -754,7 +757,7 @@ WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.Decorat
     omitRight(program.body, null, true);
   }
   if (inverse) {
-    var inverseStrip = block.inverseStrip;
+    let inverseStrip = block.inverseStrip;
     if (inverseStrip.open) {
       omitLeft(program.body, null, true);
     }
@@ -764,6 +767,7 @@ WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.Decorat
     if (block.closeStrip.open) {
       omitLeft(lastInverse.body, null, true);
     }
+
     // Find standalone else statements
     if (!this.options.ignoreStandalone && isPrevWhitespace(program.body) && isNextWhitespace(firstInverse.body)) {
       omitLeft(program.body);
@@ -779,7 +783,7 @@ WhitespaceControl.prototype.Decorator = WhitespaceControl.prototype.MustacheStat
 };
 WhitespaceControl.prototype.PartialStatement = WhitespaceControl.prototype.CommentStatement = function (node) {
   /* istanbul ignore next */
-  var strip = node.strip || {};
+  let strip = node.strip || {};
   return {
     inlineStandalone: true,
     open: strip.open,
@@ -790,9 +794,10 @@ function isPrevWhitespace(body, i, isRoot) {
   if (i === undefined) {
     i = body.length;
   }
+
   // Nodes that end with newlines are considered whitespace (but are special
   // cased for strip operations)
-  var prev = body[i - 1],
+  let prev = body[i - 1],
     sibling = body[i - 2];
   if (!prev) {
     return isRoot;
@@ -805,7 +810,7 @@ function isNextWhitespace(body, i, isRoot) {
   if (i === undefined) {
     i = -1;
   }
-  var next = body[i + 1],
+  let next = body[i + 1],
     sibling = body[i + 2];
   if (!next) {
     return isRoot;
@@ -814,6 +819,7 @@ function isNextWhitespace(body, i, isRoot) {
     return (sibling || !isRoot ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(next.original);
   }
 }
+
 // Marks the node to the right of the position as omitted.
 // I.e. {{foo}}' ' will mark the ' ' node as omitted.
 //
@@ -822,14 +828,15 @@ function isNextWhitespace(body, i, isRoot) {
 // If multiple is truthy then all whitespace will be stripped out until non-whitespace
 // content is met.
 function omitRight(body, i, multiple) {
-  var current = body[i == null ? 0 : i + 1];
+  let current = body[i == null ? 0 : i + 1];
   if (!current || current.type !== 'ContentStatement' || !multiple && current.rightStripped) {
     return;
   }
-  var original = current.value;
+  let original = current.value;
   current.value = current.value.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, '');
   current.rightStripped = current.value !== original;
 }
+
 // Marks the node to the left of the position as omitted.
 // I.e. ' '{{foo}} will mark the ' ' node as omitted.
 //
@@ -838,17 +845,19 @@ function omitRight(body, i, multiple) {
 // If multiple is truthy then all whitespace will be stripped out until non-whitespace
 // content is met.
 function omitLeft(body, i, multiple) {
-  var current = body[i == null ? body.length - 1 : i - 1];
+  let current = body[i == null ? body.length - 1 : i - 1];
   if (!current || current.type !== 'ContentStatement' || !multiple && current.leftStripped) {
     return;
   }
+
   // We omit the last node if it's whitespace only and not preceded by a non-content node.
-  var original = current.value;
+  let original = current.value;
   current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, '');
   current.leftStripped = current.value !== original;
   return current.leftStripped;
 }
 
+// @ts-nocheck
 /* parser generated by jison 0.4.18 */
 /*
   Returns a Parser object of the following structure:
@@ -967,140 +976,141 @@ var parser = function () {
     trace: function trace() {},
     yy: {},
     symbols_: {
-      "error": 2,
-      "root": 3,
-      "program": 4,
-      "EOF": 5,
-      "program_repetition0": 6,
-      "statement": 7,
-      "mustache": 8,
-      "block": 9,
-      "rawBlock": 10,
-      "partial": 11,
-      "partialBlock": 12,
-      "content": 13,
-      "COMMENT": 14,
-      "CONTENT": 15,
-      "openRawBlock": 16,
-      "rawBlock_repetition0": 17,
-      "END_RAW_BLOCK": 18,
-      "OPEN_RAW_BLOCK": 19,
-      "helperName": 20,
-      "openRawBlock_repetition0": 21,
-      "openRawBlock_option0": 22,
-      "CLOSE_RAW_BLOCK": 23,
-      "openBlock": 24,
-      "block_option0": 25,
-      "closeBlock": 26,
-      "openInverse": 27,
-      "block_option1": 28,
-      "OPEN_BLOCK": 29,
-      "openBlock_repetition0": 30,
-      "openBlock_option0": 31,
-      "openBlock_option1": 32,
-      "CLOSE": 33,
-      "OPEN_INVERSE": 34,
-      "openInverse_repetition0": 35,
-      "openInverse_option0": 36,
-      "openInverse_option1": 37,
-      "openInverseChain": 38,
-      "OPEN_INVERSE_CHAIN": 39,
-      "openInverseChain_repetition0": 40,
-      "openInverseChain_option0": 41,
-      "openInverseChain_option1": 42,
-      "inverseAndProgram": 43,
-      "INVERSE": 44,
-      "inverseChain": 45,
-      "inverseChain_option0": 46,
-      "OPEN_ENDBLOCK": 47,
-      "OPEN": 48,
-      "hash": 49,
-      "expr": 50,
-      "mustache_repetition0": 51,
-      "mustache_option0": 52,
-      "OPEN_UNESCAPED": 53,
-      "mustache_repetition1": 54,
-      "mustache_option1": 55,
-      "CLOSE_UNESCAPED": 56,
-      "OPEN_PARTIAL": 57,
-      "partial_repetition0": 58,
-      "partial_option0": 59,
-      "openPartialBlock": 60,
-      "OPEN_PARTIAL_BLOCK": 61,
-      "openPartialBlock_repetition0": 62,
-      "openPartialBlock_option0": 63,
-      "exprHead": 64,
-      "arrayLiteral": 65,
-      "sexpr": 66,
-      "OPEN_SEXPR": 67,
-      "CLOSE_SEXPR": 68,
-      "sexpr_repetition0": 69,
-      "sexpr_option0": 70,
-      "hash_repetition_plus0": 71,
-      "hashSegment": 72,
-      "ID": 73,
-      "EQUALS": 74,
-      "OPEN_ARRAY": 75,
-      "arrayLiteral_repetition0": 76,
-      "CLOSE_ARRAY": 77,
-      "blockParams": 78,
-      "OPEN_BLOCK_PARAMS": 79,
-      "blockParams_repetition_plus0": 80,
-      "CLOSE_BLOCK_PARAMS": 81,
-      "path": 82,
-      "dataName": 83,
-      "STRING": 84,
-      "NUMBER": 85,
-      "BOOLEAN": 86,
-      "UNDEFINED": 87,
-      "NULL": 88,
-      "DATA": 89,
-      "pathSegments": 90,
-      "sep": 91,
-      "SEP": 92,
-      "PRIVATE_SEP": 93,
-      "$accept": 0,
-      "$end": 1
+      error: 2,
+      root: 3,
+      program: 4,
+      EOF: 5,
+      program_repetition0: 6,
+      statement: 7,
+      mustache: 8,
+      block: 9,
+      rawBlock: 10,
+      partial: 11,
+      partialBlock: 12,
+      content: 13,
+      COMMENT: 14,
+      CONTENT: 15,
+      openRawBlock: 16,
+      rawBlock_repetition0: 17,
+      END_RAW_BLOCK: 18,
+      OPEN_RAW_BLOCK: 19,
+      helperName: 20,
+      openRawBlock_repetition0: 21,
+      openRawBlock_option0: 22,
+      CLOSE_RAW_BLOCK: 23,
+      openBlock: 24,
+      block_option0: 25,
+      closeBlock: 26,
+      openInverse: 27,
+      block_option1: 28,
+      OPEN_BLOCK: 29,
+      openBlock_repetition0: 30,
+      openBlock_option0: 31,
+      openBlock_option1: 32,
+      CLOSE: 33,
+      OPEN_INVERSE: 34,
+      openInverse_repetition0: 35,
+      openInverse_option0: 36,
+      openInverse_option1: 37,
+      openInverseChain: 38,
+      OPEN_INVERSE_CHAIN: 39,
+      openInverseChain_repetition0: 40,
+      openInverseChain_option0: 41,
+      openInverseChain_option1: 42,
+      inverseAndProgram: 43,
+      INVERSE: 44,
+      inverseChain: 45,
+      inverseChain_option0: 46,
+      OPEN_ENDBLOCK: 47,
+      OPEN: 48,
+      hash: 49,
+      expr: 50,
+      mustache_repetition0: 51,
+      mustache_option0: 52,
+      OPEN_UNESCAPED: 53,
+      mustache_repetition1: 54,
+      mustache_option1: 55,
+      CLOSE_UNESCAPED: 56,
+      OPEN_PARTIAL: 57,
+      partial_repetition0: 58,
+      partial_option0: 59,
+      openPartialBlock: 60,
+      OPEN_PARTIAL_BLOCK: 61,
+      openPartialBlock_repetition0: 62,
+      openPartialBlock_option0: 63,
+      exprHead: 64,
+      arrayLiteral: 65,
+      sexpr: 66,
+      OPEN_SEXPR: 67,
+      CLOSE_SEXPR: 68,
+      sexpr_repetition0: 69,
+      sexpr_option0: 70,
+      hash_repetition_plus0: 71,
+      hashSegment: 72,
+      ID: 73,
+      EQUALS: 74,
+      OPEN_ARRAY: 75,
+      arrayLiteral_repetition0: 76,
+      CLOSE_ARRAY: 77,
+      blockParams: 78,
+      OPEN_BLOCK_PARAMS: 79,
+      blockParams_repetition_plus0: 80,
+      CLOSE_BLOCK_PARAMS: 81,
+      path: 82,
+      dataName: 83,
+      STRING: 84,
+      NUMBER: 85,
+      BOOLEAN: 86,
+      UNDEFINED: 87,
+      NULL: 88,
+      DATA: 89,
+      pathSegments: 90,
+      sep: 91,
+      SEP: 92,
+      PRIVATE_SEP: 93,
+      $accept: 0,
+      $end: 1
     },
     terminals_: {
-      2: "error",
-      5: "EOF",
-      14: "COMMENT",
-      15: "CONTENT",
-      18: "END_RAW_BLOCK",
-      19: "OPEN_RAW_BLOCK",
-      23: "CLOSE_RAW_BLOCK",
-      29: "OPEN_BLOCK",
-      33: "CLOSE",
-      34: "OPEN_INVERSE",
-      39: "OPEN_INVERSE_CHAIN",
-      44: "INVERSE",
-      47: "OPEN_ENDBLOCK",
-      48: "OPEN",
-      53: "OPEN_UNESCAPED",
-      56: "CLOSE_UNESCAPED",
-      57: "OPEN_PARTIAL",
-      61: "OPEN_PARTIAL_BLOCK",
-      67: "OPEN_SEXPR",
-      68: "CLOSE_SEXPR",
-      73: "ID",
-      74: "EQUALS",
-      75: "OPEN_ARRAY",
-      77: "CLOSE_ARRAY",
-      79: "OPEN_BLOCK_PARAMS",
-      81: "CLOSE_BLOCK_PARAMS",
-      84: "STRING",
-      85: "NUMBER",
-      86: "BOOLEAN",
-      87: "UNDEFINED",
-      88: "NULL",
-      89: "DATA",
-      92: "SEP",
-      93: "PRIVATE_SEP"
+      2: 'error',
+      5: 'EOF',
+      14: 'COMMENT',
+      15: 'CONTENT',
+      18: 'END_RAW_BLOCK',
+      19: 'OPEN_RAW_BLOCK',
+      23: 'CLOSE_RAW_BLOCK',
+      29: 'OPEN_BLOCK',
+      33: 'CLOSE',
+      34: 'OPEN_INVERSE',
+      39: 'OPEN_INVERSE_CHAIN',
+      44: 'INVERSE',
+      47: 'OPEN_ENDBLOCK',
+      48: 'OPEN',
+      53: 'OPEN_UNESCAPED',
+      56: 'CLOSE_UNESCAPED',
+      57: 'OPEN_PARTIAL',
+      61: 'OPEN_PARTIAL_BLOCK',
+      67: 'OPEN_SEXPR',
+      68: 'CLOSE_SEXPR',
+      73: 'ID',
+      74: 'EQUALS',
+      75: 'OPEN_ARRAY',
+      77: 'CLOSE_ARRAY',
+      79: 'OPEN_BLOCK_PARAMS',
+      81: 'CLOSE_BLOCK_PARAMS',
+      84: 'STRING',
+      85: 'NUMBER',
+      86: 'BOOLEAN',
+      87: 'UNDEFINED',
+      88: 'NULL',
+      89: 'DATA',
+      92: 'SEP',
+      93: 'PRIVATE_SEP'
     },
     productions_: [0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [13, 1], [10, 3], [16, 5], [9, 4], [9, 4], [24, 6], [27, 6], [38, 6], [43, 2], [45, 3], [45, 1], [26, 3], [8, 3], [8, 5], [8, 5], [11, 5], [12, 3], [60, 5], [50, 1], [50, 1], [64, 1], [64, 1], [66, 3], [66, 5], [49, 1], [72, 3], [65, 3], [78, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [83, 2], [91, 1], [91, 1], [82, 3], [82, 1], [90, 3], [90, 1], [6, 0], [6, 2], [17, 0], [17, 2], [21, 0], [21, 2], [22, 0], [22, 1], [25, 0], [25, 1], [28, 0], [28, 1], [30, 0], [30, 2], [31, 0], [31, 1], [32, 0], [32, 1], [35, 0], [35, 2], [36, 0], [36, 1], [37, 0], [37, 1], [40, 0], [40, 2], [41, 0], [41, 1], [42, 0], [42, 1], [46, 0], [46, 1], [51, 0], [51, 2], [52, 0], [52, 1], [54, 0], [54, 2], [55, 0], [55, 1], [58, 0], [58, 2], [59, 0], [59, 1], [62, 0], [62, 2], [63, 0], [63, 1], [69, 0], [69, 2], [70, 0], [70, 1], [71, 1], [71, 2], [76, 0], [76, 2], [80, 1], [80, 2]],
     performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
       /* this == yyval */
+
       var $0 = $$.length - 1;
       switch (yystate) {
         case 1:
@@ -1201,7 +1211,7 @@ var parser = function () {
           break;
         case 22:
           this.$ = yy.prepareMustache(yy.syntax.hash($$[$0 - 1], yy.locInfo(this._$), {
-            yy: yy,
+            yy,
             syntax: 'expr'
           }), [], undefined, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);
           break;
@@ -1233,7 +1243,7 @@ var parser = function () {
           break;
         case 32:
           this.$ = yy.syntax.hash($$[$0 - 1], yy.locInfo(this._$), {
-            yy: yy,
+            yy,
             syntax: 'expr'
           });
           break;
@@ -1263,7 +1273,7 @@ var parser = function () {
           break;
         case 36:
           this.$ = yy.syntax.square($$[$0 - 1], yy.locInfo(this._$), {
-            yy: yy,
+            yy,
             syntax: 'expr'
           });
           break;
@@ -2107,13 +2117,13 @@ var parser = function () {
           expected = [];
           for (p in table[state]) {
             if (this.terminals_[p] && p > TERROR) {
-              expected.push('\'' + this.terminals_[p] + '\'');
+              expected.push("'" + this.terminals_[p] + "'");
             }
           }
           if (lexer.showPosition) {
-            errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
+            errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol) + "'";
           } else {
-            errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
+            errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : "'" + (this.terminals_[symbol] || symbol) + "'");
           }
           this.parseError(errStr, {
             text: lexer.match,
@@ -2264,7 +2274,7 @@ var parser = function () {
           this._backtrack = true;
         } else {
           return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
-            text: "",
+            text: '',
             token: null,
             line: this.yylineno
           });
@@ -2278,7 +2288,7 @@ var parser = function () {
       // displays already matched input, i.e. for error messages
       pastInput: function () {
         var past = this.matched.substr(0, this.matched.length - this.match.length);
-        return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
+        return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, '');
       },
       // displays upcoming input, i.e. for error messages
       upcomingInput: function () {
@@ -2286,13 +2296,13 @@ var parser = function () {
         if (next.length < 20) {
           next += this._input.substr(0, 20 - next.length);
         }
-        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
+        return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, '');
       },
       // displays the character position where the lexing error occurred, i.e. for error messages
       showPosition: function () {
         var pre = this.pastInput();
-        var c = new Array(pre.length + 1).join("-");
-        return pre + this.upcomingInput() + "\n" + c + "^";
+        var c = new Array(pre.length + 1).join('-');
+        return pre + this.upcomingInput() + '\n' + c + '^';
       },
       // test the lexed token: return FALSE when not a match, otherwise return token
       test_match: function (match, indexed_rule) {
@@ -2402,11 +2412,11 @@ var parser = function () {
           // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
           return false;
         }
-        if (this._input === "") {
+        if (this._input === '') {
           return this.EOF;
         } else {
           return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
-            text: "",
+            text: '',
             token: null,
             line: this.yylineno
           });
@@ -2439,7 +2449,7 @@ var parser = function () {
         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
           return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
         } else {
-          return this.conditions["INITIAL"].rules;
+          return this.conditions['INITIAL'].rules;
         }
       },
       // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
@@ -2448,7 +2458,7 @@ var parser = function () {
         if (n >= 0) {
           return this.conditionStack[n];
         } else {
-          return "INITIAL";
+          return 'INITIAL';
         }
       },
       // alias for begin(condition)
@@ -2466,14 +2476,14 @@ var parser = function () {
         }
         switch ($avoiding_name_collisions) {
           case 0:
-            if (yy_.yytext.slice(-2) === "\\\\") {
+            if (yy_.yytext.slice(-2) === '\\\\') {
               strip(0, 1);
-              this.begin("mu");
-            } else if (yy_.yytext.slice(-1) === "\\") {
+              this.begin('mu');
+            } else if (yy_.yytext.slice(-1) === '\\') {
               strip(0, 1);
-              this.begin("emu");
+              this.begin('emu');
             } else {
-              this.begin("mu");
+              this.begin('mu');
             }
             if (yy_.yytext) return 15;
             break;
@@ -2609,29 +2619,29 @@ var parser = function () {
       },
       rules: [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/, /^(?:\{\{\{\{(?=[^/]))/, /^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/, /^(?:[^\x00]+?(?=(\{\{\{\{)))/, /^(?:[\s\S]*?--(~)?\}\})/, /^(?:\()/, /^(?:\))/, /^(?:\[)/, /^(?:\])/, /^(?:\{\{\{\{)/, /^(?:\}\}\}\})/, /^(?:\{\{(~)?>)/, /^(?:\{\{(~)?#>)/, /^(?:\{\{(~)?#\*?)/, /^(?:\{\{(~)?\/)/, /^(?:\{\{(~)?\^\s*(~)?\}\})/, /^(?:\{\{(~)?\s*else\s*(~)?\}\})/, /^(?:\{\{(~)?\^)/, /^(?:\{\{(~)?\s*else\b)/, /^(?:\{\{(~)?\{)/, /^(?:\{\{(~)?&)/, /^(?:\{\{(~)?!--)/, /^(?:\{\{(~)?![\s\S]*?\}\})/, /^(?:\{\{(~)?\*?)/, /^(?:=)/, /^(?:\.\.)/, /^(?:\.(?=([=~}\s\/.)\]|])))/, /^(?:\.#)/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}(~)?\}\})/, /^(?:(~)?\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@)/, /^(?:true(?=([~}\s)\]])))/, /^(?:false(?=([~}\s)\]])))/, /^(?:undefined(?=([~}\s)\]])))/, /^(?:null(?=([~}\s)\]])))/, /^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)\]])))/, /^(?:as\s+\|)/, /^(?:\|)/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)\]|]))))/, /^(?:\[(\\\]|[^\]])*\])/, /^(?:.)/, /^(?:$)/],
       conditions: {
-        "mu": {
-          "rules": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47],
-          "inclusive": false
+        mu: {
+          rules: [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47],
+          inclusive: false
         },
-        "emu": {
-          "rules": [2],
-          "inclusive": false
+        emu: {
+          rules: [2],
+          inclusive: false
         },
-        "com": {
-          "rules": [6],
-          "inclusive": false
+        com: {
+          rules: [6],
+          inclusive: false
         },
-        "raw": {
-          "rules": [3, 4, 5],
-          "inclusive": false
+        raw: {
+          rules: [3, 4, 5],
+          inclusive: false
         },
-        "escl": {
-          "rules": [45],
-          "inclusive": false
+        escl: {
+          rules: [45],
+          inclusive: false
         },
-        "INITIAL": {
-          "rules": [0, 1, 47],
-          "inclusive": true
+        INITIAL: {
+          rules: [0, 1, 47],
+          inclusive: true
         }
       }
     };
@@ -2646,34 +2656,25 @@ var parser = function () {
   return new Parser();
 }();
 
-var __spreadArray$1 = undefined && undefined.__spreadArray || function (to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
 function PrintVisitor() {
   this.padding = 0;
 }
 PrintVisitor.prototype = new Visitor();
 PrintVisitor.prototype.pad = function (string) {
-  var out = '';
-  for (var i = 0, l = this.padding; i < l; i++) {
+  let out = '';
+  for (let i = 0, l = this.padding; i < l; i++) {
     out += '  ';
   }
   out += string + '\n';
   return out;
 };
 PrintVisitor.prototype.Program = function (program) {
-  var out = '',
+  let out = '',
     body = program.body,
     i,
     l;
   if (program.blockParams) {
-    var blockParams = 'BLOCK PARAMS: [';
+    let blockParams = 'BLOCK PARAMS: [';
     for (i = 0, l = program.blockParams.length; i < l; i++) {
       blockParams += ' ' + program.blockParams[i];
     }
@@ -2697,7 +2698,7 @@ PrintVisitor.prototype.Decorator = function (mustache) {
   return this.pad('{{ DIRECTIVE ' + this.callBody(mustache) + ' }}');
 };
 PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock = function (block) {
-  var out = '';
+  let out = '';
   out += this.pad((block.type === 'DecoratorBlock' ? 'DIRECTIVE ' : '') + 'BLOCK:');
   this.padding++;
   out += this.pad(this.callBody(block));
@@ -2723,7 +2724,7 @@ PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock =
   return out;
 };
 PrintVisitor.prototype.PartialStatement = function (partial) {
-  var content = 'PARTIAL:' + partial.name.original;
+  let content = 'PARTIAL:' + partial.name.original;
   if (partial.params[0]) {
     content += ' ' + this.accept(partial.params[0]);
   }
@@ -2733,7 +2734,7 @@ PrintVisitor.prototype.PartialStatement = function (partial) {
   return this.pad('{{> ' + content + ' }}');
 };
 PrintVisitor.prototype.PartialBlockStatement = function (partial) {
-  var content = 'PARTIAL BLOCK:' + partial.name.original;
+  let content = 'PARTIAL BLOCK:' + partial.name.original;
   if (partial.params[0]) {
     content += ' ' + this.accept(partial.params[0]);
   }
@@ -2753,13 +2754,13 @@ PrintVisitor.prototype.CommentStatement = function (comment) {
   return this.pad("{{! '" + comment.value + "' }}");
 };
 PrintVisitor.prototype.SubExpression = function (sexpr) {
-  return "(".concat(this.callBody(sexpr), ")");
+  return `(${this.callBody(sexpr)})`;
 };
 PrintVisitor.prototype.callBody = function (callExpr) {
-  var params = callExpr.params,
+  let params = callExpr.params,
     paramStrings = [],
     hash;
-  for (var i = 0, l = params.length; i < l; i++) {
+  for (let i = 0, l = params.length; i < l; i++) {
     paramStrings.push(this.accept(params[i]));
   }
   params = paramStrings.length === 0 ? '' : ' [' + paramStrings.join(', ') + ']';
@@ -2767,8 +2768,8 @@ PrintVisitor.prototype.callBody = function (callExpr) {
   return this.accept(callExpr.path) + params + hash;
 };
 PrintVisitor.prototype.PathExpression = function (id) {
-  var head = typeof id.head === 'string' ? id.head : "[".concat(this.accept(id.head), "]");
-  var path = __spreadArray$1([head], id.tail, true).join('/');
+  let head = typeof id.head === 'string' ? id.head : `[${this.accept(id.head)}]`;
+  let path = [head, ...id.tail].join('/');
   return 'p%' + prefix(id) + path;
 };
 function prefix(path) {
@@ -2796,21 +2797,18 @@ PrintVisitor.prototype.NullLiteral = function () {
   return 'NULL';
 };
 PrintVisitor.prototype.ArrayLiteral = function (array) {
-  var _this = this;
-  return "Array[".concat(array.items.map(function (item) {
-    return _this.accept(item);
-  }).join(', '), "]");
+  return `Array[${array.items.map(item => this.accept(item)).join(', ')}]`;
 };
 PrintVisitor.prototype.HashLiteral = function (hash) {
-  return "Hash{".concat(this.hashPairs(hash), "}");
+  return `Hash{${this.hashPairs(hash)}}`;
 };
 PrintVisitor.prototype.Hash = function (hash) {
-  return "HASH{".concat(this.hashPairs(hash), "}");
+  return `HASH{${this.hashPairs(hash)}}`;
 };
 PrintVisitor.prototype.hashPairs = function (hash) {
-  var pairs = hash.pairs,
+  let pairs = hash.pairs,
     joinedPairs = [];
-  for (var i = 0, l = pairs.length; i < l; i++) {
+  for (let i = 0, l = pairs.length; i < l; i++) {
     joinedPairs.push(this.HashPair(pairs[i]));
   }
   return joinedPairs.join(' ');
@@ -2818,21 +2816,11 @@ PrintVisitor.prototype.hashPairs = function (hash) {
 PrintVisitor.prototype.HashPair = function (pair) {
   return pair.key + '=' + this.accept(pair.value);
 };
-/* eslint-enable new-cap */
 
-var __spreadArray = undefined && undefined.__spreadArray || function (to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
 function validateClose(open, close) {
   close = close.path ? close.path.original : close;
   if (open.path.original !== close) {
-    var errorNode = {
+    let errorNode = {
       loc: open.path.loc
     };
     throw new Exception(open.path.original + " doesn't match " + close, errorNode);
@@ -2867,7 +2855,7 @@ function stripComment(comment) {
 }
 function preparePath(data, sexpr, parts, loc) {
   loc = this.locInfo(loc);
-  var original;
+  let original;
   if (data) {
     original = '@';
   } else if (sexpr) {
@@ -2875,60 +2863,60 @@ function preparePath(data, sexpr, parts, loc) {
   } else {
     original = '';
   }
-  var tail = [];
-  var depth = 0;
-  for (var i = 0, l = parts.length; i < l; i++) {
-    var part = parts[i].part;
+  let tail = [];
+  let depth = 0;
+  for (let i = 0, l = parts.length; i < l; i++) {
+    let part = parts[i].part;
     // If we have [] syntax then we do not treat path references as operators,
     // i.e. foo.[this] resolves to approximately context.foo['this']
-    var isLiteral = parts[i].original !== part;
-    var separator = parts[i].separator;
-    var partPrefix = separator === '.#' ? '#' : '';
+    let isLiteral = parts[i].original !== part;
+    let separator = parts[i].separator;
+    let partPrefix = separator === '.#' ? '#' : '';
     original += (separator || '') + part;
     if (!isLiteral && (part === '..' || part === '.' || part === 'this')) {
       if (tail.length > 0) {
         throw new Exception('Invalid path: ' + original, {
-          loc: loc
+          loc
         });
       } else if (part === '..') {
         depth++;
       }
     } else {
-      tail.push("".concat(partPrefix).concat(part));
+      tail.push(`${partPrefix}${part}`);
     }
   }
-  var head = sexpr || tail.shift();
+  let head = sexpr || tail.shift();
   return {
     type: 'PathExpression',
     this: original.startsWith('this.'),
-    data: data,
-    depth: depth,
-    head: head,
-    tail: tail,
-    parts: head ? __spreadArray([head], tail, true) : tail,
-    original: original,
-    loc: loc
+    data,
+    depth,
+    head,
+    tail,
+    parts: head ? [head, ...tail] : tail,
+    original,
+    loc
   };
 }
 function prepareMustache(path, params, hash, open, strip, locInfo) {
   // Must use charAt to support IE pre-10
-  var escapeFlag = open.charAt(3) || open.charAt(2),
+  let escapeFlag = open.charAt(3) || open.charAt(2),
     escaped = escapeFlag !== '{' && escapeFlag !== '&';
-  var decorator = /\*/.test(open);
+  let decorator = /\*/.test(open);
   return {
     type: decorator ? 'Decorator' : 'MustacheStatement',
-    path: path,
-    params: params,
-    hash: hash,
-    escaped: escaped,
-    strip: strip,
+    path,
+    params,
+    hash,
+    escaped,
+    strip,
     loc: this.locInfo(locInfo)
   };
 }
 function prepareRawBlock(openRawBlock, contents, close, locInfo) {
   validateClose(openRawBlock, close);
   locInfo = this.locInfo(locInfo);
-  var program = {
+  let program = {
     type: 'Program',
     body: contents,
     strip: {},
@@ -2939,7 +2927,7 @@ function prepareRawBlock(openRawBlock, contents, close, locInfo) {
     path: openRawBlock.path,
     params: openRawBlock.params,
     hash: openRawBlock.hash,
-    program: program,
+    program,
     openStrip: {},
     inverseStrip: {},
     closeStrip: {},
@@ -2950,9 +2938,9 @@ function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, lo
   if (close && close.path) {
     validateClose(openBlock, close);
   }
-  var decorator = /\*/.test(openBlock.open);
+  let decorator = /\*/.test(openBlock.open);
   program.blockParams = openBlock.blockParams;
-  var inverse, inverseStrip;
+  let inverse, inverseStrip;
   if (inverseAndProgram) {
     if (decorator) {
       throw new Exception('Unexpected inverse block on decorator', inverseAndProgram);
@@ -2973,18 +2961,19 @@ function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, lo
     path: openBlock.path,
     params: openBlock.params,
     hash: openBlock.hash,
-    program: program,
-    inverse: inverse,
+    program,
+    inverse,
     openStrip: openBlock.strip,
-    inverseStrip: inverseStrip,
+    inverseStrip,
     closeStrip: close && close.strip,
     loc: this.locInfo(locInfo)
   };
 }
 function prepareProgram(statements, loc) {
   if (!loc && statements.length) {
-    var firstLoc = statements[0].loc,
+    const firstLoc = statements[0].loc,
       lastLoc = statements[statements.length - 1].loc;
+
     /* istanbul ignore else */
     if (firstLoc && lastLoc) {
       loc = {
@@ -3014,7 +3003,7 @@ function preparePartialBlock(open, program, close, locInfo) {
     name: open.path,
     params: open.params,
     hash: open.hash,
-    program: program,
+    program,
     openStrip: open.strip,
     closeStrip: close && close.strip,
     loc: this.locInfo(locInfo)
@@ -3035,33 +3024,33 @@ const Helpers = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   stripFlags
 }, Symbol.toStringTag, { value: 'Module' }));
 
-var baseHelpers = {};
-for (var helper in Helpers) {
+let baseHelpers = {};
+for (let helper in Helpers) {
   if (Object.prototype.hasOwnProperty.call(Helpers, helper)) {
     baseHelpers[helper] = Helpers[helper];
   }
 }
 function parseWithoutProcessing(input, options) {
-  var _a, _b, _c;
   // Just return if an already-compiled AST was passed in.
   if (input.type === 'Program') {
     return input;
   }
   parser.yy = baseHelpers;
+
   // Altering the shared object here, but this is ok as parser is a sync operation
   parser.yy.locInfo = function (locInfo) {
     return new SourceLocation(options && options.srcName, locInfo);
   };
-  var squareSyntax;
-  if (typeof ((_a = options === null || options === void 0 ? void 0 : options.syntax) === null || _a === void 0 ? void 0 : _a.square) === 'function') {
+  let squareSyntax;
+  if (typeof options?.syntax?.square === 'function') {
     squareSyntax = options.syntax.square;
-  } else if (((_b = options === null || options === void 0 ? void 0 : options.syntax) === null || _b === void 0 ? void 0 : _b.square) === 'node') {
+  } else if (options?.syntax?.square === 'node') {
     squareSyntax = arrayLiteralNode;
   } else {
     squareSyntax = 'string';
   }
-  var hashSyntax;
-  if (typeof ((_c = options === null || options === void 0 ? void 0 : options.syntax) === null || _c === void 0 ? void 0 : _c.hash) === 'function') {
+  let hashSyntax;
+  if (typeof options?.syntax?.hash === 'function') {
     hashSyntax = options.syntax.hash;
   } else {
     hashSyntax = hashLiteralNode;
@@ -3076,19 +3065,19 @@ function arrayLiteralNode(array, loc) {
   return {
     type: 'ArrayLiteral',
     items: array,
-    loc: loc
+    loc
   };
 }
 function hashLiteralNode(hash, loc) {
   return {
     type: 'HashLiteral',
     pairs: hash.pairs,
-    loc: loc
+    loc
   };
 }
 function parse(input, options) {
-  var ast = parseWithoutProcessing(input, options);
-  var strip = new WhitespaceControl(options);
+  let ast = parseWithoutProcessing(input, options);
+  let strip = new WhitespaceControl(options);
   return strip.accept(ast);
 }
 
@@ -7340,6 +7329,62 @@ const HELPER_NAMESPACE = HELPER_VAR_NS;
 const MODIFIER_NAMESPACE = MODIFIER_VAR_NS;
 const COMPONENT_NAMESPACE = COMPONENT_VAR_NS;
 
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+  {{helper "..." ...}}
+  ```
+
+  with
+
+  ```handlebars
+  {{helper (-resolve "helper:...") ...}}
+  ```
+
+  and
+
+  ```handlebars
+  {{helper ... ...}}
+  ```
+
+  with
+
+  ```handlebars
+  {{helper (-disallow-dynamic-resolution ...) ...}}
+  ```
+
+  and
+
+  ```handlebars
+  {{modifier "..." ...}}
+  ```
+
+  with
+
+  ```handlebars
+  {{modifier (-resolve "modifier:...") ...}}
+  ```
+  and
+
+  ```handlebars
+  {{modifier ... ...}}
+  ```
+
+  with
+
+  ```handlebars
+  {{modifier (-disallow-dynamic-resolution ...) ...}}
+  ```
+
+  @private
+  @class TransformResolutions
+*/
+
 const TARGETS = Object.freeze(['helper', 'modifier']);
 function transformResolutions(env) {
   let {
@@ -7369,7 +7414,7 @@ function transformResolutions(env) {
         }
       },
       MustacheStatement(node) {
-        (isDevelopingApp() && !(seen) && assert$1('[BUG] seen set should be available', seen));
+        (!(seen) && assert$1('[BUG] seen set should be available', seen));
         if (seen.has(node)) {
           return;
         }
@@ -7382,7 +7427,7 @@ function transformResolutions(env) {
         }
       },
       SubExpression(node) {
-        (isDevelopingApp() && !(seen) && assert$1('[BUG] seen set should be available', seen));
+        (!(seen) && assert$1('[BUG] seen set should be available', seen));
         if (seen.has(node)) {
           return;
         }
@@ -7402,14 +7447,12 @@ function isLocalVariable(node, hasLocal) {
 }
 function transformParams(b, params, type, moduleName, loc) {
   let [first, ...rest] = params;
-  (isDevelopingApp() && !(first) && assert$1(`The ${type} keyword requires at least one positional arguments ${calculateLocationDisplay(moduleName, loc)}`, first));
+  (!(first) && assert$1(`The ${type} keyword requires at least one positional arguments ${calculateLocationDisplay(moduleName, loc)}`, first));
   if (isStringLiteral(first)) {
     return [b.sexpr(b.path('-resolve', first.loc), [b.string(`${type}:${first.value}`)], undefined, first.loc), ...rest];
-  } else if (isDevelopingApp()) {
-    return [b.sexpr(b.path('-disallow-dynamic-resolution', first.loc), [first], b.hash([b.pair('type', b.string(type), first.loc), b.pair('loc', b.string(calculateLocationDisplay(moduleName, loc)), first.loc), b.pair('original', b.string(build(first)))]), first.loc), ...rest];
   } else {
-    return params;
+    return [b.sexpr(b.path('-disallow-dynamic-resolution', first.loc), [first], b.hash([b.pair('type', b.string(type), first.loc), b.pair('loc', b.string(calculateLocationDisplay(moduleName, loc)), first.loc), b.pair('original', b.string(build(first)))]), first.loc), ...rest];
   }
 }
 
-export { isLiteral as $, Args as A, Block as B, ComponentArg as C, NamedBlocks as D, EntityParser as E, FreeVarReference as F, InvokeBlock as G, HtmlAttr as H, InterpolateExpression as I, SimpleElement as J, KeywordExpression as K, LocalVarReference as L, InvokeComponent as M, NON_EXISTENT_LOCATION as N, SpanList as O, PositionalArguments as P, LooseModeResolution as Q, COMPONENT_NAMESPACE as R, SourceOffset as S, Template as T, MODIFIER_NAMESPACE as U, HELPER_NAMESPACE as V, HtmlText as W, HtmlComment as X, GlimmerComment as Y, Printer as Z, node as _, SourceSpan as a, maybeLoc as a0, loc as a1, cannotRemoveNode as b, cannotReplaceOrRemoveInKeyHandlerYet as c, cannotReplaceNode as d, SYNTHETIC_LOCATION as e, EventedTokenizer as f, parse as g, build as h, isVoidTag as i, STRICT_RESOLUTION as j, NamedBlock as k, SourceSlice as l, NamedArgument as m, namedCharRefs as n, NamedArguments as o, parseWithoutProcessing as p, SplatAttr as q, PathExpression as r, ThisReference as s, transformResolutions as t, ArgReference as u, voidMap as v, CallExpression as w, LiteralExpression as x, AppendContent as y, ElementModifier as z };
+export { maybeLoc as $, Args as A, Block as B, ComponentArg as C, InvokeBlock as D, EntityParser as E, FreeVarReference as F, SimpleElement as G, HtmlAttr as H, InterpolateExpression as I, InvokeComponent as J, KeywordExpression as K, LocalVarReference as L, SpanList as M, NON_EXISTENT_LOCATION as N, LooseModeResolution as O, PositionalArguments as P, COMPONENT_NAMESPACE as Q, MODIFIER_NAMESPACE as R, SourceOffset as S, Template as T, HELPER_NAMESPACE as U, HtmlText as V, HtmlComment as W, GlimmerComment as X, Printer as Y, node as Z, isLiteral as _, SourceSpan as a, loc as a0, transformResolutions as a1, build as b, cannotReplaceOrRemoveInKeyHandlerYet as c, cannotRemoveNode as d, cannotReplaceNode as e, SYNTHETIC_LOCATION as f, EventedTokenizer as g, parse as h, isVoidTag as i, STRICT_RESOLUTION as j, NamedBlock as k, SourceSlice as l, NamedArgument as m, namedCharRefs as n, NamedArguments as o, parseWithoutProcessing as p, SplatAttr as q, PathExpression as r, ThisReference as s, ArgReference as t, CallExpression as u, voidMap as v, LiteralExpression as w, AppendContent as x, ElementModifier as y, NamedBlocks as z };