ember-source 5.11.0-beta.2 → 5.11.1

package/dist/packages/shared-chunks/index-PYiGj1jp.js

@@ -1,2071 +0,0 @@
-import { a as assert } from './index-DTxy4Zgx.js';
-import { E as ENV } from './env-BJLX2Arx.js';
-import { g as get, a3 as endPropertyChanges, n as notifyPropertyChange, x as addObserver, y as removeObserver, J as hasListeners, a1 as beginPropertyChanges, R as objectAt, a7 as replaceInNativeArray, S as replace, a5 as PROXY_CONTENT, c as computed, H as hasUnknownProperty, B as descriptorForProperty, ad as DEBUG_INJECTION_FUNCTIONS, u as isClassicDecorator, d as defineProperty, ab as activateObserver, I as sendEvent, L as setClassicDecorator, i as isElementDescriptor, e as expandProperties } from './cache-gDE3bkXq.js';
-import { peekMeta, meta } from '../@ember/-internals/meta/lib/meta.js';
-import '../@glimmer/validator/index.js';
-import { g as guidFor, s as setObservers } from './mandatory-setter-1UQhiJOb.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { registerDestructor, isDestroyed, isDestroying, destroy } from '../@glimmer/destroyable/index.js';
-import '../@glimmer/manager/index.js';
-import { s as set } from './property_set-CW4q-uo4.js';
-import { g as getProperties, s as setProperties } from './set_properties-DvalyQdu.js';
-import { g as getFactoryFor, s as setFactoryFor } from './registry-DzfcDwii.js';
-import { getOwner } from '../@ember/-internals/owner/index.js';
-import { i as isInternalSymbol } from './to-string-D8i3mjEU.js';
-import Mixin, { applyMixin } from '../@ember/object/mixin.js';
-import '../@ember/-internals/runtime/lib/mixins/registry_proxy.js';
-import '../@ember/-internals/runtime/lib/mixins/container_proxy.js';
-import Comparable from '../@ember/-internals/runtime/lib/mixins/comparable.js';
-import ActionHandler from '../@ember/-internals/runtime/lib/mixins/action_handler.js';
-import '../@ember/-internals/runtime/lib/mixins/-proxy.js';
-import MutableEnumerable from '../@ember/enumerable/mutable.js';
-import '../@ember/-internals/runtime/lib/mixins/target_action_support.js';
-import '../@ember/-internals/runtime/lib/ext/rsvp.js';
-import Enumerable from '../@ember/enumerable/index.js';
-import { setEmberArray, isEmberArray } from '../@ember/array/-internals.js';
-import makeArray from '../@ember/array/lib/make-array.js';
-import { OWNER } from '../@glimmer/owner/index.js';
-
-// ........................................
-// TYPING & ARRAY MESSAGING
-//
-const TYPE_MAP = {
-  '[object Boolean]': 'boolean',
-  '[object Number]': 'number',
-  '[object String]': 'string',
-  '[object Function]': 'function',
-  '[object AsyncFunction]': 'function',
-  '[object Array]': 'array',
-  '[object Date]': 'date',
-  '[object RegExp]': 'regexp',
-  '[object Object]': 'object',
-  '[object FileList]': 'filelist'
-};
-const {
-  toString
-} = Object.prototype;
-
-/**
- @module @ember/utils
-*/
-/**
-  Returns a consistent type for the passed object.
-
-  Use this instead of the built-in `typeof` to get the type of an item.
-  It will return the same result across all browsers and includes a bit
-  more detail. Here is what will be returned:
-
-      | Return Value  | Meaning                                              |
-      |---------------|------------------------------------------------------|
-      | 'string'      | String primitive or String object.                   |
-      | 'number'      | Number primitive or Number object.                   |
-      | 'boolean'     | Boolean primitive or Boolean object.                 |
-      | 'null'        | Null value                                           |
-      | 'undefined'   | Undefined value                                      |
-      | 'function'    | A function                                           |
-      | 'array'       | An instance of Array                                 |
-      | 'regexp'      | An instance of RegExp                                |
-      | 'date'        | An instance of Date                                  |
-      | 'filelist'    | An instance of FileList                              |
-      | 'class'       | An Ember class (created using EmberObject.extend())  |
-      | 'instance'    | An Ember object instance                             |
-      | 'error'       | An instance of the Error object                      |
-      | 'object'      | A JavaScript object not inheriting from EmberObject  |
-
-  Examples:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import { typeOf } from '@ember/utils';
-  import EmberObject from '@ember/object';
-
-  typeOf();                       // 'undefined'
-  typeOf(null);                   // 'null'
-  typeOf(undefined);              // 'undefined'
-  typeOf('michael');              // 'string'
-  typeOf(new String('michael'));  // 'string'
-  typeOf(101);                    // 'number'
-  typeOf(new Number(101));        // 'number'
-  typeOf(true);                   // 'boolean'
-  typeOf(new Boolean(true));      // 'boolean'
-  typeOf(A);                      // 'function'
-  typeOf(A());                    // 'array'
-  typeOf([1, 2, 90]);             // 'array'
-  typeOf(/abc/);                  // 'regexp'
-  typeOf(new Date());             // 'date'
-  typeOf(event.target.files);     // 'filelist'
-  typeOf(EmberObject.extend());   // 'class'
-  typeOf(EmberObject.create());   // 'instance'
-  typeOf(new Error('teamocil'));  // 'error'
-
-  // 'normal' JavaScript object
-  typeOf({ a: 'b' });             // 'object'
-  ```
-
-  @method typeOf
-  @for @ember/utils
-  @param item the item to check
-  @return {String} the type
-  @public
-  @static
-*/
-function typeOf(item) {
-  if (item === null) {
-    return 'null';
-  }
-  if (item === undefined) {
-    return 'undefined';
-  }
-  let ret = TYPE_MAP[toString.call(item)] || 'object';
-  if (ret === 'function') {
-    if (EmberCoreObject.detect(item)) {
-      ret = 'class';
-    }
-  } else if (ret === 'object') {
-    if (item instanceof Error) {
-      ret = 'error';
-    } else if (item instanceof EmberCoreObject) {
-      ret = 'instance';
-    } else if (item instanceof Date) {
-      ret = 'date';
-    }
-  }
-  return ret;
-}
-
-const TYPE_ORDER = {
-  undefined: 0,
-  null: 1,
-  boolean: 2,
-  number: 3,
-  string: 4,
-  array: 5,
-  object: 6,
-  instance: 7,
-  function: 8,
-  class: 9,
-  date: 10,
-  regexp: 11,
-  filelist: 12,
-  error: 13
-};
-//
-// the spaceship operator
-//
-//                      `. ___
-//                     __,' __`.                _..----....____
-//         __...--.'``;.   ,.   ;``--..__     .'    ,-._    _.-'
-//   _..-''-------'   `'   `'   `'     O ``-''._   (,;') _,'
-// ,'________________                          \`-._`-','
-//  `._              ```````````------...___   '-.._'-:
-//     ```--.._      ,.                     ````--...__\-.
-//             `.--. `-` "INFINITY IS LESS     ____    |  |`
-//               `. `.   THAN BEYOND"        ,'`````.  ;  ;`
-//                 `._`.        __________   `.      \'__/`
-//                    `-:._____/______/___/____`.     \  `
-//                                |       `._    `.    \
-//                                `._________`-.   `.   `.___
-//                                              SSt  `------'`
-function spaceship(a, b) {
-  // SAFETY: `Math.sign` always returns `-1` for negative, `0` for zero, and `1`
-  // for positive numbers. (The extra precision is useful for the way we use
-  // this in the context of `compare`.)
-  return Math.sign(a - b);
-}
-
-/**
- @module @ember/utils
-*/
-
-/**
- Compares two javascript values and returns:
-
-  - -1 if the first is smaller than the second,
-  - 0 if both are equal,
-  - 1 if the first is greater than the second.
-
-  ```javascript
-  import { compare } from '@ember/utils';
-
-  compare('hello', 'hello');  // 0
-  compare('abc', 'dfg');      // -1
-  compare(2, 1);              // 1
-  ```
-
- If the types of the two objects are different precedence occurs in the
- following order, with types earlier in the list considered `<` types
- later in the list:
-
-  - undefined
-  - null
-  - boolean
-  - number
-  - string
-  - array
-  - object
-  - instance
-  - function
-  - class
-  - date
-
-  ```javascript
-  import { compare } from '@ember/utils';
-
-  compare('hello', 50);       // 1
-  compare(50, 'hello');       // -1
-  ```
-
- @method compare
- @for @ember/utils
- @static
- @param {Object} v First value to compare
- @param {Object} w Second value to compare
- @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
- @public
-*/
-function compare(v, w) {
-  if (v === w) {
-    return 0;
-  }
-  let type1 = typeOf(v);
-  let type2 = typeOf(w);
-  if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
-    return v.constructor.compare(v, w);
-  }
-  if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
-    // SAFETY: Multiplying by a negative just changes the sign
-    return w.constructor.compare(w, v) * -1;
-  }
-  let res = spaceship(TYPE_ORDER[type1], TYPE_ORDER[type2]);
-  if (res !== 0) {
-    return res;
-  }
-
-  // types are equal - so we have to check values now
-  switch (type1) {
-    case 'boolean':
-      (isDevelopingApp() && !(typeof v === 'boolean' && typeof w === 'boolean') && assert('both are boolean', typeof v === 'boolean' && typeof w === 'boolean'));
-      return spaceship(Number(v), Number(w));
-    case 'number':
-      (isDevelopingApp() && !(typeof v === 'number' && typeof w === 'number') && assert('both are numbers', typeof v === 'number' && typeof w === 'number'));
-      return spaceship(v, w);
-    case 'string':
-      (isDevelopingApp() && !(typeof v === 'string' && typeof w === 'string') && assert('both are strings', typeof v === 'string' && typeof w === 'string'));
-      return spaceship(v.localeCompare(w), 0);
-    case 'array':
-      {
-        (isDevelopingApp() && !(Array.isArray(v) && Array.isArray(w)) && assert('both are arrays', Array.isArray(v) && Array.isArray(w)));
-        let vLen = v.length;
-        let wLen = w.length;
-        let len = Math.min(vLen, wLen);
-        for (let i = 0; i < len; i++) {
-          let r = compare(v[i], w[i]);
-          if (r !== 0) {
-            return r;
-          }
-        }
-
-        // all elements are equal now
-        // shorter array should be ordered first
-        return spaceship(vLen, wLen);
-      }
-    case 'instance':
-      if (isComparable(v) && v.compare) {
-        return v.compare(v, w);
-      }
-      return 0;
-    case 'date':
-      (isDevelopingApp() && !(v instanceof Date && w instanceof Date) && assert('both are dates', v instanceof Date && w instanceof Date));
-      return spaceship(v.getTime(), w.getTime());
-    default:
-      return 0;
-  }
-}
-function isComparable(value) {
-  return Comparable.detect(value);
-}
-
-/**
-@module @ember/object/observable
-*/
-
-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) {
-    (isDevelopingApp() && !(!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) {
-    (isDevelopingApp() && !((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;
-  }
-});
-
-/**
-@module @ember/array
-*/
-
-const EMPTY_ARRAY = Object.freeze([]);
-const identityFunction = item => item;
-function uniqBy(array, keyOrFunc = identityFunction) {
-  (isDevelopingApp() && !(isArray(array)) && assert(`first argument passed to \`uniqBy\` should be array`, isArray(array)));
-  let ret = A();
-  let seen = new Set();
-  let getter = typeof keyOrFunc === 'function' ? keyOrFunc : item => get(item, keyOrFunc);
-  array.forEach(item => {
-    let val = getter(item);
-    if (!seen.has(val)) {
-      seen.add(val);
-      ret.push(item);
-    }
-  });
-  return ret;
-}
-function iter(...args) {
-  let valueProvided = args.length === 2;
-  let [key, value] = args;
-  return valueProvided ? item => value === get(item, key) : item => Boolean(get(item, key));
-}
-function findIndex(array, predicate, startAt) {
-  let len = array.length;
-  for (let index = startAt; index < len; index++) {
-    // SAFETY: Because we're checking the index this value should always be set.
-    let item = objectAt(array, index);
-    if (predicate(item, index, array)) {
-      return index;
-    }
-  }
-  return -1;
-}
-function find(array, callback, target = null) {
-  let predicate = callback.bind(target);
-  let index = findIndex(array, predicate, 0);
-  return index === -1 ? undefined : objectAt(array, index);
-}
-function any(array, callback, target = null) {
-  let predicate = callback.bind(target);
-  return findIndex(array, predicate, 0) !== -1;
-}
-function every(array, callback, target = null) {
-  let cb = callback.bind(target);
-  let predicate = (item, index, array) => !cb(item, index, array);
-  return findIndex(array, predicate, 0) === -1;
-}
-function indexOf(array, val, startAt = 0, withNaNCheck) {
-  let len = array.length;
-  if (startAt < 0) {
-    startAt += len;
-  }
-
-  // SameValueZero comparison (NaN !== NaN)
-  let predicate = withNaNCheck && val !== val ? item => item !== item : item => item === val;
-  return findIndex(array, predicate, startAt);
-}
-function removeAt(array, index, len) {
-  (isDevelopingApp() && !(index > -1 && index < array.length) && assert(`\`removeAt\` index provided is out of range`, index > -1 && index < array.length));
-  replace(array, index, len ?? 1, EMPTY_ARRAY);
-  return array;
-}
-function insertAt(array, index, item) {
-  (isDevelopingApp() && !(index > -1 && index <= array.length) && assert(`\`insertAt\` index provided is out of range`, index > -1 && index <= array.length));
-  replace(array, index, 0, [item]);
-  return item;
-}
-
-/**
-  Returns true if the passed object is an array or Array-like.
-
-  Objects are considered Array-like if any of the following are true:
-
-    - the object is a native Array
-    - the object has an objectAt property
-    - the object is an Object, and has a length property
-
-  Unlike `typeOf` this method returns true even if the passed object is
-  not formally an array but appears to be array-like (i.e. implements `Array`)
-
-  ```javascript
-  import { isArray } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  isArray();                                      // false
-  isArray([]);                                    // true
-  isArray(ArrayProxy.create({ content: [] }));    // true
-  ```
-
-  @method isArray
-  @static
-  @for @ember/array
-  @param {Object} obj The object to test
-  @return {Boolean} true if the passed object is an array or Array-like
-  @public
-*/
-function isArray(obj) {
-  if (isDevelopingApp() && typeof obj === 'object' && obj !== null) {
-    // SAFETY: Property read checks are safe if it's an object
-    let possibleProxyContent = obj[PROXY_CONTENT];
-    if (possibleProxyContent !== undefined) {
-      obj = possibleProxyContent;
-    }
-  }
-
-  // SAFETY: Property read checks are safe if it's an object
-  if (!obj || obj.setInterval) {
-    return false;
-  }
-  if (Array.isArray(obj) || EmberArray.detect(obj)) {
-    return true;
-  }
-  let type = typeOf(obj);
-  if ('array' === type) {
-    return true;
-  }
-
-  // SAFETY: Property read checks are safe if it's an object
-  let length = obj.length;
-  if (typeof length === 'number' && length === length && 'object' === type) {
-    return true;
-  }
-  return false;
-}
-
-/*
-  This allows us to define computed properties that are not enumerable.
-  The primary reason this is important is that when `NativeArray` is
-  applied to `Array.prototype` we need to ensure that we do not add _any_
-  new enumerable properties.
-*/
-function nonEnumerableComputed(callback) {
-  let property = computed(callback);
-  property.enumerable = false;
-  return property;
-}
-function mapBy(key) {
-  return this.map(next => get(next, key));
-}
-
-// ..........................................................
-// ARRAY
-//
-/**
-  This mixin implements Observer-friendly Array-like behavior. It is not a
-  concrete implementation, but it can be used up by other classes that want
-  to appear like arrays.
-
-  For example, ArrayProxy is a concrete class that can be instantiated to
-  implement array-like behavior. This class uses the Array Mixin by way of
-  the MutableArray mixin, which allows observable changes to be made to the
-  underlying array.
-
-  This mixin defines methods specifically for collections that provide
-  index-ordered access to their contents. When you are designing code that
-  needs to accept any kind of Array-like object, you should use these methods
-  instead of Array primitives because these will properly notify observers of
-  changes to the array.
-
-  Although these methods are efficient, they do add a layer of indirection to
-  your application so it is a good idea to use them only when you need the
-  flexibility of using both true JavaScript arrays and "virtual" arrays such
-  as controllers and collections.
-
-  You can use the methods defined in this module to access and modify array
-  contents in an observable-friendly way. You can also be notified whenever
-  the membership of an array changes by using `.observes('myArray.[]')`.
-
-  To support `EmberArray` in your own class, you must override two
-  primitives to use it: `length()` and `objectAt()`.
-
-  @class EmberArray
-  @uses Enumerable
-  @since Ember 0.9.0
-  @public
-*/
-
-const EmberArray = Mixin.create(Enumerable, {
-  init() {
-    this._super(...arguments);
-    setEmberArray(this);
-  },
-  objectsAt(indexes) {
-    return indexes.map(idx => objectAt(this, idx));
-  },
-  '[]': nonEnumerableComputed({
-    get() {
-      return this;
-    },
-    set(_key, value) {
-      this.replace(0, this.length, value);
-      return this;
-    }
-  }),
-  firstObject: nonEnumerableComputed(function () {
-    return objectAt(this, 0);
-  }).readOnly(),
-  lastObject: nonEnumerableComputed(function () {
-    return objectAt(this, this.length - 1);
-  }).readOnly(),
-  // Add any extra methods to EmberArray that are native to the built-in Array.
-  slice(beginIndex = 0, endIndex) {
-    let ret = A();
-    let length = this.length;
-    if (beginIndex < 0) {
-      beginIndex = length + beginIndex;
-    }
-    let validatedEndIndex;
-    if (endIndex === undefined || endIndex > length) {
-      validatedEndIndex = length;
-    } else if (endIndex < 0) {
-      validatedEndIndex = length + endIndex;
-    } else {
-      validatedEndIndex = endIndex;
-    }
-    while (beginIndex < validatedEndIndex) {
-      ret[ret.length] = objectAt(this, beginIndex++);
-    }
-    return ret;
-  },
-  indexOf(object, startAt) {
-    return indexOf(this, object, startAt, false);
-  },
-  lastIndexOf(object, startAt) {
-    let len = this.length;
-    if (startAt === undefined || startAt >= len) {
-      startAt = len - 1;
-    }
-    if (startAt < 0) {
-      startAt += len;
-    }
-    for (let idx = startAt; idx >= 0; idx--) {
-      if (objectAt(this, idx) === object) {
-        return idx;
-      }
-    }
-    return -1;
-  },
-  forEach(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`forEach` expects a function as first argument.', typeof callback === 'function'));
-    let length = this.length;
-    for (let index = 0; index < length; index++) {
-      let item = this.objectAt(index);
-      callback.call(target, item, index, this);
-    }
-    return this;
-  },
-  getEach: mapBy,
-  setEach(key, value) {
-    return this.forEach(item => set(item, key, value));
-  },
-  map(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`map` expects a function as first argument.', typeof callback === 'function'));
-    let ret = A();
-    this.forEach((x, idx, i) => ret[idx] = callback.call(target, x, idx, i));
-    return ret;
-  },
-  mapBy,
-  filter(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`filter` expects a function as first argument.', typeof callback === 'function'));
-    let ret = A();
-    this.forEach((x, idx, i) => {
-      if (callback.call(target, x, idx, i)) {
-        ret.push(x);
-      }
-    });
-    return ret;
-  },
-  reject(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`reject` expects a function as first argument.', typeof callback === 'function'));
-    return this.filter(function () {
-      // @ts-expect-error TS doesn't like us using arguments like this
-      return !callback.apply(target, arguments);
-    });
-  },
-  filterBy() {
-    // @ts-expect-error TS doesn't like the ...arguments spread here.
-    return this.filter(iter(...arguments));
-  },
-  rejectBy() {
-    // @ts-expect-error TS doesn't like the ...arguments spread here.
-    return this.reject(iter(...arguments));
-  },
-  find(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`find` expects a function as first argument.', typeof callback === 'function'));
-    return find(this, callback, target);
-  },
-  findBy() {
-    // @ts-expect-error TS doesn't like the ...arguments spread here.
-    let callback = iter(...arguments);
-    return find(this, callback);
-  },
-  every(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`every` expects a function as first argument.', typeof callback === 'function'));
-    return every(this, callback, target);
-  },
-  isEvery() {
-    // @ts-expect-error TS doesn't like the ...arguments spread here.
-    let callback = iter(...arguments);
-    return every(this, callback);
-  },
-  any(callback, target = null) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`any` expects a function as first argument.', typeof callback === 'function'));
-    return any(this, callback, target);
-  },
-  isAny() {
-    // @ts-expect-error TS doesn't like us using arguments like this
-    let callback = iter(...arguments);
-    return any(this, callback);
-  },
-  // FIXME: When called without initialValue, behavior does not match native behavior
-  reduce(callback, initialValue) {
-    (isDevelopingApp() && !(typeof callback === 'function') && assert('`reduce` expects a function as first argument.', typeof callback === 'function'));
-    let ret = initialValue;
-    this.forEach(function (item, i) {
-      ret = callback(ret, item, i, this);
-    }, this);
-    return ret;
-  },
-  invoke(methodName, ...args) {
-    let ret = A();
-
-    // SAFETY: This is not entirely safe and the code will not work with Ember proxies
-    this.forEach(item => ret.push(item[methodName]?.(...args)));
-    return ret;
-  },
-  toArray() {
-    return this.map(item => item);
-  },
-  compact() {
-    return this.filter(value => value != null);
-  },
-  includes(object, startAt) {
-    return indexOf(this, object, startAt, true) !== -1;
-  },
-  sortBy() {
-    let sortKeys = arguments;
-    return this.toArray().sort((a, b) => {
-      for (let i = 0; i < sortKeys.length; i++) {
-        let key = sortKeys[i];
-        let propA = get(a, key);
-        let propB = get(b, key);
-        // return 1 or -1 else continue to the next sortKey
-        let compareValue = compare(propA, propB);
-        if (compareValue) {
-          return compareValue;
-        }
-      }
-      return 0;
-    });
-  },
-  uniq() {
-    return uniqBy(this);
-  },
-  uniqBy(key) {
-    return uniqBy(this, key);
-  },
-  without(value) {
-    if (!this.includes(value)) {
-      return this; // nothing to do
-    }
-
-    // SameValueZero comparison (NaN !== NaN)
-    let predicate = value === value ? item => item !== value : item => item === item;
-    return this.filter(predicate);
-  }
-});
-
-/**
-  This mixin defines the API for modifying array-like objects. These methods
-  can be applied only to a collection that keeps its items in an ordered set.
-  It builds upon the Array mixin and adds methods to modify the array.
-  One concrete implementations of this class include ArrayProxy.
-
-  It is important to use the methods in this class to modify arrays so that
-  changes are observable. This allows the binding system in Ember to function
-  correctly.
-
-
-  Note that an Array can change even if it does not implement this mixin.
-  For example, one might implement a SparseArray that cannot be directly
-  modified, but if its underlying enumerable changes, it will change also.
-
-  @class MutableArray
-  @uses EmberArray
-  @uses MutableEnumerable
-  @public
-*/
-
-const MutableArray = Mixin.create(EmberArray, MutableEnumerable, {
-  clear() {
-    let len = this.length;
-    if (len === 0) {
-      return this;
-    }
-    this.replace(0, len, EMPTY_ARRAY);
-    return this;
-  },
-  insertAt(idx, object) {
-    insertAt(this, idx, object);
-    return this;
-  },
-  removeAt(start, len) {
-    return removeAt(this, start, len);
-  },
-  pushObject(obj) {
-    return insertAt(this, this.length, obj);
-  },
-  pushObjects(objects) {
-    this.replace(this.length, 0, objects);
-    return this;
-  },
-  popObject() {
-    let len = this.length;
-    if (len === 0) {
-      return null;
-    }
-    let ret = objectAt(this, len - 1);
-    this.removeAt(len - 1, 1);
-    return ret;
-  },
-  shiftObject() {
-    if (this.length === 0) {
-      return null;
-    }
-    let ret = objectAt(this, 0);
-    this.removeAt(0);
-    return ret;
-  },
-  unshiftObject(obj) {
-    return insertAt(this, 0, obj);
-  },
-  unshiftObjects(objects) {
-    this.replace(0, 0, objects);
-    return this;
-  },
-  reverseObjects() {
-    let len = this.length;
-    if (len === 0) {
-      return this;
-    }
-    let objects = this.toArray().reverse();
-    this.replace(0, len, objects);
-    return this;
-  },
-  setObjects(objects) {
-    if (objects.length === 0) {
-      return this.clear();
-    }
-    let len = this.length;
-    this.replace(0, len, objects);
-    return this;
-  },
-  removeObject(obj) {
-    let loc = this.length || 0;
-    while (--loc >= 0) {
-      let curObject = objectAt(this, loc);
-      if (curObject === obj) {
-        this.removeAt(loc);
-      }
-    }
-    return this;
-  },
-  removeObjects(objects) {
-    beginPropertyChanges();
-    for (let i = objects.length - 1; i >= 0; i--) {
-      // SAFETY: Due to the loop structure we know this will always exist.
-      this.removeObject(objects[i]);
-    }
-    endPropertyChanges();
-    return this;
-  },
-  addObject(obj) {
-    let included = this.includes(obj);
-    if (!included) {
-      this.pushObject(obj);
-    }
-    return this;
-  },
-  addObjects(objects) {
-    beginPropertyChanges();
-    objects.forEach(obj => this.addObject(obj));
-    endPropertyChanges();
-    return this;
-  }
-});
-
-/**
-  Creates an `Ember.NativeArray` from an Array-like object.
-  Does not modify the original object's contents. `A()` is not needed if
-  `EmberENV.EXTEND_PROTOTYPES` is `true` (the default value). However,
-  it is recommended that you use `A()` when creating addons for
-  ember or when you can not guarantee that `EmberENV.EXTEND_PROTOTYPES`
-  will be `true`.
-
-  Example
-
-  ```app/components/my-component.js
-  import Component from '@ember/component';
-  import { A } from '@ember/array';
-
-  export default Component.extend({
-    tagName: 'ul',
-    classNames: ['pagination'],
-
-    init() {
-      this._super(...arguments);
-
-      if (!this.get('content')) {
-        this.set('content', A());
-        this.set('otherContent', A([1,2,3]));
-      }
-    }
-  });
-  ```
-
-  @method A
-  @static
-  @for @ember/array
-  @return {Ember.NativeArray}
-  @public
-*/
-
-// Add Ember.Array to Array.prototype. Remove methods with native
-// implementations and supply some more optimized versions of generic methods
-// because they are so common.
-/**
-@module ember
-*/
-
-/**
- * The final definition of NativeArray removes all native methods. This is the list of removed methods
- * when run in Chrome 106.
- */
-
-/**
- * These additional items must be redefined since `Omit` causes methods that return `this` to return the
- * type at the time of the Omit.
- */
-
-// This is the same as MutableArray, but removes the actual native methods that exist on Array.prototype.
-
-/**
-  The NativeArray mixin contains the properties needed to make the native
-  Array support MutableArray and all of its dependent APIs. Unless you
-  have `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Array` set to
-  false, this will be applied automatically. Otherwise you can apply the mixin
-  at anytime by calling `Ember.NativeArray.apply(Array.prototype)`.
-
-  @class Ember.NativeArray
-  @uses MutableArray
-  @uses Observable
-  @public
-*/
-
-let NativeArray = Mixin.create(MutableArray, Observable, {
-  objectAt(idx) {
-    return this[idx];
-  },
-  // primitive for array support.
-  replace(start, deleteCount, items = EMPTY_ARRAY) {
-    (isDevelopingApp() && !(Array.isArray(items)) && assert('The third argument to replace needs to be an array.', Array.isArray(items)));
-    replaceInNativeArray(this, start, deleteCount, items);
-    return this;
-  }
-});
-
-// Remove any methods implemented natively so we don't override them
-const ignore = ['length'];
-NativeArray.keys().forEach(methodName => {
-  // SAFETY: It's safe to read unknown properties from an object
-  if (Array.prototype[methodName]) {
-    ignore.push(methodName);
-  }
-});
-NativeArray = NativeArray.without(...ignore);
-let A;
-if (ENV.EXTEND_PROTOTYPES.Array) {
-  NativeArray.apply(Array.prototype, true);
-  A = function (arr) {
-    (isDevelopingApp() && !(!(this instanceof A)) && assert('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A))); // SAFTEY: Since we are extending prototypes all true native arrays are Ember NativeArrays
-    return arr || [];
-  };
-} else {
-  A = function (arr) {
-    (isDevelopingApp() && !(!(this instanceof A)) && assert('You cannot create an Ember Array with `new A()`, please update to calling A as a function: `A()`', !(this instanceof A)));
-    if (isEmberArray(arr)) {
-      // SAFETY: If it's a true native array and it is also an EmberArray then it should be an Ember NativeArray
-      return arr;
-    } else {
-      // SAFETY: This will return an NativeArray but TS can't infer that.
-      return NativeArray.apply(arr ?? []);
-    }
-  };
-}
-
-/**
-  @module @ember/object/core
-*/
-
-function hasSetUnknownProperty(val) {
-  return typeof val === 'object' && val !== null && typeof val.setUnknownProperty === 'function';
-}
-function hasToStringExtension(val) {
-  return typeof val === 'object' && val !== null && typeof val.toStringExtension === 'function';
-}
-const reopen = Mixin.prototype.reopen;
-const wasApplied = new WeakSet();
-const prototypeMixinMap = new WeakMap();
-const initCalled = isDevelopingApp() ? new WeakSet() : undefined; // only used in debug builds to enable the proxy trap
-
-const destroyCalled = new Set();
-function ensureDestroyCalled(instance) {
-  if (!destroyCalled.has(instance)) {
-    instance.destroy();
-  }
-}
-function initialize(obj, properties) {
-  let m = meta(obj);
-  if (properties !== undefined) {
-    (isDevelopingApp() && !(typeof properties === 'object' && properties !== null) && assert('EmberObject.create only accepts objects.', typeof properties === 'object' && properties !== null));
-    (isDevelopingApp() && !(!(properties instanceof Mixin)) && assert('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof Mixin)));
-    let concatenatedProperties = obj.concatenatedProperties;
-    let mergedProperties = obj.mergedProperties;
-    let keyNames = Object.keys(properties);
-    for (let keyName of keyNames) {
-      // SAFETY: this cast as a Record is safe because all object types can be
-      // indexed in JS, and we explicitly type it as returning `unknown`, so the
-      // result *must* be checked below.
-      let value = properties[keyName];
-      (isDevelopingApp() && !(!isClassicDecorator(value)) && assert('EmberObject.create no longer supports defining computed ' + 'properties. Define computed properties using extend() or reopen() ' + 'before calling create().', !isClassicDecorator(value)));
-      (isDevelopingApp() && !(!(typeof value === 'function' && value.toString().indexOf('._super') !== -1)) && assert('EmberObject.create no longer supports defining methods that call _super.', !(typeof value === 'function' && value.toString().indexOf('._super') !== -1)));
-      (isDevelopingApp() && !(!(keyName === 'actions' && ActionHandler.detect(obj))) && assert('`actions` must be provided at extend time, not at create time, ' + 'when Ember.ActionHandler is used (i.e. views, controllers & routes).', !(keyName === 'actions' && ActionHandler.detect(obj))));
-      let possibleDesc = descriptorForProperty(obj, keyName, m);
-      let isDescriptor = possibleDesc !== undefined;
-      if (!isDescriptor) {
-        if (concatenatedProperties !== undefined && concatenatedProperties.length > 0 && concatenatedProperties.includes(keyName)) {
-          let baseValue = obj[keyName];
-          if (baseValue) {
-            value = makeArray(baseValue).concat(value);
-          } else {
-            value = makeArray(value);
-          }
-        }
-        if (mergedProperties !== undefined && mergedProperties.length > 0 && mergedProperties.includes(keyName)) {
-          let baseValue = obj[keyName];
-          value = Object.assign({}, baseValue, value);
-        }
-      }
-      if (isDescriptor) {
-        possibleDesc.set(obj, keyName, value);
-      } else if (hasSetUnknownProperty(obj) && !(keyName in obj)) {
-        obj.setUnknownProperty(keyName, value);
-      } else {
-        if (isDevelopingApp()) {
-          defineProperty(obj, keyName, null, value, m); // setup mandatory setter
-        } else {
-          obj[keyName] = value;
-        }
-      }
-    }
-  }
-
-  // using DEBUG here to avoid the extraneous variable when not needed
-  if (isDevelopingApp()) {
-    initCalled.add(obj);
-  }
-  obj.init(properties);
-  m.unsetInitializing();
-  let observerEvents = m.observerEvents();
-  if (observerEvents !== undefined) {
-    for (let i = 0; i < observerEvents.length; i++) {
-      activateObserver(obj, observerEvents[i].event, observerEvents[i].sync);
-    }
-  }
-  sendEvent(obj, 'init', undefined, undefined, m);
-}
-
-/**
-  `CoreObject` is the base class for all Ember constructs. It establishes a
-  class system based on Ember's Mixin system, and provides the basis for the
-  Ember Object Model. `CoreObject` should generally not be used directly,
-  instead you should use `EmberObject`.
-
-  ## Usage
-
-  You can define a class by extending from `CoreObject` using the `extend`
-  method:
-
-  ```js
-  const Person = CoreObject.extend({
-    name: 'Tomster',
-  });
-  ```
-
-  For detailed usage, see the [Object Model](https://guides.emberjs.com/release/object-model/)
-  section of the guides.
-
-  ## Usage with Native Classes
-
-  Native JavaScript `class` syntax can be used to extend from any `CoreObject`
-  based class:
-
-  ```js
-  class Person extends CoreObject {
-    init() {
-      super.init(...arguments);
-      this.name = 'Tomster';
-    }
-  }
-  ```
-
-  Some notes about `class` usage:
-
-  * `new` syntax is not currently supported with classes that extend from
-    `EmberObject` or `CoreObject`. You must continue to use the `create` method
-    when making new instances of classes, even if they are defined using native
-    class syntax. If you want to use `new` syntax, consider creating classes
-    which do _not_ extend from `EmberObject` or `CoreObject`. Ember features,
-    such as computed properties and decorators, will still work with base-less
-    classes.
-  * Instead of using `this._super()`, you must use standard `super` syntax in
-    native classes. See the [MDN docs on classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Super_class_calls_with_super)
-    for more details.
-  * Native classes support using [constructors](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Constructor)
-    to set up newly-created instances. Ember uses these to, among other things,
-    support features that need to retrieve other entities by name, like Service
-    injection and `getOwner`. To ensure your custom instance setup logic takes
-    place after this important work is done, avoid using the `constructor` in
-    favor of `init`.
-  * Properties passed to `create` will be available on the instance by the time
-    `init` runs, so any code that requires these values should work at that
-    time.
-  * Using native classes, and switching back to the old Ember Object model is
-    fully supported.
-
-  @class CoreObject
-  @public
-*/
-
-class CoreObject {
-  /** @internal */
-  [OWNER];
-  constructor(owner) {
-    this[OWNER] = owner;
-
-    // prepare prototype...
-    this.constructor.proto();
-    let self;
-    if (isDevelopingApp() && hasUnknownProperty(this)) {
-      let messageFor = (obj, property) => {
-        return `You attempted to access the \`${String(property)}\` property (of ${obj}).\n` + `Since Ember 3.1, this is usually fine as you no longer need to use \`.get()\`\n` + `to access computed properties. However, in this case, the object in question\n` + `is a special kind of Ember object (a proxy). Therefore, it is still necessary\n` + `to use \`.get('${String(property)}')\` in this case.\n\n` + `If you encountered this error because of third-party code that you don't control,\n` + `there is more information at https://github.com/emberjs/ember.js/issues/16148, and\n` + `you can help us improve this error message by telling us more about what happened in\n` + `this situation.`;
-      };
-
-      /* globals Proxy Reflect */
-      self = new Proxy(this, {
-        get(target, property, receiver) {
-          if (property === PROXY_CONTENT) {
-            return target;
-          } else if (
-          // init called will be set on the proxy, not the target, so get with the receiver
-          !initCalled.has(receiver) || typeof property === 'symbol' || isInternalSymbol(property) || property === 'toJSON' || property === 'toString' || property === 'toStringExtension' || property === 'didDefineProperty' || property === 'willWatchProperty' || property === 'didUnwatchProperty' || property === 'didAddListener' || property === 'didRemoveListener' || property === 'isDescriptor' || property === '_onLookup' || property in target) {
-            return Reflect.get(target, property, receiver);
-          }
-          let value = target.unknownProperty.call(receiver, property);
-          if (typeof value !== 'function') {
-            (isDevelopingApp() && !(value === undefined || value === null) && assert(messageFor(receiver, property), value === undefined || value === null));
-          }
-        }
-      });
-    } else {
-      self = this;
-    }
-    const destroyable = self;
-    registerDestructor(self, ensureDestroyCalled, true);
-    registerDestructor(self, () => destroyable.willDestroy());
-
-    // disable chains
-    let m = meta(self);
-    m.setInitializing();
-
-    // only return when in debug builds and `self` is the proxy created above
-    if (isDevelopingApp() && self !== this) {
-      return self;
-    }
-  }
-  reopen(...args) {
-    applyMixin(this, args);
-    return this;
-  }
-
-  /**
-    An overridable method called when objects are instantiated. By default,
-    does nothing unless it is overridden during class definition.
-     Example:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      init() {
-        alert(`Name is ${this.get('name')}`);
-      }
-    });
-     let steve = Person.create({
-      name: 'Steve'
-    });
-     // alerts 'Name is Steve'.
-    ```
-     NOTE: If you do override `init` for a framework class like `Component`
-    from `@ember/component`, be sure to call `this._super(...arguments)`
-    in your `init` declaration!
-    If you don't, Ember may not have an opportunity to
-    do important setup work, and you'll see strange behavior in your
-    application.
-     @method init
-    @public
-  */
-  init(_properties) {}
-
-  /**
-    Defines the properties that will be concatenated from the superclass
-    (instead of overridden).
-     By default, when you extend an Ember class a property defined in
-    the subclass overrides a property with the same name that is defined
-    in the superclass. However, there are some cases where it is preferable
-    to build up a property's value by combining the superclass' property
-    value with the subclass' value. An example of this in use within Ember
-    is the `classNames` property of `Component` from `@ember/component`.
-     Here is some sample code showing the difference between a concatenated
-    property and a normal one:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Bar = EmberObject.extend({
-      // Configure which properties to concatenate
-      concatenatedProperties: ['concatenatedProperty'],
-       someNonConcatenatedProperty: ['bar'],
-      concatenatedProperty: ['bar']
-    });
-     const FooBar = Bar.extend({
-      someNonConcatenatedProperty: ['foo'],
-      concatenatedProperty: ['foo']
-    });
-     let fooBar = FooBar.create();
-    fooBar.get('someNonConcatenatedProperty'); // ['foo']
-    fooBar.get('concatenatedProperty'); // ['bar', 'foo']
-    ```
-     This behavior extends to object creation as well. Continuing the
-    above example:
-     ```javascript
-    let fooBar = FooBar.create({
-      someNonConcatenatedProperty: ['baz'],
-      concatenatedProperty: ['baz']
-    })
-    fooBar.get('someNonConcatenatedProperty'); // ['baz']
-    fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
-    ```
-     Adding a single property that is not an array will just add it in the array:
-     ```javascript
-    let fooBar = FooBar.create({
-      concatenatedProperty: 'baz'
-    })
-    view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']
-    ```
-     Using the `concatenatedProperties` property, we can tell Ember to mix the
-    content of the properties.
-     In `Component` the `classNames`, `classNameBindings` and
-    `attributeBindings` properties are concatenated.
-     This feature is available for you to use throughout the Ember object model,
-    although typical app developers are likely to use it infrequently. Since
-    it changes expectations about behavior of properties, you should properly
-    document its usage in each individual concatenated property (to not
-    mislead your users to think they can override the property in a subclass).
-     @property concatenatedProperties
-    @type Array
-    @default null
-    @public
-  */
-
-  /**
-    Defines the properties that will be merged from the superclass
-    (instead of overridden).
-     By default, when you extend an Ember class a property defined in
-    the subclass overrides a property with the same name that is defined
-    in the superclass. However, there are some cases where it is preferable
-    to build up a property's value by merging the superclass property value
-    with the subclass property's value. An example of this in use within Ember
-    is the `queryParams` property of routes.
-     Here is some sample code showing the difference between a merged
-    property and a normal one:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Bar = EmberObject.extend({
-      // Configure which properties are to be merged
-      mergedProperties: ['mergedProperty'],
-       someNonMergedProperty: {
-        nonMerged: 'superclass value of nonMerged'
-      },
-      mergedProperty: {
-        page: { replace: false },
-        limit: { replace: true }
-      }
-    });
-     const FooBar = Bar.extend({
-      someNonMergedProperty: {
-        completelyNonMerged: 'subclass value of nonMerged'
-      },
-      mergedProperty: {
-        limit: { replace: false }
-      }
-    });
-     let fooBar = FooBar.create();
-     fooBar.get('someNonMergedProperty');
-    // => { completelyNonMerged: 'subclass value of nonMerged' }
-    //
-    // Note the entire object, including the nonMerged property of
-    // the superclass object, has been replaced
-     fooBar.get('mergedProperty');
-    // => {
-    //   page: {replace: false},
-    //   limit: {replace: false}
-    // }
-    //
-    // Note the page remains from the superclass, and the
-    // `limit` property's value of `false` has been merged from
-    // the subclass.
-    ```
-     This behavior is not available during object `create` calls. It is only
-    available at `extend` time.
-     In `Route` the `queryParams` property is merged.
-     This feature is available for you to use throughout the Ember object model,
-    although typical app developers are likely to use it infrequently. Since
-    it changes expectations about behavior of properties, you should properly
-    document its usage in each individual merged property (to not
-    mislead your users to think they can override the property in a subclass).
-     @property mergedProperties
-    @type Array
-    @default null
-    @public
-  */
-
-  /**
-    Destroyed object property flag.
-     if this property is `true` the observers and bindings were already
-    removed by the effect of calling the `destroy()` method.
-     @property isDestroyed
-    @default false
-    @public
-  */
-  get isDestroyed() {
-    return isDestroyed(this);
-  }
-  set isDestroyed(_value) {
-    (isDevelopingApp() && !(false) && assert(`You cannot set \`${this}.isDestroyed\` directly, please use \`.destroy()\`.`, false));
-  }
-
-  /**
-    Destruction scheduled flag. The `destroy()` method has been called.
-     The object stays intact until the end of the run loop at which point
-    the `isDestroyed` flag is set.
-     @property isDestroying
-    @default false
-    @public
-  */
-  get isDestroying() {
-    return isDestroying(this);
-  }
-  set isDestroying(_value) {
-    (isDevelopingApp() && !(false) && assert(`You cannot set \`${this}.isDestroying\` directly, please use \`.destroy()\`.`, false));
-  }
-
-  /**
-    Destroys an object by setting the `isDestroyed` flag and removing its
-    metadata, which effectively destroys observers and bindings.
-     If you try to set a property on a destroyed object, an exception will be
-    raised.
-     Note that destruction is scheduled for the end of the run loop and does not
-    happen immediately.  It will set an isDestroying flag immediately.
-     @method destroy
-    @return {EmberObject} receiver
-    @public
-  */
-  destroy() {
-    // Used to ensure that manually calling `.destroy()` does not immediately call destroy again
-    destroyCalled.add(this);
-    try {
-      destroy(this);
-    } finally {
-      destroyCalled.delete(this);
-    }
-    return this;
-  }
-
-  /**
-    Override to implement teardown.
-     @method willDestroy
-    @public
-  */
-  willDestroy() {}
-
-  /**
-    Returns a string representation which attempts to provide more information
-    than Javascript's `toString` typically does, in a generic way for all Ember
-    objects.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend();
-    person = Person.create();
-    person.toString(); //=> "<Person:ember1024>"
-    ```
-     If the object's class is not defined on an Ember namespace, it will
-    indicate it is a subclass of the registered superclass:
-     ```javascript
-    const Student = Person.extend();
-    let student = Student.create();
-    student.toString(); //=> "<(subclass of Person):ember1025>"
-    ```
-     If the method `toStringExtension` is defined, its return value will be
-    included in the output.
-     ```javascript
-    const Teacher = Person.extend({
-      toStringExtension() {
-        return this.get('fullName');
-      }
-    });
-    teacher = Teacher.create();
-    teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
-    ```
-     @method toString
-    @return {String} string representation
-    @public
-  */
-  toString() {
-    let extension = hasToStringExtension(this) ? `:${this.toStringExtension()}` : '';
-    return `<${getFactoryFor(this) || '(unknown)'}:${guidFor(this)}${extension}>`;
-  }
-
-  /**
-    Creates a new subclass.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      say(thing) {
-        alert(thing);
-       }
-    });
-    ```
-     This defines a new subclass of EmberObject: `Person`. It contains one method: `say()`.
-     You can also create a subclass from any existing class by calling its `extend()` method.
-    For example, you might want to create a subclass of Ember's built-in `Component` class:
-     ```javascript
-    import Component from '@ember/component';
-     const PersonComponent = Component.extend({
-      tagName: 'li',
-      classNameBindings: ['isAdministrator']
-    });
-    ```
-     When defining a subclass, you can override methods but still access the
-    implementation of your parent class by calling the special `_super()` method:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      say(thing) {
-        let name = this.get('name');
-        alert(`${name} says: ${thing}`);
-      }
-    });
-     const Soldier = Person.extend({
-      say(thing) {
-        this._super(`${thing}, sir!`);
-      },
-      march(numberOfHours) {
-        alert(`${this.get('name')} marches for ${numberOfHours} hours.`);
-      }
-    });
-     let yehuda = Soldier.create({
-      name: 'Yehuda Katz'
-    });
-     yehuda.say('Yes');  // alerts "Yehuda Katz says: Yes, sir!"
-    ```
-     The `create()` on line #17 creates an *instance* of the `Soldier` class.
-    The `extend()` on line #8 creates a *subclass* of `Person`. Any instance
-    of the `Person` class will *not* have the `march()` method.
-     You can also pass `Mixin` classes to add additional properties to the subclass.
-     ```javascript
-    import EmberObject from '@ember/object';
-    import Mixin from '@ember/object/mixin';
-     const Person = EmberObject.extend({
-      say(thing) {
-        alert(`${this.get('name')} says: ${thing}`);
-      }
-    });
-     const SingingMixin = Mixin.create({
-      sing(thing) {
-        alert(`${this.get('name')} sings: la la la ${thing}`);
-      }
-    });
-     const BroadwayStar = Person.extend(SingingMixin, {
-      dance() {
-        alert(`${this.get('name')} dances: tap tap tap tap `);
-      }
-    });
-    ```
-     The `BroadwayStar` class contains three methods: `say()`, `sing()`, and `dance()`.
-     @method extend
-    @static
-    @for @ember/object
-    @param {Mixin} [mixins]* One or more Mixin classes
-    @param {Object} [arguments]* Object containing values to use within the new class
-    @public
-  */
-
-  static extend(...mixins) {
-    let Class = class extends this {};
-    reopen.apply(Class.PrototypeMixin, mixins);
-    return Class;
-  }
-
-  /**
-    Creates an instance of a class. Accepts either no arguments, or an object
-    containing values to initialize the newly instantiated object with.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      helloWorld() {
-        alert(`Hi, my name is ${this.get('name')}`);
-      }
-    });
-     let tom = Person.create({
-      name: 'Tom Dale'
-    });
-     tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
-    ```
-     `create` will call the `init` function if defined during
-    `AnyObject.extend`
-     If no arguments are passed to `create`, it will not set values to the new
-    instance during initialization:
-     ```javascript
-    let noName = Person.create();
-    noName.helloWorld(); // alerts undefined
-    ```
-     NOTE: For performance reasons, you cannot declare methods or computed
-    properties during `create`. You should instead declare methods and computed
-    properties when using `extend`.
-     @method create
-    @for @ember/object
-    @static
-    @param [arguments]*
-    @public
-  */
-
-  static create(...args) {
-    let props = args[0];
-    let instance;
-    if (props !== undefined) {
-      instance = new this(getOwner(props));
-      // TODO(SAFETY): at present, we cannot actually rely on this being set,
-      // because a number of acceptance tests are (incorrectly? Unclear!)
-      // relying on the ability to run through this path with `factory` being
-      // `undefined`. It's *possible* that actually means that the type for
-      // `setFactoryFor()` should allow `undefined`, but we typed it the other
-      // way for good reason! Accordingly, this *casts* `factory`, and the
-      // commented-out `assert()` is here in the hope that we can enable it
-      // after addressing tests *or* updating the call signature here.
-      let factory = getFactoryFor(props);
-      // assert(`missing factory when creating object ${instance}`, factory !== undefined);
-      setFactoryFor(instance, factory);
-    } else {
-      instance = new this();
-    }
-    if (args.length <= 1) {
-      initialize(instance, props);
-    } else {
-      initialize(instance, flattenProps.apply(this, args));
-    }
-
-    // SAFETY: The `initialize` call is responsible to merge the prototype chain
-    // so that this holds.
-    return instance;
-  }
-
-  /**
-    Augments a constructor's prototype with additional
-    properties and functions:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const MyObject = EmberObject.extend({
-      name: 'an object'
-    });
-     o = MyObject.create();
-    o.get('name'); // 'an object'
-     MyObject.reopen({
-      say(msg) {
-        console.log(msg);
-      }
-    });
-     o2 = MyObject.create();
-    o2.say('hello'); // logs "hello"
-     o.say('goodbye'); // logs "goodbye"
-    ```
-     To add functions and properties to the constructor itself,
-    see `reopenClass`
-     @method reopen
-    @for @ember/object
-    @static
-    @public
-  */
-  static reopen(...args) {
-    this.willReopen();
-    reopen.apply(this.PrototypeMixin, args);
-    return this;
-  }
-  static willReopen() {
-    let p = this.prototype;
-    if (wasApplied.has(p)) {
-      wasApplied.delete(p);
-
-      // If the base mixin already exists and was applied, create a new mixin to
-      // make sure that it gets properly applied. Reusing the same mixin after
-      // the first `proto` call will cause it to get skipped.
-      if (prototypeMixinMap.has(this)) {
-        prototypeMixinMap.set(this, Mixin.create(this.PrototypeMixin));
-      }
-    }
-  }
-
-  /**
-    Augments a constructor's own properties and functions:
-     ```javascript
-    import EmberObject from '@ember/object';
-     const MyObject = EmberObject.extend({
-      name: 'an object'
-    });
-     MyObject.reopenClass({
-      canBuild: false
-    });
-     MyObject.canBuild; // false
-    o = MyObject.create();
-    ```
-     In other words, this creates static properties and functions for the class.
-    These are only available on the class and not on any instance of that class.
-     ```javascript
-    import EmberObject from '@ember/object';
-     const Person = EmberObject.extend({
-      name: '',
-      sayHello() {
-        alert(`Hello. My name is ${this.get('name')}`);
-      }
-    });
-     Person.reopenClass({
-      species: 'Homo sapiens',
-       createPerson(name) {
-        return Person.create({ name });
-      }
-    });
-     let tom = Person.create({
-      name: 'Tom Dale'
-    });
-    let yehuda = Person.createPerson('Yehuda Katz');
-     tom.sayHello(); // "Hello. My name is Tom Dale"
-    yehuda.sayHello(); // "Hello. My name is Yehuda Katz"
-    alert(Person.species); // "Homo sapiens"
-    ```
-     Note that `species` and `createPerson` are *not* valid on the `tom` and `yehuda`
-    variables. They are only valid on `Person`.
-     To add functions and properties to instances of
-    a constructor by extending the constructor's prototype
-    see `reopen`
-     @method reopenClass
-    @for @ember/object
-    @static
-    @public
-  */
-  static reopenClass(...mixins) {
-    applyMixin(this, mixins);
-    return this;
-  }
-  static detect(obj) {
-    if ('function' !== typeof obj) {
-      return false;
-    }
-    while (obj) {
-      if (obj === this) {
-        return true;
-      }
-      obj = obj.superclass;
-    }
-    return false;
-  }
-  static detectInstance(obj) {
-    return obj instanceof this;
-  }
-
-  /**
-    In some cases, you may want to annotate computed properties with additional
-    metadata about how they function or what values they operate on. For
-    example, computed property functions may close over variables that are then
-    no longer available for introspection.
-     You can pass a hash of these values to a computed property like this:
-     ```javascript
-    import { computed } from '@ember/object';
-     person: computed(function() {
-      let personId = this.get('personId');
-      return Person.create({ id: personId });
-    }).meta({ type: Person })
-    ```
-     Once you've done this, you can retrieve the values saved to the computed
-    property from your class like this:
-     ```javascript
-    MyClass.metaForProperty('person');
-    ```
-     This will return the original hash that was passed to `meta()`.
-     @static
-    @method metaForProperty
-    @param key {String} property name
-    @private
-  */
-  static metaForProperty(key) {
-    let proto = this.proto(); // ensure prototype is initialized
-    let possibleDesc = descriptorForProperty(proto, key);
-    (isDevelopingApp() && !(possibleDesc !== undefined) && assert(`metaForProperty() could not find a computed property with key '${key}'.`, possibleDesc !== undefined));
-    return possibleDesc._meta || {};
-  }
-
-  /**
-    Iterate over each computed property for the class, passing its name
-    and any associated metadata (see `metaForProperty`) to the callback.
-     @static
-    @method eachComputedProperty
-    @param {Function} callback
-    @param {Object} binding
-    @private
-  */
-  static eachComputedProperty(callback, binding = this) {
-    this.proto(); // ensure prototype is initialized
-    let empty = {};
-    meta(this.prototype).forEachDescriptors((name, descriptor) => {
-      if (descriptor.enumerable) {
-        let meta = descriptor._meta || empty;
-        callback.call(binding, name, meta);
-      }
-    });
-  }
-  static get PrototypeMixin() {
-    let prototypeMixin = prototypeMixinMap.get(this);
-    if (prototypeMixin === undefined) {
-      prototypeMixin = Mixin.create();
-      prototypeMixin.ownerConstructor = this;
-      prototypeMixinMap.set(this, prototypeMixin);
-    }
-    return prototypeMixin;
-  }
-  static get superclass() {
-    let c = Object.getPrototypeOf(this);
-    return c !== Function.prototype ? c : undefined;
-  }
-  static proto() {
-    let p = this.prototype;
-    if (!wasApplied.has(p)) {
-      wasApplied.add(p);
-      let parent = this.superclass;
-      if (parent) {
-        parent.proto();
-      }
-
-      // If the prototype mixin exists, apply it. In the case of native classes,
-      // it will not exist (unless the class has been reopened).
-      if (prototypeMixinMap.has(this)) {
-        this.PrototypeMixin.apply(p);
-      }
-    }
-    return p;
-  }
-  static toString() {
-    return `<${getFactoryFor(this) || '(unknown)'}:constructor>`;
-  }
-  static isClass = true;
-  static isMethod = false;
-  static _onLookup;
-  static _lazyInjections;
-}
-function flattenProps(...props) {
-  let initProperties = {};
-  for (let properties of props) {
-    (isDevelopingApp() && !(!(properties instanceof Mixin)) && assert('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof Mixin)));
-    let keyNames = Object.keys(properties);
-    for (let j = 0, k = keyNames.length; j < k; j++) {
-      let keyName = keyNames[j];
-      let value = properties[keyName];
-      initProperties[keyName] = value;
-    }
-  }
-  return initProperties;
-}
-if (isDevelopingApp()) {
-  /**
-    Provides lookup-time type validation for injected properties.
-     @private
-    @method _onLookup
-  */
-  CoreObject._onLookup = function injectedPropertyAssertion(debugContainerKey) {
-    let [type] = debugContainerKey.split(':');
-    let proto = this.proto();
-    for (let key in proto) {
-      let desc = descriptorForProperty(proto, key);
-      if (desc && DEBUG_INJECTION_FUNCTIONS.has(desc._getter)) {
-        (isDevelopingApp() && !(type === 'controller' || DEBUG_INJECTION_FUNCTIONS.get(desc._getter).type !== 'controller') && assert(`Defining \`${key}\` as an injected controller property on a non-controller (\`${debugContainerKey}\`) is not allowed.`, type === 'controller' || DEBUG_INJECTION_FUNCTIONS.get(desc._getter).type !== 'controller'));
-      }
-    }
-  };
-
-  /**
-    Returns a hash of property names and container names that injected
-    properties will lookup on the container lazily.
-     @method _lazyInjections
-    @return {Object} Hash of all lazy injected property keys to container names
-    @private
-  */
-  CoreObject._lazyInjections = function () {
-    let injections = {};
-    let proto = this.proto();
-    let key;
-    let desc;
-    for (key in proto) {
-      desc = descriptorForProperty(proto, key);
-      if (desc && DEBUG_INJECTION_FUNCTIONS.has(desc._getter)) {
-        let {
-          namespace,
-          source,
-          type,
-          name
-        } = DEBUG_INJECTION_FUNCTIONS.get(desc._getter);
-        injections[key] = {
-          namespace,
-          source,
-          specifier: `${type}:${name || key}`
-        };
-      }
-    }
-    return injections;
-  };
-}
-const EmberCoreObject = CoreObject;
-
-/**
-@module @ember/object
-*/
-
-/**
-  `EmberObject` is the main base class for all Ember objects. It is a subclass
-  of `CoreObject` with the `Observable` mixin applied. For details,
-  see the documentation for each of these.
-
-  @class EmberObject
-  @extends CoreObject
-  @uses Observable
-  @public
-*/
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-
-class EmberObject extends EmberCoreObject.extend(Observable) {
-  get _debugContainerKey() {
-    let factory = getFactoryFor(this);
-    return factory !== undefined && factory.fullName;
-  }
-}
-
-/**
-  Decorator that turns the target function into an Action which can be accessed
-  directly by reference.
-
-  ```js
-  import Component from '@ember/component';
-  import { action, set } from '@ember/object';
-
-  export default class Tooltip extends Component {
-    @action
-    toggleShowing() {
-      set(this, 'isShowing', !this.isShowing);
-    }
-  }
-  ```
-  ```hbs
-  <!-- template.hbs -->
-  <button {{action this.toggleShowing}}>Show tooltip</button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
-
-  Decorated actions also interop with the string style template actions:
-
-  ```hbs
-  <!-- template.hbs -->
-  <button {{action "toggleShowing"}}>Show tooltip</button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
-
-  It also binds the function directly to the instance, so it can be used in any
-  context and will correctly refer to the class it came from:
-
-  ```hbs
-  <!-- template.hbs -->
-  <button
-    {{did-insert this.toggleShowing}}
-    {{on "click" this.toggleShowing}}
-  >
-    Show tooltip
-  </button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
-
-  This can also be used in JavaScript code directly:
-
-  ```js
-  import Component from '@ember/component';
-  import { action, set } from '@ember/object';
-
-  export default class Tooltip extends Component {
-    constructor() {
-      super(...arguments);
-
-      // this.toggleShowing is still bound correctly when added to
-      // the event listener
-      document.addEventListener('click', this.toggleShowing);
-    }
-
-    @action
-    toggleShowing() {
-      set(this, 'isShowing', !this.isShowing);
-    }
-  }
-  ```
-
-  This is considered best practice, since it means that methods will be bound
-  correctly no matter where they are used. By contrast, the `{{action}}` helper
-  and modifier can also be used to bind context, but it will be required for
-  every usage of the method:
-
-  ```hbs
-  <!-- template.hbs -->
-  <button
-    {{did-insert (action this.toggleShowing)}}
-    {{on "click" (action this.toggleShowing)}}
-  >
-    Show tooltip
-  </button>
-
-  {{#if isShowing}}
-    <div class="tooltip">
-      I'm a tooltip!
-    </div>
-  {{/if}}
-  ```
-
-  They also do not have equivalents in JavaScript directly, so they cannot be
-  used for other situations where binding would be useful.
-
-  @public
-  @method action
-  @for @ember/object
-  @static
-  @param {Function|undefined} callback The function to turn into an action,
-                                       when used in classic classes
-  @return {PropertyDecorator} property decorator instance
-*/
-
-const BINDINGS_MAP = new WeakMap();
-function hasProto(obj) {
-  return obj != null && obj.constructor !== undefined && typeof obj.constructor.proto === 'function';
-}
-function setupAction(target, key, actionFn) {
-  if (hasProto(target)) {
-    target.constructor.proto();
-  }
-  if (!Object.prototype.hasOwnProperty.call(target, 'actions')) {
-    let parentActions = target.actions;
-    // we need to assign because of the way mixins copy actions down when inheriting
-    target.actions = parentActions ? Object.assign({}, parentActions) : {};
-  }
-  (isDevelopingApp() && !(target.actions != null) && assert("[BUG] Somehow the target doesn't have actions!", target.actions != null));
-  target.actions[key] = actionFn;
-  return {
-    get() {
-      let bindings = BINDINGS_MAP.get(this);
-      if (bindings === undefined) {
-        bindings = new Map();
-        BINDINGS_MAP.set(this, bindings);
-      }
-      let fn = bindings.get(actionFn);
-      if (fn === undefined) {
-        fn = actionFn.bind(this);
-        bindings.set(actionFn, fn);
-      }
-      return fn;
-    }
-  };
-}
-function action(...args) {
-  let actionFn;
-  if (!isElementDescriptor(args)) {
-    actionFn = args[0];
-    let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
-      (isDevelopingApp() && !(isClassicDecorator) && assert('The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes', isClassicDecorator));
-      (isDevelopingApp() && !(typeof actionFn === 'function') && assert('The action() decorator must be passed a method when used in classic classes', typeof actionFn === 'function'));
-      return setupAction(target, key, actionFn);
-    };
-    setClassicDecorator(decorator);
-    return decorator;
-  }
-  let [target, key, desc] = args;
-  actionFn = desc?.value;
-  (isDevelopingApp() && !(typeof actionFn === 'function') && assert('The @action decorator must be applied to methods when used in native classes', typeof actionFn === 'function')); // SAFETY: TS types are weird with decorators. This should work.
-  return setupAction(target, key, actionFn);
-}
-
-// SAFETY: TS types are weird with decorators. This should work.
-setClassicDecorator(action);
-
-// ..........................................................
-// OBSERVER HELPER
-//
-
-/**
-  Specify a method that observes property changes.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { observer } from '@ember/object';
-
-  export default EmberObject.extend({
-    valueObserver: observer('value', function() {
-      // Executes whenever the "value" property changes
-    })
-  });
-  ```
-
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
-  @method observer
-  @for @ember/object
-  @param {String} propertyNames*
-  @param {Function} func
-  @return func
-  @public
-  @static
-*/
-function observer(...args) {
-  let funcOrDef = args.pop();
-  (isDevelopingApp() && !(typeof funcOrDef === 'function' || typeof funcOrDef === 'object' && funcOrDef !== null) && assert('observer must be provided a function or an observer definition', typeof funcOrDef === 'function' || typeof funcOrDef === 'object' && funcOrDef !== null));
-  let func;
-  let dependentKeys;
-  let sync;
-  if (typeof funcOrDef === 'function') {
-    func = funcOrDef;
-    dependentKeys = args;
-    sync = !ENV._DEFAULT_ASYNC_OBSERVERS;
-  } else {
-    func = funcOrDef.fn;
-    dependentKeys = funcOrDef.dependentKeys;
-    sync = funcOrDef.sync;
-  }
-  (isDevelopingApp() && !(typeof func === 'function') && assert('observer called without a function', typeof func === 'function'));
-  (isDevelopingApp() && !(Array.isArray(dependentKeys) && dependentKeys.length > 0 && dependentKeys.every(p => typeof p === 'string' && Boolean(p.length))) && assert('observer called without valid path', Array.isArray(dependentKeys) && dependentKeys.length > 0 && dependentKeys.every(p => typeof p === 'string' && Boolean(p.length))));
-  (isDevelopingApp() && !(typeof sync === 'boolean') && assert('observer called without sync', typeof sync === 'boolean'));
-  let paths = [];
-  for (let dependentKey of dependentKeys) {
-    expandProperties(dependentKey, path => paths.push(path));
-  }
-  setObservers(func, {
-    paths,
-    sync
-  });
-  return func;
-}
-
-export { A, EmberObject as E, MutableArray as M, NativeArray as N, Observable as O, EmberArray as a, action as b, compare as c, EmberCoreObject as d, isArray as i, observer as o, removeAt as r, typeOf as t, uniqBy as u };