ember-source 6.12.0 → 7.0.0-beta.1

package/dist/{packages → dev/packages}/@ember/object/lib/computed/reduce_computed_macros.js

@@ -1,15 +1,14 @@
 import '../../../debug/index.js';
-import { i as isElementDescriptor, g as get, c as computed, R as autoComputed } from '../../../../shared-chunks/observers-DhgQ6ba5.js';
+import { i as isElementDescriptor, g as get, c as computed, R as autoComputed } from '../../../../shared-chunks/observers-Bj9qLVau.js';
 import '../../../-internals/meta/lib/meta.js';
 import '../../../../@glimmer/validator/index.js';
-import '../../../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import { isDevelopingApp } from '@embroider/macros';
+import '../../../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import '../../../../@glimmer/destroyable/index.js';
-import '../../../../shared-chunks/debug-to-string-BsFOvUtQ.js';
+import '../../../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import '../../../../@glimmer/global-context/index.js';
-import '../../../../shared-chunks/reference-B6HMX4y0.js';
-import '../../../../shared-chunks/capabilities-DHiXCCuB.js';
-import '../../../../shared-chunks/env-DEd6hPbj.js';
+import '../../../../shared-chunks/reference-C3TKDRnP.js';
+import '../../../../shared-chunks/capabilities-O_xc7Yqk.js';
+import '../../../-internals/environment/index.js';
 import '../../index.js';
 import '../../core.js';
 import compare from '../../../utils/lib/compare.js';
@@ -24,7 +23,7 @@ function isNativeOrEmberArray(obj) {
   return Array.isArray(obj) || EmberArray.detect(obj);
 }
 function reduceMacro(dependentKey, callback, initialValue, name) {
-  (isDevelopingApp() && !(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
+  (!(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
   return computed(`${dependentKey}.[]`, function () {
     let arr = get(this, dependentKey);
     if (arr === null || typeof arr !== 'object') {
@@ -52,7 +51,7 @@ function arrayMacro(dependentKey, additionalDependentKeys, callback) {
   }).readOnly();
 }
 function multiArrayMacro(_dependentKeys, callback, name) {
-  (isDevelopingApp() && !(_dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey))) && assert(`Dependent keys passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, _dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey))));
+  (!(_dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey))) && assert(`Dependent keys passed to \`${name}\` computed macro shouldn't contain brace expanding pattern.`, _dependentKeys.every(dependentKey => !/[[\]{}]/g.test(dependentKey))));
   let dependentKeys = _dependentKeys.map(key => `${key}.[]`);
   return computed(...dependentKeys, function () {
     return A(callback.call(this, _dependentKeys));
@@ -88,7 +87,7 @@ function multiArrayMacro(_dependentKeys, callback, name) {
   @public
 */
 function sum(dependentKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @sum as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @sum as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   return reduceMacro(dependentKey, (sum, item) => sum + item, 0, 'sum');
 }
 
@@ -148,7 +147,7 @@ function sum(dependentKey) {
   @public
 */
 function max(dependentKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @max as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @max as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   return reduceMacro(dependentKey, (max, item) => Math.max(max, item), -Infinity, 'max');
 }
 
@@ -207,7 +206,7 @@ function max(dependentKey) {
   @public
 */
 function min(dependentKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @min as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @min as a decorator directly, but it requires a `dependentKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   return reduceMacro(dependentKey, (min, item) => Math.min(min, item), Infinity, 'min');
 }
 
@@ -288,9 +287,9 @@ function min(dependentKey) {
 */
 
 function map(dependentKey, additionalDependentKeysOrCallback, callback) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @map as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && assert('The final parameter provided to map must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
-  (isDevelopingApp() && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && assert('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @map as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && assert('The final parameter provided to map must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+  (!(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && assert('The second parameter provided to map must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
   let additionalDependentKeys;
   if (typeof additionalDependentKeysOrCallback === 'function') {
     callback = additionalDependentKeysOrCallback;
@@ -299,7 +298,7 @@ function map(dependentKey, additionalDependentKeysOrCallback, callback) {
     additionalDependentKeys = additionalDependentKeysOrCallback;
   }
   const cCallback = callback;
-  (isDevelopingApp() && !(cCallback) && assert('[BUG] Missing callback', cCallback));
+  (!(cCallback) && assert('[BUG] Missing callback', cCallback));
   return arrayMacro(dependentKey, additionalDependentKeys, function (value) {
     // This is so dumb...
     return Array.isArray(value) ? value.map(cCallback, this) : value.map(cCallback, this);
@@ -355,9 +354,9 @@ function map(dependentKey, additionalDependentKeysOrCallback, callback) {
   @public
 */
 function mapBy(dependentKey, propertyKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @mapBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(typeof propertyKey === 'string') && assert('`mapBy` computed macro expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string'));
-  (isDevelopingApp() && !(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`mapBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @mapBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(typeof propertyKey === 'string') && assert('`mapBy` computed macro expects a property string for its second argument, ' + 'perhaps you meant to use "map"', typeof propertyKey === 'string'));
+  (!(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`mapBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
   return map(`${dependentKey}.@each.${propertyKey}`, item => get(item, propertyKey));
 }
 
@@ -471,9 +470,9 @@ function mapBy(dependentKey, propertyKey) {
 */
 
 function filter(dependentKey, additionalDependentKeysOrCallback, callback) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @filter as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && assert('The final parameter provided to filter must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
-  (isDevelopingApp() && !(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && assert('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @filter as a decorator directly, but it requires atleast `dependentKey` and `callback` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function') && assert('The final parameter provided to filter must be a callback function', typeof callback === 'function' || callback === undefined && typeof additionalDependentKeysOrCallback === 'function'));
+  (!(Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function') && assert('The second parameter provided to filter must either be the callback or an array of additional dependent keys', Array.isArray(additionalDependentKeysOrCallback) || typeof additionalDependentKeysOrCallback === 'function'));
   let additionalDependentKeys;
   if (typeof additionalDependentKeysOrCallback === 'function') {
     callback = additionalDependentKeysOrCallback;
@@ -524,8 +523,8 @@ function filter(dependentKey, additionalDependentKeysOrCallback, callback) {
   @public
 */
 function filterBy(dependentKey, propertyKey, value) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @filterBy as a decorator directly, but it requires atleast `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`filterBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @filterBy as a decorator directly, but it requires atleast `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`filterBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
   let callback;
   if (arguments.length === 2) {
     callback = item => get(item, propertyKey);
@@ -572,7 +571,7 @@ function filterBy(dependentKey, propertyKey, value) {
   @public
 */
 function uniq(dependentKey, ...additionalDependentKeys) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @uniq/@union as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @uniq/@union as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   let args = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(args, function (dependentKeys) {
     let uniq = A();
@@ -630,8 +629,8 @@ function uniq(dependentKey, ...additionalDependentKeys) {
   @public
 */
 function uniqBy(dependentKey, propertyKey) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @uniqBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`uniqBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @uniqBy as a decorator directly, but it requires `dependentKey` and `propertyKey` parameters', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!/[[\]{}]/g.test(dependentKey)) && assert(`Dependent key passed to \`uniqBy\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(dependentKey)));
   return computed(`${dependentKey}.[]`, function () {
     let list = get(this, dependentKey);
     return isNativeOrEmberArray(list) ? uniqBy$1(list, propertyKey) : A();
@@ -721,7 +720,7 @@ let union = uniq;
   @public
 */
 function intersect(dependentKey, ...additionalDependentKeys) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @intersect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @intersect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   let args = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(args, function (dependentKeys) {
     let arrays = dependentKeys.map(dependentKey => {
@@ -729,7 +728,7 @@ function intersect(dependentKey, ...additionalDependentKeys) {
       return Array.isArray(array) ? array : [];
     });
     let firstArray = arrays.pop();
-    (isDevelopingApp() && !(firstArray) && assert('Attempted to apply multiArrayMacro for intersect without any dependentKeys', firstArray));
+    (!(firstArray) && assert('Attempted to apply multiArrayMacro for intersect without any dependentKeys', firstArray));
     let results = firstArray.filter(candidate => {
       for (let array of arrays) {
         let found = false;
@@ -793,9 +792,9 @@ function intersect(dependentKey, ...additionalDependentKeys) {
   @public
 */
 function setDiff(setAProperty, setBProperty) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @setDiff as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  (isDevelopingApp() && !(arguments.length === 2) && assert('`setDiff` computed macro requires exactly two dependent arrays.', arguments.length === 2));
-  (isDevelopingApp() && !(!/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty)) && assert(`Dependent keys passed to \`setDiff\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty)));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @setDiff as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(arguments.length === 2) && assert('`setDiff` computed macro requires exactly two dependent arrays.', arguments.length === 2));
+  (!(!/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty)) && assert(`Dependent keys passed to \`setDiff\` computed macro shouldn't contain brace expanding pattern.`, !/[[\]{}]/g.test(setAProperty) && !/[[\]{}]/g.test(setBProperty)));
   return computed(`${setAProperty}.[]`, `${setBProperty}.[]`, function () {
     let setA = get(this, setAProperty);
     let setB = get(this, setBProperty);
@@ -841,7 +840,7 @@ function setDiff(setAProperty, setBProperty) {
   @public
 */
 function collect(dependentKey, ...additionalDependentKeys) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @collect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @collect as a decorator directly, but it requires atleast one dependent key parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
   let dependentKeys = [dependentKey, ...additionalDependentKeys];
   return multiArrayMacro(dependentKeys, function () {
     let res = dependentKeys.map(key => {
@@ -998,8 +997,8 @@ function collect(dependentKey, ...additionalDependentKeys) {
 */
 
 function sort(itemsKey, additionalDependentKeysOrDefinition, sortDefinition) {
-  (isDevelopingApp() && !(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @sort as a decorator directly, but it requires atleast an `itemsKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
-  if (isDevelopingApp()) {
+  (!(!isElementDescriptor(Array.prototype.slice.call(arguments))) && assert('You attempted to use @sort as a decorator directly, but it requires atleast an `itemsKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))));
+  {
     let argumentsValid = false;
     if (arguments.length === 2) {
       argumentsValid = typeof itemsKey === 'string' && (typeof additionalDependentKeysOrDefinition === 'string' || typeof additionalDependentKeysOrDefinition === 'function');
@@ -1007,7 +1006,7 @@ function sort(itemsKey, additionalDependentKeysOrDefinition, sortDefinition) {
     if (arguments.length === 3) {
       argumentsValid = typeof itemsKey === 'string' && Array.isArray(additionalDependentKeysOrDefinition) && typeof sortDefinition === 'function';
     }
-    (isDevelopingApp() && !(argumentsValid) && assert('The `sort` computed macro can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid));
+    (!(argumentsValid) && assert('The `sort` computed macro can either be used with an array of sort properties or with a sort function. If used with an array of sort properties, it must receive exactly two arguments: the key of the array to sort, and the key of the array of sort properties. If used with a sort function, it may receive up to three arguments: the key of the array to sort, an optional additional array of dependent keys for the computed property, and the sort function.', argumentsValid));
   }
   let additionalDependentKeys;
   let sortDefinitionOrString;
@@ -1035,7 +1034,7 @@ function customSort(itemsKey, additionalDependentKeys, comparator) {
 function propertySort(itemsKey, sortPropertiesKey) {
   let cp = autoComputed(function (key) {
     let sortProperties = get(this, sortPropertiesKey);
-    (isDevelopingApp() && !(function (arr) {
+    (!(function (arr) {
       return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');
     }(sortProperties)) && assert(`The sort definition for '${key}' on ${this} must be a function or an array of strings`, function (arr) {
       return isNativeOrEmberArray(arr) && arr.every(s => typeof s === 'string');

package/dist/{packages → dev/packages}/@ember/object/mixin.js

@@ -1,16 +1,15 @@
-import { I as INIT_FACTORY } from '../../shared-chunks/registry-XY5cfmbH.js';
+import { INIT_FACTORY } from '../-internals/container/index.js';
 import { peekMeta, meta } from '../-internals/meta/lib/meta.js';
-import { g as guidFor, R as ROOT, o as observerListenerMetaFor, w as wrap } from '../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { R as ROOT, o as observerListenerMetaFor, w as wrap } from '../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import '../debug/index.js';
-import { y as nativeDescDecorator, z as defineValue, A as defineDecorator, B as revalidateObservers, f as isClassicDecorator, E as descriptorForDecorator, x as addObserver, w as removeObserver, F as addListener, G as removeListener, C as ComputedProperty, H as makeComputedDecorator } from '../../shared-chunks/observers-DhgQ6ba5.js';
+import { x as nativeDescDecorator, y as defineValue, z as defineDecorator, A as revalidateObservers, f as isClassicDecorator, B as descriptorForDecorator, u as addObserver, r as removeObserver, E as addListener, F as removeListener, C as ComputedProperty, G as makeComputedDecorator } from '../../shared-chunks/observers-Bj9qLVau.js';
 import '../../@glimmer/validator/index.js';
 import '../../@glimmer/destroyable/index.js';
-import '../../shared-chunks/debug-to-string-BsFOvUtQ.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import '../../@glimmer/global-context/index.js';
-import '../../shared-chunks/reference-B6HMX4y0.js';
-import '../../shared-chunks/capabilities-DHiXCCuB.js';
-import { s as setUnprocessedMixins } from '../../shared-chunks/namespace_search-ClQOZuFA.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { s as setUnprocessedMixins } from '../../shared-chunks/namespace_search-uT8odThF.js';
 import { assert } from '../debug/lib/assert.js';
 
 /**
@@ -125,7 +124,7 @@ function simpleMakeArray(value) {
 function applyConcatenatedProperties(key, value, values) {
   let baseValue = values[key];
   let ret = simpleMakeArray(baseValue).concat(simpleMakeArray(value));
-  if (isDevelopingApp()) {
+  {
     // it is possible to use concatenatedProperties with strings (which cannot be frozen)
     // only freeze objects...
     if (typeof ret === 'object' && ret !== null) {
@@ -137,7 +136,7 @@ function applyConcatenatedProperties(key, value, values) {
 }
 function applyMergedProperties(key, value, values) {
   let baseValue = values[key];
-  (isDevelopingApp() && !(!isArray(value)) && assert(`You passed in \`${JSON.stringify(value)}\` as the value for \`${key}\` but \`${key}\` cannot be an Array`, !isArray(value)));
+  (!(!isArray(value)) && assert(`You passed in \`${JSON.stringify(value)}\` as the value for \`${key}\` but \`${key}\` cannot be an Array`, !isArray(value)));
   if (!baseValue) {
     return value;
   }
@@ -162,7 +161,7 @@ function mergeMixins(mixins, meta, descs, values, base, keys, keysWithSuper) {
   let currentMixin;
   for (let i = 0; i < mixins.length; i++) {
     currentMixin = mixins[i];
-    (isDevelopingApp() && !(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(currentMixin)}`, typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]'));
+    (!(typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(currentMixin)}`, typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]'));
     if (MIXINS.has(currentMixin)) {
       if (meta.hasMixin(currentMixin)) {
         continue;
@@ -414,16 +413,9 @@ class Mixin {
     this.mixins = buildMixinsArray(mixins);
     this.ownerConstructor = undefined;
     this._without = undefined;
-    if (isDevelopingApp()) {
+    {
       // Eagerly add INIT_FACTORY to avoid issues in DEBUG as a result of Object.seal(mixin)
       this[INIT_FACTORY] = null;
-      /*
-        In debug builds, we seal mixins to help avoid performance pitfalls.
-         In IE11 there is a quirk that prevents sealed objects from being added
-        to a WeakMap. Unfortunately, the mixin system currently relies on
-        weak maps in `guidFor`, so we need to prime the guid cache weak map.
-      */
-      guidFor(this);
       if (Mixin._disableDebugSeal !== true) {
         Object.seal(this);
       }
@@ -534,7 +526,7 @@ class Mixin {
   /** @internal */
   keys() {
     let keys = _keys(this);
-    (isDevelopingApp() && !(keys) && assert('[BUG] Missing keys for mixin!', keys));
+    (!(keys) && assert('[BUG] Missing keys for mixin!', keys));
     return keys;
   }
 
@@ -543,7 +535,7 @@ class Mixin {
     return '(unknown mixin)';
   }
 }
-if (isDevelopingApp()) {
+{
   Object.defineProperty(Mixin, '_disableDebugSeal', {
     configurable: true,
     enumerable: false,
@@ -558,7 +550,7 @@ function buildMixinsArray(mixins) {
     m = new Array(length);
     for (let i = 0; i < length; i++) {
       let x = mixins[i];
-      (isDevelopingApp() && !(typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(x)}`, typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]'));
+      (!(typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]') && assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(x)}`, typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]'));
       if (MIXINS.has(x)) {
         m[i] = x;
       } else {
@@ -568,7 +560,7 @@ function buildMixinsArray(mixins) {
   }
   return m;
 }
-if (isDevelopingApp()) {
+{
   Object.seal(Mixin.prototype);
 }
 function _detect(curMixin, targetMixin, seen = new Set()) {

package/dist/dev/packages/@ember/object/observable.js

@@ -0,0 +1,181 @@
+import { peekMeta } from '../-internals/meta/lib/meta.js';
+import '../../shared-chunks/mandatory-setter-DHZe7-kW.js';
+import '../debug/index.js';
+import '../../@glimmer/destroyable/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../@glimmer/global-context/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { g as get, q as hasListeners, r as removeObserver, u as addObserver, n as notifyPropertyChange, v as endPropertyChanges, w as beginPropertyChanges } from '../../shared-chunks/observers-Bj9qLVau.js';
+import { s as set } from '../../shared-chunks/property_set-DaoZXGM5.js';
+import { s as setProperties, g as getProperties } from '../../shared-chunks/set_properties-kVGzZL_a.js';
+import '../-internals/environment/index.js';
+import Mixin from './mixin.js';
+import { assert } from '../debug/lib/assert.js';
+
+/**
+@module @ember/object/observable
+*/
+
+
+/**
+  ## Overview
+
+  This mixin provides properties and property observing functionality, core
+  features of the Ember object model.
+
+  Properties and observers allow one object to observe changes to a
+  property on another object. This is one of the fundamental ways that
+  models, controllers and views communicate with each other in an Ember
+  application.
+
+  Any object that has this mixin applied can be used in observer
+  operations. That includes `EmberObject` and most objects you will
+  interact with as you write your Ember application.
+
+  Note that you will not generally apply this mixin to classes yourself,
+  but you will use the features provided by this module frequently, so it
+  is important to understand how to use it.
+
+  ## Using `get()` and `set()`
+
+  Because of Ember's support for bindings and observers, you will always
+  access properties using the get method, and set properties using the
+  set method. This allows the observing objects to be notified and
+  computed properties to be handled properly.
+
+  More documentation about `get` and `set` are below.
+
+  ## Observing Property Changes
+
+  You typically observe property changes simply by using the `observer`
+  function in classes that you write.
+
+  For example:
+
+  ```javascript
+  import { observer } from '@ember/object';
+  import EmberObject from '@ember/object';
+
+  EmberObject.extend({
+    valueObserver: observer('value', function(sender, key, value, rev) {
+      // Executes whenever the "value" property changes
+      // See the addObserver method for more information about the callback arguments
+    })
+  });
+  ```
+
+  Although this is the most common way to add an observer, this capability
+  is actually built into the `EmberObject` class on top of two methods
+  defined in this mixin: `addObserver` and `removeObserver`. You can use
+  these two methods to add and remove observers yourself if you need to
+  do so at runtime.
+
+  To add an observer for a property, call:
+
+  ```javascript
+  object.addObserver('propertyKey', targetObject, targetAction)
+  ```
+
+  This will call the `targetAction` method on the `targetObject` whenever
+  the value of the `propertyKey` changes.
+
+  Note that if `propertyKey` is a computed property, the observer will be
+  called when any of the property dependencies are changed, even if the
+  resulting value of the computed property is unchanged. This is necessary
+  because computed properties are not computed until `get` is called.
+
+  @class Observable
+  @public
+*/
+
+const Observable = Mixin.create({
+  get(keyName) {
+    return get(this, keyName);
+  },
+  getProperties(...args) {
+    return getProperties(this, ...args);
+  },
+  set(keyName, value) {
+    return set(this, keyName, value);
+  },
+  setProperties(hash) {
+    return setProperties(this, hash);
+  },
+  /**
+    Begins a grouping of property changes.
+     You can use this method to group property changes so that notifications
+    will not be sent until the changes are finished. If you plan to make a
+    large number of changes to an object at one time, you should call this
+    method at the beginning of the changes to begin deferring change
+    notifications. When you are done making changes, call
+    `endPropertyChanges()` to deliver the deferred change notifications and end
+    deferring.
+     @method beginPropertyChanges
+    @return {Observable}
+    @private
+  */
+  beginPropertyChanges() {
+    beginPropertyChanges();
+    return this;
+  },
+  /**
+    Ends a grouping of property changes.
+     You can use this method to group property changes so that notifications
+    will not be sent until the changes are finished. If you plan to make a
+    large number of changes to an object at one time, you should call
+    `beginPropertyChanges()` at the beginning of the changes to defer change
+    notifications. When you are done making changes, call this method to
+    deliver the deferred change notifications and end deferring.
+     @method endPropertyChanges
+    @return {Observable}
+    @private
+  */
+  endPropertyChanges() {
+    endPropertyChanges();
+    return this;
+  },
+  notifyPropertyChange(keyName) {
+    notifyPropertyChange(this, keyName);
+    return this;
+  },
+  addObserver(key, target, method, sync) {
+    addObserver(this, key, target, method, sync);
+    return this;
+  },
+  removeObserver(key, target, method, sync) {
+    removeObserver(this, key, target, method, sync);
+    return this;
+  },
+  /**
+    Returns `true` if the object currently has observers registered for a
+    particular key. You can use this method to potentially defer performing
+    an expensive action until someone begins observing a particular property
+    on the object.
+     @method hasObserverFor
+    @param {String} key Key to check
+    @return {Boolean}
+    @private
+  */
+  hasObserverFor(key) {
+    return hasListeners(this, `${key}:change`);
+  },
+  incrementProperty(keyName, increment = 1) {
+    (!(!isNaN(parseFloat(String(increment))) && isFinite(increment)) && assert('Must pass a numeric value to incrementProperty', !isNaN(parseFloat(String(increment))) && isFinite(increment)));
+    return set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
+  },
+  decrementProperty(keyName, decrement = 1) {
+    (!((typeof decrement === 'number' || !isNaN(parseFloat(decrement))) && isFinite(decrement)) && assert('Must pass a numeric value to decrementProperty', (typeof decrement === 'number' || !isNaN(parseFloat(decrement))) && isFinite(decrement)));
+    return set(this, keyName, (get(this, keyName) || 0) - decrement);
+  },
+  toggleProperty(keyName) {
+    return set(this, keyName, !get(this, keyName));
+  },
+  cacheFor(keyName) {
+    let meta = peekMeta(this);
+    return meta !== null ? meta.valueFor(keyName) : undefined;
+  }
+});
+
+export { Observable as default };

package/dist/dev/packages/@ember/object/observers.js

@@ -0,0 +1,11 @@
+import '../-internals/meta/lib/meta.js';
+import '../../shared-chunks/mandatory-setter-DHZe7-kW.js';
+import '../debug/index.js';
+import '../../@glimmer/destroyable/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../@glimmer/global-context/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+export { u as addObserver, r as removeObserver } from '../../shared-chunks/observers-Bj9qLVau.js';
+import '../-internals/environment/index.js';

package/dist/{packages → dev/packages}/@ember/object/promise-proxy-mixin.js

@@ -1,18 +1,17 @@
 import './index.js';
 import Mixin from './mixin.js';
-import { c as computed, g as get } from '../../shared-chunks/observers-DhgQ6ba5.js';
+import { c as computed, g as get } from '../../shared-chunks/observers-Bj9qLVau.js';
 import '../-internals/meta/lib/meta.js';
 import '../debug/index.js';
 import '../../@glimmer/validator/index.js';
-import '../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import '@embroider/macros';
+import '../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import '../../@glimmer/destroyable/index.js';
-import '../../shared-chunks/debug-to-string-BsFOvUtQ.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import '../../@glimmer/global-context/index.js';
-import '../../shared-chunks/reference-B6HMX4y0.js';
-import '../../shared-chunks/capabilities-DHiXCCuB.js';
-import { s as setProperties } from '../../shared-chunks/set_properties-Dag9Xz6u.js';
-import '../../shared-chunks/env-DEd6hPbj.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { s as setProperties } from '../../shared-chunks/set_properties-kVGzZL_a.js';
+import '../-internals/environment/index.js';
 
 /**
   @module @ember/object/promise-proxy-mixin

package/dist/dev/packages/@ember/renderer/index.js

@@ -0,0 +1,14 @@
+import '../../shared-chunks/fragment-Cc5k9Oy4.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../@glimmer/global-context/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/index-Q7JnrdBn.js';
+import '../../@glimmer/destroyable/index.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+export { f as renderComponent, r as renderSettled } from '../../shared-chunks/index-PxU6E7q8.js';
+import '../-internals/container/index.js';
+import '../debug/index.js';
+import '../../shared-chunks/dynamic-CFg3dljk.js';
+import '../../shared-chunks/constants-eoaL3OJQ.js';
+import '../runloop/index.js';

package/dist/dev/packages/@ember/routing/-internals.js

@@ -0,0 +1,22 @@
+export { default as RouterState } from './lib/router_state.js';
+export { default as RoutingService } from './lib/routing-service.js';
+export { prefixRouteNameArg } from './lib/utils.js';
+export { default as generateController, generateControllerFactory } from './lib/generate_controller.js';
+export { default as BucketCache } from './lib/cache.js';
+export { default as DSL } from './lib/dsl.js';
+export { default as controllerFor } from './lib/controller_for.js';
+import '../-internals/meta/lib/meta.js';
+import '../../shared-chunks/mandatory-setter-DHZe7-kW.js';
+import '../debug/index.js';
+import '../../@glimmer/destroyable/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../@glimmer/global-context/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import '../../shared-chunks/observers-Bj9qLVau.js';
+import '../-internals/environment/index.js';
+import '../engine/instance.js';
+import '../../route-recognizer/index.js';
+import '../../shared-chunks/rsvp-CnCSY930.js';
+import '../../shared-chunks/unrecognized-url-error-B3wUTorp.js';

package/dist/{packages → dev/packages}/@ember/routing/hash-location.js

@@ -67,7 +67,7 @@ class HashLocation extends EmberObject {
       outPath = '/';
 
       // Only add the # if the path isn't empty.
-      // We do NOT want `/#` since the ampersand
+      // We do NOT want `/#` since the hash
       // is only included (conventionally) when
       // the location.hash has a value
       if (originalPath) {