ember-source 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/packages/@ember/-internals/metal/index.js

@@ -1,14 +1,14 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, setWithMandatorySetter, Cache, setProxy, lookupDescriptor, getName, setName } from '@ember/-internals/utils';
-import { assert, inspect, deprecate, debug, warn } from '@ember/debug';
-import { ENV, context } from '@ember/-internals/environment';
-import { schedule } from '@ember/runloop';
+import { setListeners, symbol, setupMandatorySetter, isObject, toString, setWithMandatorySetter, Cache, setProxy, lookupDescriptor, getName, setName } from '@ember/-internals/utils';
+import { assert, inspect, deprecate, warn, debug } from '@ember/debug';
 import { registerDestructor, isDestroyed } from '@glimmer/destroyable';
-import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag, CONSTANT_TAG, dirtyTagFor, tagFor, combine, createUpdatableTag, updateTag, ALLOW_CYCLES, consumeTag, track, untrack, isTracking, trackedData, createCache, getValue } from '@glimmer/validator';
-export { createCache, getValue, isConst } from '@glimmer/validator';
 import { DEBUG } from '@glimmer/env';
-import { getCustomTagFor } from '@glimmer/manager';
+import { tagMetaFor, valueForTag, CURRENT_TAG, validateTag, tagFor, CONSTANT_TAG, dirtyTagFor, combine, createUpdatableTag, updateTag, untrack, ALLOW_CYCLES, consumeTag, track, isTracking, trackedData, createCache, getValue } from '@glimmer/validator';
+export { createCache, getValue, isConst } from '@glimmer/validator';
 import { _WeakSet } from '@glimmer/util';
+import { ENV, context } from '@ember/-internals/environment';
+import { schedule } from '@ember/runloop';
+import { getCustomTagFor } from '@glimmer/manager';
 import { isEmberArray } from '@ember/array/-internals';
 import VERSION from 'ember/version';
 import { getOwner } from '@ember/-internals/owner';
@@ -95,8 +95,8 @@ function removeListener(obj, eventName, targetOrFunction, functionOrName) {
 */
 function sendEvent(obj, eventName, params, actions, _meta) {
   if (actions === undefined) {
-    let meta$$1 = _meta === undefined ? peekMeta(obj) : _meta;
-    actions = meta$$1 !== null ? meta$$1.matchingListeners(eventName) : undefined;
+    let meta = _meta === undefined ? peekMeta(obj) : _meta;
+    actions = meta !== null ? meta.matchingListeners(eventName) : undefined;
   }
   if (actions === undefined || actions.length === 0) {
     return false;
@@ -133,11 +133,11 @@ function sendEvent(obj, eventName, params, actions, _meta) {
   @return {Boolean} if `obj` has listeners for event `eventName`
 */
 function hasListeners(obj, eventName) {
-  let meta$$1 = peekMeta(obj);
-  if (meta$$1 === null) {
+  let meta = peekMeta(obj);
+  if (meta === null) {
     return false;
   }
-  let matched = meta$$1.matchingListeners(eventName);
+  let matched = meta.matchingListeners(eventName);
   return matched !== undefined && matched.length > 0;
 }
 /**
@@ -201,8 +201,8 @@ const ASYNC_OBSERVERS = new Map();
 function addObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
   let eventName = changeEvent(path);
   addListener(obj, eventName, target, method, false, sync);
-  let meta$$1 = peekMeta(obj);
-  if (meta$$1 === null || !(meta$$1.isPrototypeMeta(obj) || meta$$1.isInitializing())) {
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
     activateObserver(obj, eventName, sync);
   }
 }
@@ -218,8 +218,8 @@ function addObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
 */
 function removeObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
   let eventName = changeEvent(path);
-  let meta$$1 = peekMeta(obj);
-  if (meta$$1 === null || !(meta$$1.isPrototypeMeta(obj) || meta$$1.isInitializing())) {
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
     deactivateObserver(obj, eventName, sync);
   }
   removeListener(obj, eventName, target, method);
@@ -307,12 +307,12 @@ function flushAsyncObservers(shouldSchedule = true) {
   }
   lastKnownRevision = currentRevision;
   ASYNC_OBSERVERS.forEach((activeObservers, target) => {
-    let meta$$1 = peekMeta(target);
+    let meta = peekMeta(target);
     activeObservers.forEach((observer, eventName) => {
       if (!validateTag(observer.tag, observer.lastRevision)) {
         let sendObserver = () => {
           try {
-            sendEvent(target, eventName, [target, observer.path], undefined, meta$$1);
+            sendEvent(target, eventName, [target, observer.path], undefined, meta);
           } finally {
             observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
             observer.lastRevision = valueForTag(observer.tag);
@@ -332,12 +332,12 @@ function flushSyncObservers() {
   // only do this during a notifyPropertyChange), so there's no reason to check
   // a global revision.
   SYNC_OBSERVERS.forEach((activeObservers, target) => {
-    let meta$$1 = peekMeta(target);
+    let meta = peekMeta(target);
     activeObservers.forEach((observer, eventName) => {
       if (!observer.suspended && !validateTag(observer.tag, observer.lastRevision)) {
         try {
           observer.suspended = true;
-          sendEvent(target, eventName, [target, observer.path], undefined, meta$$1);
+          sendEvent(target, eventName, [target, observer.path], undefined, meta);
         } finally {
           observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
           observer.lastRevision = valueForTag(observer.tag);
@@ -364,12 +364,12 @@ function destroyObservers(target) {
 
 // This is exported for `@tracked`, but should otherwise be avoided. Use `tagForObject`.
 const SELF_TAG = symbol('SELF_TAG');
-function tagForProperty(obj, propertyKey, addMandatorySetter = false, meta$$1) {
+function tagForProperty(obj, propertyKey, addMandatorySetter = false, meta) {
   let customTagFor = getCustomTagFor(obj);
   if (customTagFor !== undefined) {
     return customTagFor(obj, propertyKey, addMandatorySetter);
   }
-  let tag = tagFor(obj, propertyKey, meta$$1);
+  let tag = tagFor(obj, propertyKey, meta);
   if (DEBUG && addMandatorySetter) {
     setupMandatorySetter(tag, obj, propertyKey);
   }
@@ -417,8 +417,8 @@ let deferred = 0;
   @public
 */
 function notifyPropertyChange(obj, keyName, _meta, value) {
-  let meta$$1 = _meta === undefined ? peekMeta(obj) : _meta;
-  if (meta$$1 !== null && (meta$$1.isInitializing() || meta$$1.isPrototypeMeta(obj))) {
+  let meta = _meta === undefined ? peekMeta(obj) : _meta;
+  if (meta !== null && (meta.isInitializing() || meta.isPrototypeMeta(obj))) {
     return;
   }
   markObjectAsDirty(obj, keyName);
@@ -511,29 +511,29 @@ function arrayContentDidChange(array, startIdx, removeAmt, addAmt, notify = true
       addAmt = -1;
     }
   }
-  let meta$$1 = peekMeta(array);
+  let meta = peekMeta(array);
   if (notify) {
     if (addAmt < 0 || removeAmt < 0 || addAmt - removeAmt !== 0) {
-      notifyPropertyChange(array, 'length', meta$$1);
+      notifyPropertyChange(array, 'length', meta);
     }
-    notifyPropertyChange(array, '[]', meta$$1);
+    notifyPropertyChange(array, '[]', meta);
   }
   sendEvent(array, '@array:change', [array, startIdx, removeAmt, addAmt]);
-  if (meta$$1 !== null) {
+  if (meta !== null) {
     let length = array.length;
     let addedAmount = addAmt === -1 ? 0 : addAmt;
     let removedAmount = removeAmt === -1 ? 0 : removeAmt;
     let delta = addedAmount - removedAmount;
     let previousLength = length - delta;
     let normalStartIdx = startIdx < 0 ? previousLength + startIdx : startIdx;
-    if (meta$$1.revisionFor('firstObject') !== undefined && normalStartIdx === 0) {
-      notifyPropertyChange(array, 'firstObject', meta$$1);
+    if (meta.revisionFor('firstObject') !== undefined && normalStartIdx === 0) {
+      notifyPropertyChange(array, 'firstObject', meta);
     }
-    if (meta$$1.revisionFor('lastObject') !== undefined) {
+    if (meta.revisionFor('lastObject') !== undefined) {
       let previousLastIndex = previousLength - 1;
       let lastAffectedIndex = normalStartIdx + removedAmount;
       if (previousLastIndex < lastAffectedIndex) {
-        notifyPropertyChange(array, 'lastObject', meta$$1);
+        notifyPropertyChange(array, 'lastObject', meta);
       }
     }
   }
@@ -578,7 +578,6 @@ function replaceInNativeArray(array, start, deleteCount, items) {
   arrayContentDidChange(array, start, deleteCount, items.length);
 }
 function arrayObserversHelper(obj, target, opts, operation) {
-  var _a;
   let {
     willChange,
     didChange
@@ -589,7 +588,7 @@ function arrayObserversHelper(obj, target, opts, operation) {
    * Array proxies have a `_revalidate` method which must be called to set
    * up their internal array observation systems.
    */
-  (_a = obj._revalidate) === null || _a === void 0 ? void 0 : _a.call(obj);
+  obj._revalidate?.();
   return obj;
 }
 function addArrayObserver(array, target, opts) {
@@ -600,8 +599,8 @@ function removeArrayObserver(array, target, opts) {
 }
 
 const CHAIN_PASS_THROUGH = new _WeakSet();
-function finishLazyChains(meta$$1, key, value) {
-  let lazyTags = meta$$1.readableLazyChainsFor(key);
+function finishLazyChains(meta, key, value) {
+  let lazyTags = meta.readableLazyChainsFor(key);
   if (lazyTags === undefined) {
     return;
   }
@@ -612,20 +611,20 @@ function finishLazyChains(meta$$1, key, value) {
   }
   lazyTags.length = 0;
 }
-function getChainTagsForKeys(obj, keys, tagMeta, meta$$1) {
+function getChainTagsForKeys(obj, keys, tagMeta, meta) {
   let tags = [];
   for (let key of keys) {
-    getChainTags(tags, obj, key, tagMeta, meta$$1);
+    getChainTags(tags, obj, key, tagMeta, meta);
   }
   return combine(tags);
 }
-function getChainTagsForKey(obj, key, tagMeta, meta$$1) {
-  return combine(getChainTags([], obj, key, tagMeta, meta$$1));
+function getChainTagsForKey(obj, key, tagMeta, meta) {
+  return combine(getChainTags([], obj, key, tagMeta, meta));
 }
-function getChainTags(chainTags, obj, path, tagMeta, meta$$1) {
+function getChainTags(chainTags, obj, path, tagMeta, meta$1) {
   let current = obj;
   let currentTagMeta = tagMeta;
-  let currentMeta = meta$$1;
+  let currentMeta = meta$1;
   let pathLength = path.length;
   let segmentEnd = -1;
   // prevent closures
@@ -767,11 +766,11 @@ class ComputedDescriptor {
     this._dependentKeys = undefined;
     this._meta = undefined;
   }
-  setup(_obj, keyName, _propertyDesc, meta$$1) {
-    meta$$1.writeDescriptors(keyName, this);
+  setup(_obj, keyName, _propertyDesc, meta) {
+    meta.writeDescriptors(keyName, this);
   }
-  teardown(_obj, keyName, meta$$1) {
-    meta$$1.removeDescriptors(keyName);
+  teardown(_obj, keyName, meta) {
+    meta.removeDescriptors(keyName);
   }
 }
 let COMPUTED_GETTERS;
@@ -798,8 +797,8 @@ const COMPUTED_SETTERS = new _WeakSet();
 function makeComputedDecorator(desc, DecoratorClass) {
   let decorator = function COMPUTED_DECORATOR(target, key, propertyDesc, maybeMeta, isClassicDecorator) {
     assert(`Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`, isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get));
-    let meta$$1 = arguments.length === 3 ? meta(target) : maybeMeta;
-    desc.setup(target, key, propertyDesc, meta$$1);
+    let meta$1 = arguments.length === 3 ? meta(target) : maybeMeta;
+    desc.setup(target, key, propertyDesc, meta$1);
     let computedDesc = {
       enumerable: desc.enumerable,
       configurable: desc.configurable,
@@ -827,9 +826,9 @@ function descriptorForProperty(obj, keyName, _meta) {
   assert('Cannot call `descriptorForProperty` on null', obj !== null);
   assert('Cannot call `descriptorForProperty` on undefined', obj !== undefined);
   assert(`Cannot call \`descriptorForProperty\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function');
-  let meta$$1 = _meta === undefined ? peekMeta(obj) : _meta;
-  if (meta$$1 !== null) {
-    return meta$$1.peekDescriptors(keyName);
+  let meta = _meta === undefined ? peekMeta(obj) : _meta;
+  if (meta !== null) {
+    return meta.peekDescriptors(keyName);
   }
 }
 function descriptorForDecorator(dec) {
@@ -1150,8 +1149,8 @@ class ComputedProperty extends ComputedDescriptor {
       this._property(...args);
     }
   }
-  setup(obj, keyName, propertyDesc, meta$$1) {
-    super.setup(obj, keyName, propertyDesc, meta$$1);
+  setup(obj, keyName, propertyDesc, meta) {
+    super.setup(obj, keyName, propertyDesc, meta);
     assert(`@computed can only be used on accessors or fields, attempted to use it with ${keyName} but that was a method. Try converting it to a getter (e.g. \`get ${keyName}() {}\`)`, !(propertyDesc && typeof propertyDesc.value === 'function'));
     assert(`@computed can only be used on empty fields. ${keyName} has an initial value (e.g. \`${keyName} = someValue\`)`, !propertyDesc || !propertyDesc.initializer);
     assert(`Attempted to apply a computed property that already has a getter/setter to a ${keyName}, but it is a method or an accessor. If you passed @computed a function or getter/setter (e.g. \`@computed({ get() { ... } })\`), then it must be applied to a field`, !(this._hasConfig && propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')));
@@ -1187,13 +1186,13 @@ class ComputedProperty extends ComputedDescriptor {
     this._dependentKeys = args;
   }
   get(obj, keyName) {
-    let meta$$1 = meta(obj);
+    let meta$1 = meta(obj);
     let tagMeta = tagMetaFor(obj);
     let propertyTag = tagFor(obj, keyName, tagMeta);
     let ret;
-    let revision = meta$$1.revisionFor(keyName);
+    let revision = meta$1.revisionFor(keyName);
     if (revision !== undefined && validateTag(propertyTag, revision)) {
-      ret = meta$$1.valueFor(keyName);
+      ret = meta$1.valueFor(keyName);
     } else {
       // For backwards compatibility, we only throw if the CP has any dependencies. CPs without dependencies
       // should be allowed, even after the object has been destroyed, which is why we check _dependentKeys.
@@ -1207,14 +1206,14 @@ class ComputedProperty extends ComputedDescriptor {
         ret = _getter.call(obj, keyName);
       });
       if (_dependentKeys !== undefined) {
-        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
+        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$1));
         if (DEBUG) {
           ALLOW_CYCLES.set(propertyTag, true);
         }
       }
-      meta$$1.setValueFor(keyName, ret);
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-      finishLazyChains(meta$$1, keyName, ret);
+      meta$1.setValueFor(keyName, ret);
+      meta$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$1, keyName, ret);
     }
     consumeTag(propertyTag);
     // Add the tag of the returned value if it is an array, since arrays
@@ -1229,7 +1228,7 @@ class ComputedProperty extends ComputedDescriptor {
       this._throwReadOnlyError(obj, keyName);
     }
     assert(`Cannot override the computed property \`${keyName}\` on ${toString(obj)}.`, this._setter !== undefined);
-    let meta$$1 = meta(obj);
+    let meta$1 = meta(obj);
     // ensure two way binding works when the component has defined a computed
     // property with both a setter and dependent keys, in that scenario without
     // the sync observer added below the caller's value will never be updated
@@ -1237,7 +1236,7 @@ class ComputedProperty extends ComputedDescriptor {
     // See GH#18147 / GH#19028 for details.
     if (
     // ensure that we only run this once, while the component is being instantiated
-    meta$$1.isInitializing() && this._dependentKeys !== undefined && this._dependentKeys.length > 0 && typeof obj[PROPERTY_DID_CHANGE] === 'function' && obj.isComponent) {
+    meta$1.isInitializing() && this._dependentKeys !== undefined && this._dependentKeys.length > 0 && typeof obj[PROPERTY_DID_CHANGE] === 'function' && obj.isComponent) {
       // It's redundant to do this here, but we don't want to check above so we can avoid an extra function call in prod.
       assert('property did change hook is invalid', hasPropertyDidChange(obj));
       addObserver(obj, keyName, () => {
@@ -1247,20 +1246,20 @@ class ComputedProperty extends ComputedDescriptor {
     let ret;
     try {
       beginPropertyChanges();
-      ret = this._set(obj, keyName, value, meta$$1);
-      finishLazyChains(meta$$1, keyName, ret);
+      ret = this._set(obj, keyName, value, meta$1);
+      finishLazyChains(meta$1, keyName, ret);
       let tagMeta = tagMetaFor(obj);
       let propertyTag = tagFor(obj, keyName, tagMeta);
       let {
         _dependentKeys
       } = this;
       if (_dependentKeys !== undefined) {
-        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
+        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$1));
         if (DEBUG) {
           ALLOW_CYCLES.set(propertyTag, true);
         }
       }
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      meta$1.setRevisionFor(keyName, valueForTag(propertyTag));
     } finally {
       endPropertyChanges();
     }
@@ -1269,9 +1268,9 @@ class ComputedProperty extends ComputedDescriptor {
   _throwReadOnlyError(obj, keyName) {
     throw new Error(`Cannot set read-only property "${keyName}" on object: ${inspect(obj)}`);
   }
-  _set(obj, keyName, value, meta$$1) {
-    let hadCachedValue = meta$$1.revisionFor(keyName) !== undefined;
-    let cachedValue = meta$$1.valueFor(keyName);
+  _set(obj, keyName, value, meta) {
+    let hadCachedValue = meta.revisionFor(keyName) !== undefined;
+    let cachedValue = meta.valueFor(keyName);
     let ret;
     let {
       _setter
@@ -1286,28 +1285,28 @@ class ComputedProperty extends ComputedDescriptor {
     if (hadCachedValue && cachedValue === ret) {
       return ret;
     }
-    meta$$1.setValueFor(keyName, ret);
-    notifyPropertyChange(obj, keyName, meta$$1, value);
+    meta.setValueFor(keyName, ret);
+    notifyPropertyChange(obj, keyName, meta, value);
     return ret;
   }
   /* called before property is overridden */
-  teardown(obj, keyName, meta$$1) {
-    if (meta$$1.revisionFor(keyName) !== undefined) {
-      meta$$1.setRevisionFor(keyName, undefined);
-      meta$$1.setValueFor(keyName, undefined);
+  teardown(obj, keyName, meta) {
+    if (meta.revisionFor(keyName) !== undefined) {
+      meta.setRevisionFor(keyName, undefined);
+      meta.setValueFor(keyName, undefined);
     }
-    super.teardown(obj, keyName, meta$$1);
+    super.teardown(obj, keyName, meta);
   }
 }
 class AutoComputedProperty extends ComputedProperty {
   get(obj, keyName) {
-    let meta$$1 = meta(obj);
+    let meta$1 = meta(obj);
     let tagMeta = tagMetaFor(obj);
     let propertyTag = tagFor(obj, keyName, tagMeta);
     let ret;
-    let revision = meta$$1.revisionFor(keyName);
+    let revision = meta$1.revisionFor(keyName);
     if (revision !== undefined && validateTag(propertyTag, revision)) {
-      ret = meta$$1.valueFor(keyName);
+      ret = meta$1.valueFor(keyName);
     } else {
       assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, !isDestroyed(obj));
       let {
@@ -1318,9 +1317,9 @@ class AutoComputedProperty extends ComputedProperty {
         ret = _getter.call(obj, keyName);
       });
       updateTag(propertyTag, tag);
-      meta$$1.setValueFor(keyName, ret);
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-      finishLazyChains(meta$$1, keyName, ret);
+      meta$1.setValueFor(keyName, ret);
+      meta$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$1, keyName, ret);
     }
     consumeTag(propertyTag);
     // Add the tag of the returned value if it is an array, since arrays
@@ -1408,12 +1407,12 @@ class ComputedDecoratorImpl extends Function {
     @chainable
     @public
   */
-  meta(meta$$1) {
+  meta(meta) {
     let prop = descriptorForDecorator(this);
     if (arguments.length === 0) {
       return prop._meta || {};
     } else {
-      prop._meta = meta$$1;
+      prop._meta = meta;
       return this;
     }
   }
@@ -1461,9 +1460,9 @@ function isComputed(obj, key) {
 }
 
 function getCachedValueFor(obj, key) {
-  let meta$$1 = peekMeta(obj);
-  if (meta$$1) {
-    return meta$$1.valueFor(key);
+  let meta = peekMeta(obj);
+  if (meta) {
+    return meta.valueFor(key);
   } else {
     return undefined;
   }
@@ -1521,14 +1520,14 @@ function getCachedValueFor(obj, key) {
     become the explicit value of this property.
 */
 function defineProperty(obj, keyName, desc, data, _meta) {
-  let meta$$1 = _meta === undefined ? meta(obj) : _meta;
-  let previousDesc = descriptorForProperty(obj, keyName, meta$$1);
+  let meta$1 = _meta === undefined ? meta(obj) : _meta;
+  let previousDesc = descriptorForProperty(obj, keyName, meta$1);
   let wasDescriptor = previousDesc !== undefined;
   if (wasDescriptor) {
-    previousDesc.teardown(obj, keyName, meta$$1);
+    previousDesc.teardown(obj, keyName, meta$1);
   }
   if (isClassicDecorator(desc)) {
-    defineDecorator(obj, keyName, desc, meta$$1);
+    defineDecorator(obj, keyName, desc, meta$1);
   } else if (desc === null || desc === undefined) {
     defineValue(obj, keyName, data, wasDescriptor, true);
   } else {
@@ -1537,16 +1536,16 @@ function defineProperty(obj, keyName, desc, data, _meta) {
   }
   // if key is being watched, override chains that
   // were initialized with the prototype
-  if (!meta$$1.isPrototypeMeta(obj)) {
+  if (!meta$1.isPrototypeMeta(obj)) {
     revalidateObservers(obj);
   }
 }
-function defineDecorator(obj, keyName, desc, meta$$1) {
+function defineDecorator(obj, keyName, desc, meta) {
   let propertyDesc;
   if (DEBUG) {
-    propertyDesc = desc(obj, keyName, undefined, meta$$1, true);
+    propertyDesc = desc(obj, keyName, undefined, meta, true);
   } else {
-    propertyDesc = desc(obj, keyName, undefined, meta$$1);
+    propertyDesc = desc(obj, keyName, undefined, meta);
   }
   Object.defineProperty(obj, keyName, propertyDesc);
   // pass the decorator function forward for backwards compat
@@ -1778,12 +1777,12 @@ class AliasDecoratorImpl extends Function {
     descriptorForDecorator(this).oneWay();
     return this;
   }
-  meta(meta$$1) {
+  meta(meta) {
     let prop = descriptorForDecorator(this);
     if (arguments.length === 0) {
       return prop._meta || {};
     } else {
-      prop._meta = meta$$1;
+      prop._meta = meta;
     }
   }
 }
@@ -1792,14 +1791,14 @@ class AliasedProperty extends ComputedDescriptor {
     super();
     this.altKey = altKey;
   }
-  setup(obj, keyName, propertyDesc, meta$$1) {
+  setup(obj, keyName, propertyDesc, meta) {
     assert(`Setting alias '${keyName}' on self`, this.altKey !== keyName);
-    super.setup(obj, keyName, propertyDesc, meta$$1);
+    super.setup(obj, keyName, propertyDesc, meta);
     CHAIN_PASS_THROUGH.add(this);
   }
   get(obj, keyName) {
     let ret;
-    let meta$$1 = meta(obj);
+    let meta$1 = meta(obj);
     let tagMeta = tagMetaFor(obj);
     let propertyTag = tagFor(obj, keyName, tagMeta);
     // We don't use the tag since CPs are not automatic, we just want to avoid
@@ -1807,11 +1806,11 @@ class AliasedProperty extends ComputedDescriptor {
     untrack(() => {
       ret = get(obj, this.altKey);
     });
-    let lastRevision = meta$$1.revisionFor(keyName);
+    let lastRevision = meta$1.revisionFor(keyName);
     if (lastRevision === undefined || !validateTag(propertyTag, lastRevision)) {
-      updateTag(propertyTag, getChainTagsForKey(obj, this.altKey, tagMeta, meta$$1));
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-      finishLazyChains(meta$$1, keyName, ret);
+      updateTag(propertyTag, getChainTagsForKey(obj, this.altKey, tagMeta, meta$1));
+      meta$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$1, keyName, ret);
     }
     consumeTag(propertyTag);
     return ret;
@@ -2056,8 +2055,8 @@ function tracked(...args) {
     }
     let initializer = propertyDesc ? propertyDesc.initializer : undefined;
     let value = propertyDesc ? propertyDesc.value : undefined;
-    let decorator = function (target, key, _desc, _meta, isClassicDecorator$$1) {
-      assert(`You attempted to set a default value for ${key} with the @tracked({ value: 'default' }) syntax. You can only use this syntax with classic classes. For native classes, you can use class initializers: @tracked field = 'default';`, isClassicDecorator$$1);
+    let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
+      assert(`You attempted to set a default value for ${key} with the @tracked({ value: 'default' }) syntax. You can only use this syntax with classic classes. For native classes, you can use class initializers: @tracked field = 'default';`, isClassicDecorator);
       let fieldDesc = {
         initializer: initializer || (() => value)
       };
@@ -2148,125 +2147,6 @@ function throwCachedInvalidArgsError(args = []) {
   throw new Error(`You attempted to use @cached on with ${args.length > 1 ? 'arguments' : 'an argument'} ( @cached(${args.map(d => `'${d}'`).join(', ')}), which is not supported. Dependencies are automatically tracked, so you can just use ${'`@cached`'}`);
 }
 
-/**
-  Ember uses caching based on trackable values to avoid updating large portions
-  of the application. This caching is exposed via a cache primitive that can be
-  used to cache a specific computation, so that it will not update and will
-  return the cached value until a tracked value used in its computation has
-  updated.
-
-  @module @glimmer/tracking/primitives/cache
-  @public
-*/
-/**
-  Receives a function, and returns a wrapped version of it that memoizes based on
-  _autotracking_. The function will only rerun whenever any tracked values used
-  within it have changed. Otherwise, it will return the previous value.
-
-  ```js
-  import { tracked } from '@glimmer/tracking';
-  import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
-
-  class State {
-    @tracked value;
-  }
-
-  let state = new State();
-  let computeCount = 0;
-
-  let counter = createCache(() => {
-    // consume the state. Now, `counter` will
-    // only rerun if `state.value` changes.
-    state.value;
-
-    return ++computeCount;
-  });
-
-  getValue(counter); // 1
-
-  // returns the same value because no tracked state has changed
-  getValue(counter); // 1
-
-  state.value = 'foo';
-
-  // reruns because a tracked value used in the function has changed,
-  // incermenting the counter
-  getValue(counter); // 2
-  ```
-
-  @method createCache
-  @static
-  @for @glimmer/tracking/primitives/cache
-  @public
-*/
-/**
-  Gets the value of a cache created with `createCache`.
-
-  ```js
-  import { tracked } from '@glimmer/tracking';
-  import { createCache, getValue } from '@glimmer/tracking/primitives/cache';
-
-  let computeCount = 0;
-
-  let counter = createCache(() => {
-    return ++computeCount;
-  });
-
-  getValue(counter); // 1
-  ```
-
-  @method getValue
-  @static
-  @for @glimmer/tracking/primitives/cache
-  @public
-*/
-/**
-  Can be used to check if a memoized function is _constant_. If no tracked state
-  was used while running a memoized function, it will never rerun, because nothing
-  can invalidate its result. `isConst` can be used to determine if a memoized
-  function is constant or not, in order to optimize code surrounding that
-  function.
-
-  ```js
-  import { tracked } from '@glimmer/tracking';
-  import { createCache, getValue, isConst } from '@glimmer/tracking/primitives/cache';
-
-  class State {
-    @tracked value;
-  }
-
-  let state = new State();
-  let computeCount = 0;
-
-  let counter = createCache(() => {
-    // consume the state
-    state.value;
-
-    return computeCount++;
-  });
-
-  let constCounter = createCache(() => {
-    return computeCount++;
-  });
-
-  getValue(counter);
-  getValue(constCounter);
-
-  isConst(counter); // false
-  isConst(constCounter); // true
-  ```
-
-  If called on a cache that hasn't been accessed yet, it will throw an
-  error. This is because there's no way to know if the function will be constant
-  or not yet, and so this helps prevent missing an optimization opportunity on
-  accident.
-
-  @method isConst
-  @static
-  @for @glimmer/tracking/primitives/cache
-  @public
-*/
-
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 let searchDisabled = false;
 const flags = {
@@ -2396,4 +2276,4 @@ function tryIsNamespace(lookup, prop) {
   }
 }
 
-export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, hasUnknownProperty, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, defineDecorator, defineValue, ComputedDescriptor, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, makeComputedDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, revalidateObservers, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins };
+export { ASYNC_OBSERVERS, ComputedDescriptor, ComputedProperty, DEBUG_INJECTION_FUNCTIONS, Libraries, NAMESPACES, NAMESPACES_BY_ID, PROPERTY_DID_CHANGE, PROXY_CONTENT, SYNC_OBSERVERS, TrackedDescriptor, _getPath, _getProp, _setProp, activateObserver, addArrayObserver, addListener, addNamespace, addObserver, alias, arrayContentDidChange, arrayContentWillChange, autoComputed, beginPropertyChanges, cached, changeProperties, computed, defineDecorator, defineProperty, defineValue, deprecateProperty, descriptorForDecorator, descriptorForProperty, eachProxyArrayDidChange, eachProxyArrayWillChange, endPropertyChanges, expandProperties, findNamespace, findNamespaces, flushAsyncObservers, get, getCachedValueFor, getProperties, hasListeners, hasUnknownProperty, inject, isClassicDecorator, isComputed, isElementDescriptor, isSearchDisabled as isNamespaceSearchDisabled, LIBRARIES as libraries, makeComputedDecorator, markObjectAsDirty, nativeDescDecorator, notifyPropertyChange, objectAt, on, processAllNamespaces, processNamespace, removeArrayObserver, removeListener, removeNamespace, removeObserver, replace, replaceInNativeArray, revalidateObservers, sendEvent, set, setClassicDecorator, setSearchDisabled as setNamespaceSearchDisabled, setProperties, setUnprocessedMixins, tagForObject, tagForProperty, tracked, trySet };