ember-source 4.0.0-beta.6 → 4.1.0-alpha.5

package/dist/ember-template-compiler.js

@@ -6,11 +6,12 @@
  *            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   4.0.0-beta.6
+ * @version   4.1.0-alpha.5
  */
 
 /* eslint-disable no-var */
 /* globals global globalThis self */
+/* eslint-disable-next-line no-unused-vars */
 var define, require;
 
 (function () {
@@ -1301,7 +1302,7 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
     value: true
   });
   _exports.isEnabled = isEnabled;
-  _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = _exports.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = _exports.EMBER_STRICT_MODE = _exports.EMBER_MODERNIZED_BUILT_IN_COMPONENTS = _exports.EMBER_GLIMMER_INVOKE_HELPER = _exports.EMBER_GLIMMER_HELPER_MANAGER = _exports.EMBER_NAMED_BLOCKS = _exports.EMBER_IMPROVED_INSTRUMENTATION = _exports.EMBER_LIBRARIES_ISREGISTERED = _exports.FEATURES = _exports.DEFAULT_FEATURES = void 0;
+  _exports.EMBER_CACHED = _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = _exports.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = _exports.EMBER_STRICT_MODE = _exports.EMBER_MODERNIZED_BUILT_IN_COMPONENTS = _exports.EMBER_GLIMMER_INVOKE_HELPER = _exports.EMBER_GLIMMER_HELPER_MANAGER = _exports.EMBER_NAMED_BLOCKS = _exports.EMBER_IMPROVED_INSTRUMENTATION = _exports.EMBER_LIBRARIES_ISREGISTERED = _exports.FEATURES = _exports.DEFAULT_FEATURES = void 0;
 
   /**
     Set `EmberENV.FEATURES` in your application's `config/environment.js` file
@@ -1314,15 +1315,16 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
     @public
   */
   var DEFAULT_FEATURES = {
-    EMBER_LIBRARIES_ISREGISTERED: false,
-    EMBER_IMPROVED_INSTRUMENTATION: false,
+    EMBER_LIBRARIES_ISREGISTERED: null,
+    EMBER_IMPROVED_INSTRUMENTATION: null,
     EMBER_NAMED_BLOCKS: true,
     EMBER_GLIMMER_HELPER_MANAGER: true,
     EMBER_GLIMMER_INVOKE_HELPER: true,
     EMBER_MODERNIZED_BUILT_IN_COMPONENTS: true,
     EMBER_STRICT_MODE: true,
     EMBER_DYNAMIC_HELPERS_AND_MODIFIERS: true,
-    EMBER_ROUTING_ROUTER_SERVICE_REFRESH: false
+    EMBER_ROUTING_ROUTER_SERVICE_REFRESH: null,
+    EMBER_CACHED: null
   };
   /**
     The hash of enabled Canary features. Add to this, any canary features
@@ -1392,6 +1394,8 @@ define("@ember/canary-features/index", ["exports", "@ember/-internals/environmen
   _exports.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = EMBER_DYNAMIC_HELPERS_AND_MODIFIERS;
   var EMBER_ROUTING_ROUTER_SERVICE_REFRESH = featureValue(FEATURES.EMBER_ROUTING_ROUTER_SERVICE_REFRESH);
   _exports.EMBER_ROUTING_ROUTER_SERVICE_REFRESH = EMBER_ROUTING_ROUTER_SERVICE_REFRESH;
+  var EMBER_CACHED = featureValue(FEATURES.EMBER_CACHED);
+  _exports.EMBER_CACHED = EMBER_CACHED;
 });
 define("@ember/debug/container-debug-adapter", ["exports", "@ember/-internals/extension-support"], function (_exports, _extensionSupport) {
   "use strict";
@@ -2539,6 +2543,25 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
   }
 
+  var __classPrivateFieldSet = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var __classPrivateFieldGet = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var _keywords, _type;
+
   class KeywordImpl {
     constructor(keyword, type, delegate) {
       this.keyword = keyword;
@@ -2627,18 +2650,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
   class Keywords {
     constructor(type) {
-      this._keywords = [];
-      this._type = type;
+      _keywords.set(this, []);
+
+      _type.set(this, void 0);
+
+      __classPrivateFieldSet(this, _type, type);
     }
 
     kw(name, delegate) {
-      this._keywords.push(keyword(name, this._type, delegate));
+      __classPrivateFieldGet(this, _keywords).push(keyword(name, __classPrivateFieldGet(this, _type), delegate));
 
       return this;
     }
 
     translate(node$$1, state) {
-      for (var _keyword of this._keywords) {
+      for (var _keyword of __classPrivateFieldGet(this, _keywords)) {
         var result = _keyword.translate(node$$1, state);
 
         if (result !== null) {
@@ -2652,7 +2678,9 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         var {
           name
         } = path.ref;
-        var usedType = this._type;
+
+        var usedType = __classPrivateFieldGet(this, _type);
+
         var validTypes = _syntax.KEYWORDS_TYPES[name];
 
         if (validTypes.indexOf(usedType) === -1) {
@@ -2665,6 +2693,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
   }
 
+  _keywords = new WeakMap(), _type = new WeakMap();
   var typesToReadableName = {
     Append: 'an append statement',
     Block: 'a block statement',
@@ -4247,37 +4276,66 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   }
 
   var VISIT_STMTS = new NormalizationStatements();
+
+  var __classPrivateFieldSet$1 = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var __classPrivateFieldGet$1 = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var _currentScope, _cursorCount;
   /**
    * This is the mutable state for this compiler pass.
    */
 
+
   class NormalizationState {
     constructor(block, isStrict) {
       this.isStrict = isStrict;
-      this._cursorCount = 0;
-      this._currentScope = block;
+
+      _currentScope.set(this, void 0);
+
+      _cursorCount.set(this, 0);
+
+      __classPrivateFieldSet$1(this, _currentScope, block);
     }
 
     generateUniqueCursor() {
-      return "%cursor:" + this._cursorCount++ + "%";
+      var _a;
+
+      return "%cursor:" + (__classPrivateFieldSet$1(this, _cursorCount, (_a = +__classPrivateFieldGet$1(this, _cursorCount)) + 1), _a) + "%";
     }
 
     get scope() {
-      return this._currentScope;
+      return __classPrivateFieldGet$1(this, _currentScope);
     }
 
     visitBlock(block) {
-      var oldBlock = this._currentScope;
-      this._currentScope = block.scope;
+      var oldBlock = __classPrivateFieldGet$1(this, _currentScope);
+
+      __classPrivateFieldSet$1(this, _currentScope, block.scope);
 
       try {
         return VISIT_STMTS.visitList(block.body, this);
       } finally {
-        this._currentScope = oldBlock;
+        __classPrivateFieldSet$1(this, _currentScope, oldBlock);
       }
     }
 
   }
+
+  _currentScope = new WeakMap(), _cursorCount = new WeakMap();
   /**
    * Normalize the AST from @glimmer/syntax into the HIR. The HIR has special
    * instructions for keywords like `{{yield}}`, `(has-block)` and
@@ -4317,7 +4375,6 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
    * ```
    */
 
-
   function normalize$1(source, root, isStrict) {
     // create a new context for the normalization pass
     var state = new NormalizationState(root.table, isStrict);
@@ -7029,6 +7086,27 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
   }
+
+  _exports.SourceSlice = SourceSlice;
+
+  var __classPrivateFieldSet = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var __classPrivateFieldGet = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var _whens, _map, _whens_1;
   /**
    * 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
@@ -7039,17 +7117,18 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    */
 
 
-  _exports.SourceSlice = SourceSlice;
   var MatchAny = 'MATCH_ANY';
   var IsInvisible = 'IS_INVISIBLE';
 
   class WhenList {
     constructor(whens) {
-      this._whens = whens;
+      _whens.set(this, void 0);
+
+      __classPrivateFieldSet(this, _whens, whens);
     }
 
     first(kind) {
-      for (var when of this._whens) {
+      for (var when of __classPrivateFieldGet(this, _whens)) {
         var value = when.match(kind);
 
         if ((0, _util.isPresent)(value)) {
@@ -7062,13 +7141,15 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _whens = new WeakMap();
+
   class When {
     constructor() {
-      this._map = new Map();
+      _map.set(this, new Map());
     }
 
     get(pattern, or) {
-      var value = this._map.get(pattern);
+      var value = __classPrivateFieldGet(this, _map).get(pattern);
 
       if (value) {
         return value;
@@ -7076,22 +7157,22 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
       value = or();
 
-      this._map.set(pattern, value);
+      __classPrivateFieldGet(this, _map).set(pattern, value);
 
       return value;
     }
 
     add(pattern, out) {
-      this._map.set(pattern, out);
+      __classPrivateFieldGet(this, _map).set(pattern, out);
     }
 
     match(kind) {
       var pattern = patternFor(kind);
       var out = [];
 
-      var exact = this._map.get(pattern);
+      var exact = __classPrivateFieldGet(this, _map).get(pattern);
 
-      var fallback = this._map.get(MatchAny);
+      var fallback = __classPrivateFieldGet(this, _map).get(MatchAny);
 
       if (exact) {
         out.push(exact);
@@ -7106,13 +7187,15 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _map = new WeakMap();
+
   function match(callback) {
     return callback(new Matcher()).check();
   }
 
   class Matcher {
     constructor() {
-      this._whens = new When();
+      _whens_1.set(this, new When());
     }
     /**
      * You didn't exhaustively match all possibilities.
@@ -7124,7 +7207,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     matchFor(left, right) {
-      var nesteds = this._whens.match(left);
+      var nesteds = __classPrivateFieldGet(this, _whens_1).match(left);
 
       var callback = new WhenList(nesteds).first(right);
       return callback;
@@ -7132,13 +7215,15 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
     when(left, right, // eslint-disable-next-line @typescript-eslint/no-explicit-any
     callback) {
-      this._whens.get(left, () => new When()).add(right, callback);
+      __classPrivateFieldGet(this, _whens_1).get(left, () => new When()).add(right, callback);
 
       return this;
     }
 
   }
 
+  _whens_1 = new WeakMap();
+
   function patternFor(kind) {
     switch (kind) {
       case "Broken"
@@ -7155,7 +7240,26 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       default:
         return kind;
     }
-  } // eslint-disable-next-line import/no-extraneous-dependencies
+  }
+
+  var __classPrivateFieldGet$1 = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var __classPrivateFieldSet$1 = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var _locPos, _charPos; // eslint-disable-next-line import/no-extraneous-dependencies
 
   /**
    * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It
@@ -7290,7 +7394,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       ;
       /** Computed from char offset */
 
-      this._locPos = null;
+      _locPos.set(this, null);
     }
     /**
      * This is already a `CharPosition`.
@@ -7337,15 +7441,15 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
 
     toHbsPos() {
-      var locPos = this._locPos;
+      var locPos = __classPrivateFieldGet$1(this, _locPos);
 
       if (locPos === null) {
         var hbsPos = this.source.hbsPosFor(this.charPos);
 
         if (hbsPos === null) {
-          this._locPos = locPos = BROKEN;
+          __classPrivateFieldSet$1(this, _locPos, locPos = BROKEN);
         } else {
-          this._locPos = locPos = new HbsPosition(this.source, hbsPos, this.charPos);
+          __classPrivateFieldSet$1(this, _locPos, locPos = new HbsPosition(this.source, hbsPos, this.charPos));
         }
       }
 
@@ -7354,6 +7458,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _locPos = new WeakMap();
+
   class HbsPosition {
     constructor(source, hbsPos, charPos = null) {
       this.source = source;
@@ -7361,7 +7467,10 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.kind = "HbsPosition"
       /* HbsPosition */
       ;
-      this._charPos = charPos === null ? null : new CharPosition(source, charPos);
+
+      _charPos.set(this, void 0);
+
+      __classPrivateFieldSet$1(this, _charPos, charPos === null ? null : new CharPosition(source, charPos));
     }
     /**
      * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has
@@ -7374,15 +7483,15 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
 
     toCharPos() {
-      var charPos = this._charPos;
+      var charPos = __classPrivateFieldGet$1(this, _charPos);
 
       if (charPos === null) {
         var charPosNumber = this.source.charPosFor(this.hbsPos);
 
         if (charPosNumber === null) {
-          this._charPos = charPos = BROKEN;
+          __classPrivateFieldSet$1(this, _charPos, charPos = BROKEN);
         } else {
-          this._charPos = charPos = new CharPosition(this.source, charPosNumber);
+          __classPrivateFieldSet$1(this, _charPos, charPos = new CharPosition(this.source, charPosNumber));
         }
       }
 
@@ -7416,6 +7525,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _charPos = new WeakMap();
+
   class InvisiblePosition {
     constructor(kind, // whatever was provided, possibly broken
     pos) {
@@ -7495,7 +7606,26 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     var _a;
 
     return ((_a = left.toCharPos()) === null || _a === void 0 ? void 0 : _a.offset) === right;
-  }).when(MatchAny, MatchAny, () => false)); // eslint-disable-next-line import/no-extraneous-dependencies
+  }).when(MatchAny, MatchAny, () => false));
+
+  var __classPrivateFieldGet$2 = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var __classPrivateFieldSet$2 = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var _locPosSpan, _charPosSpan, _providedHbsLoc; // eslint-disable-next-line import/no-extraneous-dependencies
 
   /**
    * A `SourceSpan` object represents a span of characters inside of a template source.
@@ -7532,6 +7662,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * The goal is to avoid creating any problems for use-cases like AST Explorer.
    */
 
+
   class SourceSpan {
     constructor(data) {
       this.data = data;
@@ -7787,7 +7918,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.kind = "CharPosition"
       /* CharPosition */
       ;
-      this._locPosSpan = null;
+
+      _locPosSpan.set(this, null);
     }
 
     wrap() {
@@ -7813,19 +7945,19 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     locDidUpdate() {}
 
     toHbsSpan() {
-      var locPosSpan = this._locPosSpan;
+      var locPosSpan = __classPrivateFieldGet$2(this, _locPosSpan);
 
       if (locPosSpan === null) {
         var start = this.charPositions.start.toHbsPos();
         var end = this.charPositions.end.toHbsPos();
 
         if (start === null || end === null) {
-          locPosSpan = this._locPosSpan = BROKEN;
+          locPosSpan = __classPrivateFieldSet$2(this, _locPosSpan, BROKEN);
         } else {
-          locPosSpan = this._locPosSpan = new HbsSpan(this.source, {
+          locPosSpan = __classPrivateFieldSet$2(this, _locPosSpan, new HbsSpan(this.source, {
             start,
             end
-          });
+          }));
         }
       }
 
@@ -7855,6 +7987,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _locPosSpan = new WeakMap();
+
   class HbsSpan {
     constructor(source, hbsPositions, providedHbsLoc = null) {
       this.source = source;
@@ -7862,8 +7996,13 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.kind = "HbsPosition"
       /* HbsPosition */
       ;
-      this._charPosSpan = null;
-      this._providedHbsLoc = providedHbsLoc;
+
+      _charPosSpan.set(this, null); // the source location from Handlebars + AST Plugins -- could be wrong
+
+
+      _providedHbsLoc.set(this, void 0);
+
+      __classPrivateFieldSet$2(this, _providedHbsLoc, providedHbsLoc);
     }
 
     serialize() {
@@ -7878,16 +8017,17 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     updateProvided(pos, edge) {
-      if (this._providedHbsLoc) {
-        this._providedHbsLoc[edge] = pos;
+      if (__classPrivateFieldGet$2(this, _providedHbsLoc)) {
+        __classPrivateFieldGet$2(this, _providedHbsLoc)[edge] = pos;
       } // invalidate computed character offsets
 
 
-      this._charPosSpan = null;
-      this._providedHbsLoc = {
+      __classPrivateFieldSet$2(this, _charPosSpan, null);
+
+      __classPrivateFieldSet$2(this, _providedHbsLoc, {
         start: pos,
         end: pos
-      };
+      });
     }
 
     locDidUpdate({
@@ -7934,19 +8074,19 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     toCharPosSpan() {
-      var charPosSpan = this._charPosSpan;
+      var charPosSpan = __classPrivateFieldGet$2(this, _charPosSpan);
 
       if (charPosSpan === null) {
         var start = this.hbsPositions.start.toCharPos();
         var end = this.hbsPositions.end.toCharPos();
 
         if (start && end) {
-          charPosSpan = this._charPosSpan = new CharPositionSpan(this.source, {
+          charPosSpan = __classPrivateFieldSet$2(this, _charPosSpan, new CharPositionSpan(this.source, {
             start,
             end
-          });
+          }));
         } else {
-          charPosSpan = this._charPosSpan = BROKEN;
+          charPosSpan = __classPrivateFieldSet$2(this, _charPosSpan, BROKEN);
           return null;
         }
       }
@@ -7956,6 +8096,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   }
 
+  _charPosSpan = new WeakMap(), _providedHbsLoc = new WeakMap();
+
   class InvisibleSpan {
     constructor(kind, // whatever was provided, possibly broken
     loc, // if the span represents a synthetic string
@@ -8182,9 +8324,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.loc = loc;
       this.type = 'PathExpression';
       this.this = false;
-      this.data = false; // Cache for the head value.
-
-      this._head = undefined;
+      this.data = false;
       var parts = tail.slice();
 
       if (head.type === 'ThisHead') {
@@ -8200,10 +8340,6 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     get head() {
-      if (this._head) {
-        return this._head;
-      }
-
       var firstPart;
 
       if (this.this) {
@@ -8217,7 +8353,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       var firstPartLoc = this.loc.collapse('start').sliceStartChars({
         chars: firstPart.length
       }).loc;
-      return this._head = publicBuilder.head(firstPart, firstPartLoc);
+      return publicBuilder.head(firstPart, firstPartLoc);
     }
 
     get tail() {
@@ -8976,7 +9112,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
           return class {
             constructor(fields) {
               this.type = type;
-              (0, _util.assign)(this, fields);
+              this.loc = fields.loc;
+              copy(fields, this);
             }
 
           };
@@ -8988,7 +9125,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         fields() {
           return class {
             constructor(fields) {
-              (0, _util.assign)(this, fields);
+              this.loc = fields.loc;
+              copy(fields, this);
             }
 
           };
@@ -8997,6 +9135,16 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       };
     }
   }
+
+  function keys(object) {
+    return Object.keys(object);
+  }
+
+  function copy(object1, object2) {
+    for (var key of keys(object1)) {
+      object2[key] = object1[key];
+    }
+  }
   /**
    * Corresponds to syntaxes with positional and named arguments:
    *
@@ -9156,9 +9304,30 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
 
   class ElementModifier extends node('ElementModifier').fields() {}
 
+  var __classPrivateFieldSet$3 = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var __classPrivateFieldGet$3 = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var _span;
+
   class SpanList {
     constructor(span = []) {
-      this._span = span;
+      _span.set(this, void 0);
+
+      __classPrivateFieldSet$3(this, _span, span);
     }
 
     static range(span, fallback = SourceSpan.NON_EXISTENT) {
@@ -9166,15 +9335,17 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     add(offset) {
-      this._span.push(offset);
+      __classPrivateFieldGet$3(this, _span).push(offset);
     }
 
     getRangeOffset(fallback) {
-      if (this._span.length === 0) {
+      if (__classPrivateFieldGet$3(this, _span).length === 0) {
         return fallback;
       } else {
-        var first = this._span[0];
-        var last = this._span[this._span.length - 1];
+        var first = __classPrivateFieldGet$3(this, _span)[0];
+
+        var last = __classPrivateFieldGet$3(this, _span)[__classPrivateFieldGet$3(this, _span).length - 1];
+
         return first.extend(last);
       }
     }
@@ -9182,6 +9353,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
   }
 
   _exports.SpanList = SpanList;
+  _span = new WeakMap();
 
   function loc(span) {
     if (Array.isArray(span)) {
@@ -10173,11 +10345,160 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     return new TraversalError('Replacing and removing in key handlers is not yet supported.', node, null, key);
   }
 
+  function getLocalName(node) {
+    switch (node.type) {
+      case 'ElementNode':
+        // unfortunately the ElementNode stores `tag` as a string
+        // if that changes in glimmer-vm this will need to be updated
+        return node.tag.split('.')[0];
+
+      case 'SubExpression':
+      case 'MustacheStatement':
+      case 'BlockStatement':
+        return getLocalName(node.path);
+
+      case 'UndefinedLiteral':
+      case 'NullLiteral':
+      case 'BooleanLiteral':
+      case 'StringLiteral':
+      case 'NumberLiteral':
+      case 'TextNode':
+      case 'Template':
+      case 'Block':
+      case 'CommentStatement':
+      case 'MustacheCommentStatement':
+      case 'PartialStatement':
+      case 'ElementModifierStatement':
+      case 'AttrNode':
+      case 'ConcatStatement':
+      case 'Program':
+      case 'Hash':
+      case 'HashPair':
+        return undefined;
+
+      case 'PathExpression':
+      default:
+        return node.parts.length ? node.parts[0] : undefined;
+    }
+  }
+
+  function getLocals(node) {
+    switch (node.type) {
+      case 'ElementNode':
+      case 'Program':
+      case 'Block':
+      case 'Template':
+        return node.blockParams;
+
+      case 'BlockStatement':
+        return node.program.blockParams;
+
+      default:
+        return undefined;
+    }
+  }
+
+  class TransformScope {
+    constructor(locals) {
+      this.locals = locals;
+      this.hasPartial = false;
+      this.usedLocals = {};
+
+      for (var local of locals) {
+        this.usedLocals[local] = false;
+      }
+    }
+
+    child(node) {
+      var locals = getLocals(node);
+      return locals ? new ChildTransformScope(locals, this) : this;
+    }
+
+    usePartial() {
+      this.hasPartial = true;
+    }
+
+  }
+
+  class RootTransformScope extends TransformScope {
+    constructor(node) {
+      var _a;
+
+      var locals = (_a = getLocals(node)) !== null && _a !== void 0 ? _a : [];
+      super(locals);
+    }
+
+    useLocal(node) {
+      var name = getLocalName(node);
+
+      if (name && name in this.usedLocals) {
+        this.usedLocals[name] = true;
+      }
+    }
+
+    isLocal(name) {
+      return this.locals.indexOf(name) !== -1;
+    }
+
+    currentUnusedLocals() {
+      if (!this.hasPartial && this.locals.length > 0) {
+        return this.locals.filter(local => !this.usedLocals[local]);
+      }
+
+      return false;
+    }
+
+  }
+
+  class ChildTransformScope extends TransformScope {
+    constructor(locals, parent) {
+      super(locals);
+      this.parent = parent;
+    }
+
+    useLocal(node) {
+      var name = getLocalName(node);
+
+      if (name && name in this.usedLocals) {
+        this.usedLocals[name] = true;
+      } else {
+        this.parent.useLocal(node);
+      }
+    }
+
+    isLocal(name) {
+      return this.locals.indexOf(name) !== -1 || this.parent.isLocal(name);
+    }
+
+    currentUnusedLocals() {
+      if (!this.hasPartial && this.locals.length > 0) {
+        // We only care about the last local, because if it is used then it implies
+        // usage of the others (specifically when in a child block, |foo bar|)
+        if (!this.usedLocals[this.locals[this.locals.length - 1]]) {
+          return [this.locals[this.locals.length - 1]];
+        }
+      }
+
+      return false;
+    }
+
+  }
+
   class WalkerPath {
     constructor(node, parent = null, parentKey = null) {
       this.node = node;
       this.parent = parent;
       this.parentKey = parentKey;
+      this.scope = parent ? parent.scope.child(node) : new RootTransformScope(node); // Consume in scope values
+
+      if (node.type === 'PathExpression') {
+        this.scope.useLocal(node);
+      }
+
+      if (node.type === 'ElementNode') {
+        this.scope.useLocal(node);
+        node.children.forEach(node => this.scope.useLocal(node));
+      }
     }
 
     get parentNode() {
@@ -10297,10 +10618,10 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     if (result === undefined) {
-      var keys = visitorKeys[node.type];
+      var _keys = visitorKeys[node.type];
 
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i]; // we know if it has child keys we can widen to a ParentNode
+      for (var i = 0; i < _keys.length; i++) {
+        var key = _keys[i]; // we know if it has child keys we can widen to a ParentNode
 
         visitKey(visitor, handler, path, key);
       }
@@ -11930,6 +12251,25 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     return program;
   }
 
+  var __classPrivateFieldSet$4 = undefined && undefined.__classPrivateFieldSet || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+
+    privateMap.set(receiver, value);
+    return value;
+  };
+
+  var __classPrivateFieldGet$4 = undefined && undefined.__classPrivateFieldGet || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+
+    return privateMap.get(receiver);
+  };
+
+  var _hasEval;
+
   class SymbolTable {
     static top(locals, customizeComponentName) {
       return new ProgramSymbolTable(locals, customizeComponentName);
@@ -11955,7 +12295,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.named = (0, _util.dict)();
       this.blocks = (0, _util.dict)();
       this.usedTemplateLocals = [];
-      this._hasEval = false;
+
+      _hasEval.set(this, false);
     }
 
     getUsedTemplateLocals() {
@@ -11963,11 +12304,11 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
 
     setHasEval() {
-      this._hasEval = true;
+      __classPrivateFieldSet$4(this, _hasEval, true);
     }
 
     get hasEval() {
-      return this._hasEval;
+      return __classPrivateFieldGet$4(this, _hasEval);
     }
 
     has(name) {
@@ -12047,6 +12388,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
   }
 
   _exports.ProgramSymbolTable = ProgramSymbolTable;
+  _hasEval = new WeakMap();
 
   class BlockSymbolTable extends SymbolTable {
     constructor(parent, symbols, slots) {
@@ -18725,7 +19067,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "4.0.0-beta.6";
+  var _default = "4.1.0-alpha.5";
   _exports.default = _default;
 });
 define("simple-html-tokenizer", ["exports"], function (_exports) {