ember-source 5.11.0 → 5.11.1

package/dist/packages/@ember/application/namespace.js

@@ -1,14 +1,15 @@
 import '../-internals/meta/lib/meta.js';
-import { g as guidFor } from '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
+import { g as guidFor } from '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
 import { isDevelopingApp } from '@embroider/macros';
-import { g as getName, s as setName } from '../../shared-chunks/name-z9D9Yibn.js';
-import { a as assert } from '../../shared-chunks/index-DTxy4Zgx.js';
+import { g as getName, s as setName } from '../../shared-chunks/name-Dx2bGFVv.js';
+import '../debug/index.js';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/validator/index.js';
-import { g as get } from '../../shared-chunks/cache-gDE3bkXq.js';
 import '../../@glimmer/manager/index.js';
-import { N as NAMESPACES, a as NAMESPACES_BY_ID, p as processAllNamespaces, f as findNamespace, b as addNamespace, c as findNamespaces, d as processNamespace, r as removeNamespace } from '../../shared-chunks/namespace_search-CBgHTkDh.js';
-import { E as EmberObject } from '../../shared-chunks/index-PYiGj1jp.js';
+import { g as get } from '../../shared-chunks/cache-BESCGvbE.js';
+import { N as NAMESPACES, a as NAMESPACES_BY_ID, p as processAllNamespaces, f as findNamespace, b as addNamespace, c as findNamespaces, d as processNamespace, r as removeNamespace } from '../../shared-chunks/namespace_search-btMaPM-_.js';
+import EmberObject from '../object/index.js';
+import { assert } from '../debug/lib/assert.js';
 
 /**
 @module @ember/application/namespace

package/dist/packages/@ember/array/index.js

@@ -1,16 +1,622 @@
-import '../../shared-chunks/cache-gDE3bkXq.js';
+import { o as objectAt, g as get, l as endPropertyChanges, P as PROXY_CONTENT, c as computed, m as beginPropertyChanges } from '../../shared-chunks/cache-BESCGvbE.js';
 import '../-internals/meta/lib/meta.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
+import '../debug/index.js';
 import '../../@glimmer/validator/index.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
-import '@embroider/macros';
+import '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
+import { isDevelopingApp } from '@embroider/macros';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/manager/index.js';
-import '../../shared-chunks/property_set-CW4q-uo4.js';
-import '../../shared-chunks/env-BJLX2Arx.js';
-export { A, M as MutableArray, N as NativeArray, a as default, i as isArray, r as removeAt, u as uniqBy } from '../../shared-chunks/index-PYiGj1jp.js';
-import '../object/mixin.js';
-import '../enumerable/index.js';
-import '../enumerable/mutable.js';
-import './-internals.js';
+import { s as set } from '../../shared-chunks/property_set-BapAkp3X.js';
+import { r as replaceInNativeArray, a as replace } from '../../shared-chunks/array-3xbmc_4J.js';
+import { E as ENV } from '../../shared-chunks/env-BJLX2Arx.js';
+import '../object/index.js';
+import Mixin from '../object/mixin.js';
+import Enumerable from '../enumerable/index.js';
+import MutableEnumerable from '../enumerable/mutable.js';
+import typeOf from '../utils/lib/type-of.js';
+import compare from '../utils/lib/compare.js';
+import Observable from '../object/observable.js';
+import { setEmberArray, isEmberArray } from './-internals.js';
 export { default as makeArray } from './lib/make-array.js';
+import { assert } from '../debug/lib/assert.js';
+
+/**
+@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 ?? []);
+    }
+  };
+}
+
+export { A, MutableArray, NativeArray, EmberArray as default, isArray, removeAt, uniqBy };

package/dist/packages/@ember/array/make.js

@@ -0,0 +1 @@
+export { default } from './lib/make-array.js';

package/dist/packages/@ember/array/mutable.js

@@ -1 +1 @@
-export { M as default } from '../../shared-chunks/index-PYiGj1jp.js';
+export { MutableArray as default } from './index.js';

package/dist/packages/@ember/array/proxy.js

@@ -1,14 +1,17 @@
 import '../-internals/meta/lib/meta.js';
-import { e as isObject } from '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
+import { e as isObject } from '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
 import { isDevelopingApp } from '@embroider/macros';
-import { a as assert } from '../../shared-chunks/index-DTxy4Zgx.js';
+import '../debug/index.js';
 import '../../@glimmer/destroyable/index.js';
 import { consumeTag, validateTag, tagFor, valueForTag, combine } from '../../@glimmer/validator/index.js';
-import { Q as PROPERTY_DID_CHANGE, g as get, R as objectAt, S as replace, T as arrayContentWillChange, U as arrayContentDidChange, V as addArrayObserver, W as removeArrayObserver, a as tagForProperty } from '../../shared-chunks/cache-gDE3bkXq.js';
-import { a as alias } from '../../shared-chunks/alias-By_2yu5c.js';
+import { Q as PROPERTY_DID_CHANGE, g as get, o as objectAt, a as tagForProperty } from '../../shared-chunks/cache-BESCGvbE.js';
+import { a as alias } from '../../shared-chunks/alias-Dri0koi2.js';
+import { a as replace, b as arrayContentWillChange, c as arrayContentDidChange, d as addArrayObserver, e as removeArrayObserver } from '../../shared-chunks/array-3xbmc_4J.js';
 import '../../shared-chunks/env-BJLX2Arx.js';
-import { M as MutableArray, E as EmberObject, a as EmberArray } from '../../shared-chunks/index-PYiGj1jp.js';
+import EmberObject from '../object/index.js';
+import EmberArray, { MutableArray } from './index.js';
 import { setCustomTagFor } from '../../@glimmer/manager/index.js';
+import { assert } from '../debug/lib/assert.js';
 
 /**
 @module @ember/array/proxy