ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/{packages → dev/packages}/@ember/utils/lib/compare.js

@@ -8,7 +8,6 @@ import '../../enumerable/mutable.js';
 import '../../-internals/runtime/lib/mixins/target_action_support.js';
 import '../../-internals/runtime/lib/ext/rsvp.js';
 import '../../debug/index.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../debug/lib/assert.js';
 
 const TYPE_ORDER = {
@@ -122,17 +121,17 @@ function compare(v, w) {
   // 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'));
+      (!(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'));
+      (!(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'));
+      (!(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)));
+        (!(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);
@@ -153,7 +152,7 @@ function compare(v, w) {
       }
       return 0;
     case 'date':
-      (isDevelopingApp() && !(v instanceof Date && w instanceof Date) && assert('both are dates', v instanceof Date && w instanceof Date));
+      (!(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;

package/dist/{packages → dev/packages}/@ember/utils/lib/is_empty.js

@@ -1,16 +1,15 @@
 import '../../object/index.js';
 import '../../-internals/meta/lib/meta.js';
-import '../../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import '@embroider/macros';
+import '../../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import '../../debug/index.js';
 import '../../../@glimmer/destroyable/index.js';
 import '../../../@glimmer/validator/index.js';
-import '../../../shared-chunks/debug-to-string-BsFOvUtQ.js';
+import '../../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import '../../../@glimmer/global-context/index.js';
-import '../../../shared-chunks/reference-B6HMX4y0.js';
-import '../../../shared-chunks/capabilities-DHiXCCuB.js';
-import { h as hasUnknownProperty, g as get } from '../../../shared-chunks/observers-DhgQ6ba5.js';
-import '../../../shared-chunks/env-DEd6hPbj.js';
+import '../../../shared-chunks/reference-C3TKDRnP.js';
+import '../../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { h as hasUnknownProperty, g as get } from '../../../shared-chunks/observers-Bj9qLVau.js';
+import '../../-internals/environment/index.js';
 
 /**
  @module @ember/utils

package/dist/{packages → dev/packages}/@glimmer/destroyable/index.js

@@ -1,37 +1,42 @@
-import { d as debugToString } from '../../shared-chunks/debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { d as debugToString } from '../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import { scheduleDestroyed, scheduleDestroy } from '../global-context/index.js';
 
 const LIVE_STATE = 0;
 const DESTROYING_STATE = 1;
 const DESTROYED_STATE = 2;
 let DESTROYABLE_META = new WeakMap();
+const branded = Symbol('BrandedArray');
+function isBrandedArray(collection) {
+  return Array.isArray(collection) && branded in collection;
+}
 function push(collection, newItem) {
   if (collection === null) {
     return newItem;
-  } else if (Array.isArray(collection)) {
+  } else if (isBrandedArray(collection)) {
     collection.push(newItem);
     return collection;
   } else {
-    return [collection, newItem];
+    const b = [collection, newItem];
+    b[branded] = true;
+    return b;
   }
 }
 function iterate(collection, fn) {
-  if (Array.isArray(collection)) {
+  if (isBrandedArray(collection)) {
     collection.forEach(fn);
   } else if (collection !== null) {
     fn(collection);
   }
 }
 function remove(collection, item, message) {
-  if (isDevelopingApp()) {
+  {
     let collectionIsItem = collection === item;
-    let collectionContainsItem = Array.isArray(collection) && collection.indexOf(item) !== -1;
+    let collectionContainsItem = isBrandedArray(collection) && collection.indexOf(item) !== -1;
     if (!collectionIsItem && !collectionContainsItem) {
       throw new Error(String(message));
     }
   }
-  if (Array.isArray(collection) && collection.length > 1) {
+  if (isBrandedArray(collection) && collection.length > 1) {
     let index = collection.indexOf(item);
     collection.splice(index, 1);
     return collection;
@@ -49,7 +54,7 @@ function getDestroyableMeta(destroyable) {
       destructors: null,
       state: LIVE_STATE
     };
-    if (isDevelopingApp()) {
+    {
       meta.source = destroyable;
     }
     DESTROYABLE_META.set(destroyable, meta);
@@ -57,7 +62,7 @@ function getDestroyableMeta(destroyable) {
   return meta;
 }
 function associateDestroyableChild(parent, child) {
-  if (isDevelopingApp() && isDestroying(parent)) {
+  if (isDestroying(parent)) {
     throw new Error('Attempted to associate a destroyable child with an object that is already destroying or destroyed');
   }
   let parentMeta = getDestroyableMeta(parent);
@@ -67,7 +72,7 @@ function associateDestroyableChild(parent, child) {
   return child;
 }
 function registerDestructor(destroyable, destructor, eager = false) {
-  if (isDevelopingApp() && isDestroying(destroyable)) {
+  if (isDestroying(destroyable)) {
     throw new Error('Attempted to register a destructor with an object that is already destroying or destroyed');
   }
   let meta = getDestroyableMeta(destroyable);
@@ -76,12 +81,12 @@ function registerDestructor(destroyable, destructor, eager = false) {
   return destructor;
 }
 function unregisterDestructor(destroyable, destructor, eager = false) {
-  if (isDevelopingApp() && isDestroying(destroyable)) {
+  if (isDestroying(destroyable)) {
     throw new Error('Attempted to unregister a destructor with an object that is already destroying or destroyed');
   }
   let meta = getDestroyableMeta(destroyable);
   let destructorsKey = eager ? 'eagerDestructors' : 'destructors';
-  meta[destructorsKey] = remove(meta[destructorsKey], destructor, isDevelopingApp() && 'attempted to remove a destructor that was not registered with the destroyable');
+  meta[destructorsKey] = remove(meta[destructorsKey], destructor, 'attempted to remove a destructor that was not registered with the destroyable');
 }
 
 ////////////
@@ -112,8 +117,8 @@ function destroy(destroyable) {
 }
 function removeChildFromParent(child, parent) {
   let parentMeta = getDestroyableMeta(parent);
-  if (parentMeta.state === LIVE_STATE) {
-    parentMeta.children = remove(parentMeta.children, child, isDevelopingApp() && "attempted to remove child from parent, but the parent's children did not contain the child. This is likely a bug with destructors.");
+  if (parentMeta.state !== DESTROYED_STATE) {
+    parentMeta.children = remove(parentMeta.children, child, "attempted to remove child from parent, but the parent's children did not contain the child. This is likely a bug with destructors.");
   }
 }
 function destroyChildren(destroyable) {
@@ -139,7 +144,7 @@ function isDestroyed(destroyable) {
 
 let enableDestroyableTracking;
 let assertDestroyablesDestroyed;
-if (isDevelopingApp()) {
+{
   let isTesting = false;
   enableDestroyableTracking = () => {
     if (isTesting) {

package/dist/{packages/shared-chunks/encoder-CT1wqYMF.js → dev/packages/@glimmer/encoder/index.js}

@@ -1,5 +1,4 @@
-import { T as TYPE_SIZE, M as MAX_SIZE, A as ARG_SHIFT } from './flags-BsZlvEeR.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { b as TYPE_SIZE, a as MAX_SIZE, A as ARG_SHIFT } from '../../shared-chunks/flags-B9qxc-pB.js';
 
 class InstructionEncoderImpl {
   constructor(buffer) {
@@ -13,7 +12,7 @@ class InstructionEncoderImpl {
     let first = type | machine | arguments.length - 2 << ARG_SHIFT;
     this.buffer.push(first);
     for (const op of args) {
-      if (isDevelopingApp() && typeof op === 'number' && op > MAX_SIZE) {
+      if (typeof op === 'number' && op > MAX_SIZE) {
         throw new Error(`Operand over 32-bits. Got ${op}.`);
       }
       this.buffer.push(op);
@@ -29,4 +28,4 @@ class InstructionEncoderImpl {
   }
 }
 
-export { InstructionEncoderImpl as I };
+export { InstructionEncoderImpl };

package/dist/{packages → dev/packages}/@glimmer/global-context/index.js

@@ -1,5 +1,3 @@
-import { isDevelopingApp } from '@embroider/macros';
-
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
@@ -16,13 +14,16 @@ import { isDevelopingApp } from '@embroider/macros';
  * - Never change over time
  *
  */
+
 //////////
+
 /**
  * Interfaces
  *
  * TODO: Move these into @glimmer/interfaces, move @glimmer/interfaces to
  * @glimmer/internal-interfaces.
  */
+
 //////////
 
 /**
@@ -110,7 +111,7 @@ let warnIfStyleNotTrusted;
  */
 let assert;
 function debugAssert(test, msg, options) {
-  if (isDevelopingApp() && assert) {
+  if (assert) {
     assert(test, typeof msg === 'string' ? msg : msg(), options);
   }
 }
@@ -125,7 +126,7 @@ let deprecate;
 
 let globalContextWasSet = false;
 function setGlobalContext(context) {
-  if (isDevelopingApp()) {
+  {
     if (globalContextWasSet) {
       throw new Error('Attempted to set the global context twice. This should only be set once.');
     }
@@ -146,7 +147,7 @@ function setGlobalContext(context) {
 }
 let assertGlobalContextWasSet;
 let testOverrideGlobalContext;
-if (isDevelopingApp()) {
+{
   assertGlobalContextWasSet = () => {
     if (!globalContextWasSet) {
       throw new Error('The global context for Glimmer VM was not set. You must set these global context functions to let Glimmer VM know how to accomplish certain operations. You can do this by importing `setGlobalContext` from `@glimmer/global-context`');

package/dist/{packages/shared-chunks/api-1B_9SjFR.js → dev/packages/@glimmer/manager/index.js}

@@ -1,13 +1,16 @@
-import { j as setInternalHelperManager, C as CustomHelperManager, k as setInternalModifierManager, s as setInternalComponentManager } from './api-CkUl6KyJ.js';
-import { registerDestructor } from '../@glimmer/destroyable/index.js';
-import { debugAssert } from '../@glimmer/global-context/index.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { untrack, createUpdatableTag } from '../@glimmer/validator/index.js';
-import { d as createConstRef } from './reference-B6HMX4y0.js';
-import { a as argsProxyFor } from './args-proxy-B91L3LRK.js';
-import { b as buildCapabilities, F as FROM_CAPABILITIES } from './capabilities-DHiXCCuB.js';
-import { c as castToBrowser } from './simple-cast-BXTrayoV.js';
+import { i as setInternalHelperManager, C as CustomHelperManager, s as setInternalComponentManager, j as setInternalModifierManager } from '../../shared-chunks/api-BqXkkT0p.js';
+export { e as getInternalComponentManager, g as getInternalHelperManager, d as getInternalModifierManager, a as hasDestroyable, b as hasInternalComponentManager, f as hasInternalHelperManager, k as hasInternalModifierManager, h as hasValue, c as helperCapabilities } from '../../shared-chunks/api-BqXkkT0p.js';
+import { registerDestructor } from '../destroyable/index.js';
+import { debugAssert } from '../global-context/index.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import { untrack, createUpdatableTag } from '../validator/index.js';
+import { a as createConstRef } from '../../shared-chunks/reference-C3TKDRnP.js';
+import { a as argsProxyFor } from '../../shared-chunks/args-proxy-DgXMc9b5.js';
+export { g as getCustomTagFor, s as setCustomTagFor } from '../../shared-chunks/args-proxy-DgXMc9b5.js';
+import { F as FROM_CAPABILITIES, b as buildCapabilities } from '../../shared-chunks/capabilities-O_xc7Yqk.js';
+export { c as capabilityFlagsFrom, h as hasCapability, m as managerHasCapability } from '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { a as castToBrowser } from '../../shared-chunks/simple-cast-DCvJLSin.js';
+export { g as getComponentTemplate, s as setComponentTemplate } from '../../shared-chunks/template-kM-7TTcc.js';
 
 const CAPABILITIES = {
   dynamicLayout: false,
@@ -25,7 +28,7 @@ const CAPABILITIES = {
   hasSubOwner: false
 };
 function componentCapabilities(managerAPI, options = {}) {
-  if (isDevelopingApp() && managerAPI !== '3.13') {
+  if (managerAPI !== '3.13') {
     throw new Error('Invalid component manager compatibility specified');
   }
   let updateHook = Boolean(options.updateHook);
@@ -90,7 +93,7 @@ class CustomComponentManager {
       delegate = factory(owner);
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (!FROM_CAPABILITIES.has(delegate.capabilities)) {
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom component managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.13')\` (imported via \`import { capabilities } from '@ember/component';\`). Received: \`${JSON.stringify(delegate.capabilities
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
@@ -222,7 +225,7 @@ class CustomModifierManager {
       delegate = factory(owner);
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (!FROM_CAPABILITIES.has(delegate.capabilities)) {
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom modifier managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.22')\` (imported via \`import { capabilities } from '@ember/modifier';\`). Received: \`${JSON.stringify(delegate.capabilities
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
@@ -309,4 +312,4 @@ function setHelperManager(factory, obj) {
   return setInternalHelperManager(new CustomHelperManager(factory), obj);
 }
 
-export { CustomComponentManager as C, CustomModifierManager as a, setHelperManager as b, componentCapabilities as c, setModifierManager as d, modifierCapabilities as m, setComponentManager as s };
+export { CustomComponentManager, CustomHelperManager, CustomModifierManager, componentCapabilities, modifierCapabilities, setComponentManager, setHelperManager, setInternalComponentManager, setInternalHelperManager, setInternalModifierManager, setModifierManager };

package/dist/dev/packages/@glimmer/node/index.js

@@ -0,0 +1,40 @@
+import '../../shared-chunks/fragment-Cc5k9Oy4.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../global-context/index.js';
+import '../validator/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+import { C as ConcreteBounds } from '../../shared-chunks/dynamic-CFg3dljk.js';
+import '../../shared-chunks/constants-eoaL3OJQ.js';
+import '../destroyable/index.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';
+import createHTMLDocument from '../../@simple-dom/document/index.js';
+import { D as DOMTreeConstruction } from '../../shared-chunks/element-builder-BOxP8emt.js';
+export { s as serializeBuilder } from '../../shared-chunks/serialize-builder-b_gSYCSS.js';
+
+class NodeDOMTreeConstruction extends DOMTreeConstruction {
+  // Hides property on base class
+  constructor(doc) {
+    super(doc || createHTMLDocument());
+  }
+
+  // override to prevent usage of `this.document` until after the constructor
+  setupUselessElement() {}
+  insertHTMLBefore(parent, reference, html) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-non-null-assertion
+    let raw = this.document.createRawHTMLSection(html);
+    parent.insertBefore(raw, reference);
+    return new ConcreteBounds(parent, raw, raw);
+  }
+
+  // override to avoid SVG detection/work when in node (this is not needed in SSR)
+  createElement(tag) {
+    return this.document.createElement(tag);
+  }
+
+  // override to avoid namespace shenanigans when in node (this is not needed in SSR)
+  setAttribute(element, name, value) {
+    element.setAttribute(name, value);
+  }
+}
+
+export { NodeDOMTreeConstruction };

package/dist/{packages → dev/packages}/@glimmer/opcode-compiler/index.js

@@ -1,11 +1,10 @@
-export { E as EMPTY_BLOCKS, W as WrappedBuilder, c as compilable, b as compileStatements, I as invokeStaticBlock, d as invokeStaticBlockWithStack, m as meta, a as templateCacheCounters, e as templateCompilationContext, t as templateFactory } from '../../shared-chunks/index-CQkjwqTv.js';
-import '../../shared-chunks/debug-to-string-BsFOvUtQ.js';
-import '@embroider/macros';
-import '../../shared-chunks/capabilities-DHiXCCuB.js';
+export { E as EMPTY_BLOCKS, W as WrappedBuilder, c as compilable, b as compileStatements, I as invokeStaticBlock, d as invokeStaticBlockWithStack, m as meta, a as templateCacheCounters, e as templateCompilationContext, t as templateFactory } from '../../shared-chunks/index-Q7JnrdBn.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../shared-chunks/fragment-Cc5k9Oy4.js';
 import '../global-context/index.js';
 import '../validator/index.js';
-import '../../shared-chunks/reference-B6HMX4y0.js';
-export { E as EvaluationContextImpl, S as StdLib, c as compileStd } from '../../shared-chunks/program-context-CZJnCFdo.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+export { E as EvaluationContextImpl, S as StdLib, c as compileStd } from '../../shared-chunks/program-context-BRjCC_BA.js';
 
 let debugCompiler;
 

package/dist/dev/packages/@glimmer/program/index.js

@@ -0,0 +1,12 @@
+import { C as ConstantsImpl } from '../../shared-chunks/constants-eoaL3OJQ.js';
+import { a as ProgramHeapImpl } from '../../shared-chunks/program-DfV0v8aa.js';
+export { P as ProgramImpl, R as RuntimeOpImpl } from '../../shared-chunks/program-DfV0v8aa.js';
+
+function artifacts() {
+  return {
+    constants: new ConstantsImpl(),
+    heap: new ProgramHeapImpl()
+  };
+}
+
+export { ConstantsImpl, ProgramHeapImpl, artifacts };

package/dist/dev/packages/@glimmer/reference/index.js

@@ -0,0 +1,208 @@
+import { toIterator, getPath } from '../global-context/index.js';
+import { E as EMPTY_ARRAY } from '../../shared-chunks/array-utils-CZQxrdD3.js';
+import { a as isIndexable } from '../../shared-chunks/collections-D_nY_0UJ.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import { dirtyTag as DIRTY_TAG, consumeTag, createTag } from '../validator/index.js';
+import { c as createComputeRef, v as valueForRef } from '../../shared-chunks/reference-C3TKDRnP.js';
+export { F as FALSE_REFERENCE, N as NULL_REFERENCE, R as REFERENCE, T as TRUE_REFERENCE, U as UNDEFINED_REFERENCE, b as childRefFor, g as childRefFromParts, a as createConstRef, e as createDebugAliasRef, h as createInvokableRef, d as createPrimitiveRef, j as createReadOnlyRef, k as createUnboundRef, i as isConstRef, f as isInvokableRef, l as isUpdatableRef, u as updateRef } from '../../shared-chunks/reference-C3TKDRnP.js';
+
+const NULL_IDENTITY = {};
+const KEY = (_, index) => index;
+const INDEX = (_, index) => String(index);
+const IDENTITY = item => {
+  if (item === null) {
+    // Returning null as an identity will cause failures since the iterator
+    // can't tell that it's actually supposed to be null
+    return NULL_IDENTITY;
+  }
+  return item;
+};
+function keyForPath(path) {
+  if (path[0] === '@') {
+    throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
+  }
+  return uniqueKeyFor(item => {
+    if (item === null || item === undefined) {
+      return item;
+    }
+    return getPath(item, path);
+  });
+}
+function makeKeyFor(key) {
+  switch (key) {
+    case '@key':
+      return uniqueKeyFor(KEY);
+    case '@index':
+      return uniqueKeyFor(INDEX);
+    case '@identity':
+      return uniqueKeyFor(IDENTITY);
+    default:
+      return keyForPath(key);
+  }
+}
+class WeakMapWithPrimitives {
+  _weakMap;
+  _primitiveMap;
+  get weakMap() {
+    if (this._weakMap === undefined) {
+      this._weakMap = new WeakMap();
+    }
+    return this._weakMap;
+  }
+  get primitiveMap() {
+    if (this._primitiveMap === undefined) {
+      this._primitiveMap = new Map();
+    }
+    return this._primitiveMap;
+  }
+  set(key, value) {
+    if (isIndexable(key)) {
+      this.weakMap.set(key, value);
+    } else {
+      this.primitiveMap.set(key, value);
+    }
+  }
+  get(key) {
+    if (isIndexable(key)) {
+      return this.weakMap.get(key);
+    } else {
+      return this.primitiveMap.get(key);
+    }
+  }
+}
+const IDENTITIES = new WeakMapWithPrimitives();
+function identityForNthOccurence(value, count) {
+  let identities = IDENTITIES.get(value);
+  if (identities === undefined) {
+    identities = [];
+    IDENTITIES.set(value, identities);
+  }
+  let identity = identities[count];
+  if (identity === undefined) {
+    identity = {
+      value,
+      count
+    };
+    identities[count] = identity;
+  }
+  return identity;
+}
+
+/**
+ * When iterating over a list, it's possible that an item with the same unique
+ * key could be encountered twice:
+ *
+ * ```js
+ * let arr = ['same', 'different', 'same', 'same'];
+ * ```
+ *
+ * In general, we want to treat these items as _unique within the list_. To do
+ * this, we track the occurences of every item as we iterate the list, and when
+ * an item occurs more than once, we generate a new unique key just for that
+ * item, and that occurence within the list. The next time we iterate the list,
+ * and encounter an item for the nth time, we can get the _same_ key, and let
+ * Glimmer know that it should reuse the DOM for the previous nth occurence.
+ */
+function uniqueKeyFor(keyFor) {
+  let seen = new WeakMapWithPrimitives();
+  return (value, memo) => {
+    let key = keyFor(value, memo);
+    let count = seen.get(key) || 0;
+    seen.set(key, count + 1);
+    if (count === 0) {
+      return key;
+    }
+    return identityForNthOccurence(key, count);
+  };
+}
+function createIteratorRef(listRef, key) {
+  return createComputeRef(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let iterable = valueForRef(listRef);
+    let keyFor = makeKeyFor(key);
+    if (Array.isArray(iterable)) {
+      return new ArrayIterator(iterable, keyFor);
+    }
+    let maybeIterator = toIterator(iterable);
+    if (maybeIterator === null) {
+      return new ArrayIterator(EMPTY_ARRAY, () => null);
+    }
+    return new IteratorWrapper(maybeIterator, keyFor);
+  });
+}
+function createIteratorItemRef(_value) {
+  let value = _value;
+  let tag = createTag();
+  return createComputeRef(() => {
+    consumeTag(tag);
+    return value;
+  }, newValue => {
+    if (value !== newValue) {
+      value = newValue;
+      DIRTY_TAG(tag);
+    }
+  });
+}
+class IteratorWrapper {
+  constructor(inner, keyFor) {
+    this.inner = inner;
+    this.keyFor = keyFor;
+  }
+  isEmpty() {
+    return this.inner.isEmpty();
+  }
+  next() {
+    let nextValue = this.inner.next();
+    if (nextValue !== null) {
+      nextValue.key = this.keyFor(nextValue.value, nextValue.memo);
+    }
+    return nextValue;
+  }
+}
+class ArrayIterator {
+  current;
+  pos = 0;
+  constructor(iterator, keyFor) {
+    this.iterator = iterator;
+    this.keyFor = keyFor;
+    if (iterator.length === 0) {
+      this.current = {
+        kind: 'empty'
+      };
+    } else {
+      this.current = {
+        kind: 'first',
+        value: iterator[this.pos]
+      };
+    }
+  }
+  isEmpty() {
+    return this.current.kind === 'empty';
+  }
+  next() {
+    let value;
+    let current = this.current;
+    if (current.kind === 'first') {
+      this.current = {
+        kind: 'progress'
+      };
+      value = current.value;
+    } else if (this.pos >= this.iterator.length - 1) {
+      return null;
+    } else {
+      value = this.iterator[++this.pos];
+    }
+    let {
+      keyFor
+    } = this;
+    let key = keyFor(value, this.pos);
+    let memo = this.pos;
+    return {
+      key,
+      value,
+      memo
+    };
+  }
+}
+
+export { createComputeRef, createIteratorItemRef, createIteratorRef, valueForRef };

package/dist/dev/packages/@glimmer/runtime/index.js

@@ -0,0 +1,11 @@
+import '../../shared-chunks/fragment-Cc5k9Oy4.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../global-context/index.js';
+import '../validator/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+export { C as ConcreteBounds, a as CurriedValue, b as CursorImpl, D as DOMChanges, c as DynamicAttribute, E as EMPTY_ARGS, d as EMPTY_NAMED, e as EMPTY_POSITIONAL, f as IDOMChanges, S as SimpleDynamicAttribute, T as TEMPLATE_ONLY_COMPONENT_MANAGER, g as TemplateOnlyComponent, h as TemplateOnlyComponentManager, i as array, j as clear, k as concat, l as createCapturedArgs, m as curry, n as dynamicAttribute, o as fn, p as get, q as hash, r as isWhitespace, s as normalizeProperty, t as on, u as reifyArgs, v as reifyNamed, w as reifyPositional, x as resetDebuggerCallback, y as setDebuggerCallback, z as templateOnlyComponent } from '../../shared-chunks/dynamic-CFg3dljk.js';
+export { D as DynamicScopeImpl, E as EnvironmentImpl, L as LowLevelVM, S as ScopeImpl, U as UpdatingVM, i as inTransaction, r as renderComponent, a as renderMain, b as renderSync, c as runtimeOptions } from '../../shared-chunks/render-sg8BuFaE.js';
+export { i as invokeHelper } from '../../shared-chunks/invoke-DxRPE05O.js';
+export { destroy, isDestroyed, isDestroying, registerDestructor } from '../destroyable/index.js';
+export { D as DOMTreeConstruction, N as NewTreeBuilder, R as RemoteBlock, a as ResettableBlockImpl, c as clientBuilder } from '../../shared-chunks/element-builder-BOxP8emt.js';
+export { R as RehydrateTree, S as SERIALIZATION_FIRST_NODE_STRING, i as isSerializationFirstNode, r as rehydrationBuilder } from '../../shared-chunks/rehydrate-builder-DPImr9e9.js';