ember-source 7.2.0-alpha.4 → 7.3.0-alpha.1

package/dist/prod/packages/shared-chunks/{debug-render-tree-CYENUjgX.js → arguments-BzAkZVBa.js}

@@ -1,19 +1,19 @@
-import { u as unwrap, b as expect, f as isIndexable, d as dict, S as StackImpl } from './collections-By4M3cTy.js';
-import { a as assign } from './object-utils-AijlD-JH.js';
-import { h as $v0, g as $t1, f as $t0, a as $pc, b as $ra, $ as $fp, e as $sp, d as $s1, c as $s0 } from './registers-Buvdhhxx.js';
+import { a as $v0, b as $t1, c as $t0, d as $pc, e as $ra, f as $fp, g as $sp, h as $s1, $ as $s0 } from './registers-C_W2qYHJ.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
-import { b as createComputeRef, v as valueForRef, d as createConstRef, g as createPrimitiveRef, j as isConstRef, U as UNDEFINED_REFERENCE, N as NULL_REFERENCE, T as TRUE_REFERENCE, F as FALSE_REFERENCE, R as REFERENCE } from './reference-D2agTt1V.js';
-import { b as EMPTY_STRING_ARRAY, c as enumerate, e as emptyArray } from './array-utils-BEaSKdEb.js';
-import { b as CONSTANT_TAG, I as INITIAL, x as validateTag, k as consumeTag, y as valueForTag, g as beginTrackFrame, o as endTrackFrame, c as CURRENT_TAG } from './cache-CG6_L9db.js';
-import { b as CURRIED_MODIFIER, C as CURRIED_COMPONENT } from './curried-Cnjy9_ug.js';
-import { ax as VM_SYSCALL_SIZE, i as VM_CHILD_SCOPE_OP, a9 as VM_POP_SCOPE_OP, ah as VM_PUSH_DYNAMIC_SCOPE_OP, a6 as VM_POP_DYNAMIC_SCOPE_OP, p as VM_CONSTANT_OP, aC as decodeHandle, q as VM_CONSTANT_REFERENCE_OP, ab as VM_PRIMITIVE_OP, aG as isHandle, aD as decodeImmediate, ac as VM_PRIMITIVE_REFERENCE_OP, x as VM_DUP_OP, a7 as VM_POP_OP, _ as VM_LOAD_OP, G as VM_FETCH_OP, g as VM_BIND_DYNAMIC_SCOPE_OP, D as VM_ENTER_OP, F as VM_EXIT_OP, ak as VM_PUSH_SYMBOL_TABLE_OP, ae as VM_PUSH_BLOCK_SCOPE_OP, m as VM_COMPILE_BLOCK_OP, U as VM_INVOKE_YIELD_OP, Y as VM_JUMP_IF_OP, Z as VM_JUMP_UNLESS_OP, X as VM_JUMP_EQ_OP, e as VM_ASSERT_SAME_OP, az as VM_TO_BOOLEAN_OP, ay as VM_TEXT_OP, k as VM_COMMENT_OP, a4 as VM_OPEN_ELEMENT_OP, a3 as VM_OPEN_DYNAMIC_ELEMENT_OP, aj as VM_PUSH_REMOTE_ELEMENT_OP, a8 as VM_POP_REMOTE_ELEMENT_OP, H as VM_FLUSH_ELEMENT_OP, j as VM_CLOSE_ELEMENT_OP, a1 as VM_MODIFIER_OP, B as VM_DYNAMIC_MODIFIER_OP, av as VM_STATIC_ATTR_OP, y as VM_DYNAMIC_ATTR_OP, af as VM_PUSH_COMPONENT_DEFINITION_OP, ao as VM_RESOLVE_DYNAMIC_COMPONENT_OP, an as VM_RESOLVE_CURRIED_COMPONENT_OP, ag as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ad as VM_PUSH_ARGS_OP, ai as VM_PUSH_EMPTY_ARGS_OP, h as VM_CAPTURE_ARGS_OP, aa as VM_PREPARE_ARGS_OP, s as VM_CREATE_COMPONENT_OP, am as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, f as VM_BEGIN_COMPONENT_TRANSACTION_OP, al as VM_PUT_COMPONENT_OPERATIONS_OP, n as VM_COMPONENT_ATTR_OP, aw as VM_STATIC_COMPONENT_ATTR_OP, v as VM_DID_CREATE_ELEMENT_OP, K as VM_GET_COMPONENT_SELF_OP, L as VM_GET_COMPONENT_TAG_NAME_OP, J as VM_GET_COMPONENT_LAYOUT_OP, a0 as VM_MAIN_OP, a5 as VM_POPULATE_LAYOUT_OP, aA as VM_VIRTUAL_ROOT_SCOPE_OP, as as VM_SET_NAMED_VARIABLES_OP, aq as VM_SET_BLOCKS_OP, T as VM_INVOKE_COMPONENT_LAYOUT_OP, w as VM_DID_RENDER_LAYOUT_OP, l as VM_COMMIT_COMPONENT_TRANSACTION_OP } from './syscall-ops-nrBHMOTp.js';
+import { e as expect, S as StackImpl, u as unwrap, c as isIndexable, d as dict } from './collections-GpG8lT2g.js';
+import { c as createComputeRef, v as valueForRef, a as createConstRef, e as createPrimitiveRef, i as isConstRef, U as UNDEFINED_REFERENCE, N as NULL_REFERENCE, T as TRUE_REFERENCE, F as FALSE_REFERENCE, R as REFERENCE } from './reference-CG0yPgLy.js';
+import { b as EMPTY_STRING_ARRAY, e as enumerate, c as emptyArray } from './array-utils-CZQxrdD3.js';
+import { C as CONSTANT_TAG, I as INITIAL, v as validateTag, c as consumeTag, a as valueForTag, o as beginTrackFrame, s as endTrackFrame, k as CURRENT_TAG } from './cache-CofLhaS4.js';
+import { C as CURRIED_MODIFIER, a as CURRIED_COMPONENT } from './curried-BZnYakIg.js';
+import { j as VM_SYSCALL_SIZE, k as VM_CHILD_SCOPE_OP, l as VM_POP_SCOPE_OP, m as VM_PUSH_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, o as VM_CONSTANT_OP, p as decodeHandle, q as VM_CONSTANT_REFERENCE_OP, r as VM_PRIMITIVE_OP, s as isHandle, t as decodeImmediate, u as VM_PRIMITIVE_REFERENCE_OP, v as VM_DUP_OP, w as VM_POP_OP, x as VM_LOAD_OP, y as VM_FETCH_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, A as VM_ENTER_OP, B as VM_EXIT_OP, C as VM_PUSH_SYMBOL_TABLE_OP, D as VM_PUSH_BLOCK_SCOPE_OP, E as VM_COMPILE_BLOCK_OP, F as VM_INVOKE_YIELD_OP, G as VM_JUMP_IF_OP, H as VM_JUMP_UNLESS_OP, I as VM_JUMP_EQ_OP, b as VM_ASSERT_SAME_OP, J as VM_TO_BOOLEAN_OP, K as VM_TEXT_OP, L as VM_COMMENT_OP, M as VM_OPEN_ELEMENT_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, Z as VM_PUSH_ARGS_OP, _ as VM_PUSH_EMPTY_ARGS_OP, $ as VM_CAPTURE_ARGS_OP, a0 as VM_PREPARE_ARGS_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, a5 as VM_COMPONENT_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, a7 as VM_DID_CREATE_ELEMENT_OP, a8 as VM_GET_COMPONENT_SELF_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, V as VM_MAIN_OP, ab as VM_POPULATE_LAYOUT_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP } from './syscall-ops-CN7STuUn.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
-import { a as unwrapTemplate } from './template-B0Apv9g2.js';
+import { u as unwrapTemplate } from './template-BRrQR6KS.js';
 import { registerDestructor, destroy, associateDestroyableChild } from '../@glimmer/destroyable/index.js';
-import { m as managerHasCapability } from './capabilities-_5e35539.js';
-import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
-import { n as normalizeStringValue, C as ConcreteBounds } from './normalize-Bx4H3NjB.js';
-import { b as getInternalModifierManager } from './api-DOLN_cR2.js';
+import { m as managerHasCapability } from './capabilities-BuVYh-vx.js';
+import { a as assign } from './object-utils-AijlD-JH.js';
+import { I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
+import { n as normalizeStringValue, C as ConcreteBounds } from './normalize-C_IStty9.js';
+import { b as getInternalModifierManager } from './api-DlJKfm_f.js';
 import { toBool } from '../@glimmer/global-context/index.js';
 
 function CheckInstanceof(Class) {
@@ -48,34 +48,17 @@ function check(value, checker, message) {
   }
 }
 
-class AppendOpcodes {
-  // This code is intentionally putting unsafe `null`s into the array that it
-  // will intentionally overwrite before anyone can see them.
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  evaluateOpcode = new Array(VM_SYSCALL_SIZE).fill(null);
-  constructor() {
-  }
-  add(name, evaluate, kind = 'syscall') {
-    this.evaluateOpcode[name] = {
-      syscall: kind !== 'machine',
-      evaluate
-    };
-  }
-  evaluate(vm, opcode, type) {
-    let operation = unwrap(this.evaluateOpcode[type]);
-    if (operation.syscall) {
-      assert(!opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
-      operation.evaluate(vm, opcode);
-    } else {
-      assert(opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
-      operation.evaluate(vm.lowlevel, opcode);
-    }
-  }
+/** @internal */
+function hasCustomDebugRenderTreeLifecycle(manager) {
+  return 'getDebugCustomRenderTree' in manager;
 }
-function externs(vm) {
-  return undefined;
+
+function resolveComponent(resolver, constants, name, owner) {
+  let definition = resolver?.lookupComponent?.(name, expect(owner)) ?? null;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+  return constants.resolvedComponent(definition, name);
 }
-const APPEND_OPCODES = new AppendOpcodes();
 
 const TYPE = Symbol('TYPE');
 const INNER = Symbol('INNER');
@@ -152,18 +135,186 @@ function curry(type, spec, owner, args, resolved = false) {
   return new CurriedValue(type, spec, owner, args, resolved);
 }
 
-/** @internal */
-function hasCustomDebugRenderTreeLifecycle(manager) {
-  return 'getDebugCustomRenderTree' in manager;
+let GUID = 0;
+class Ref {
+  id = GUID++;
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+  release() {
+    this.value = null;
+  }
+  toString() {
+    let label = `Ref ${this.id}`;
+    if (this.value === null) {
+      return `${label} (released)`;
+    } else {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return `${label}: ${this.value}`;
+      } catch {
+        return label;
+      }
+    }
+  }
 }
+class DebugRenderTreeImpl {
+  stack = new StackImpl();
+  refs = new WeakMap();
+  roots = new Set();
+  nodes = new WeakMap();
+  begin() {
+    this.reset();
+  }
+  create(state, node) {
+    let internalNode = assign({}, node, {
+      bounds: null,
+      refs: new Set()
+    });
+    this.nodes.set(state, internalNode);
+    this.appendChild(internalNode, state);
+    this.enter(state);
+  }
+  update(state) {
+    this.enter(state);
+  }
+  didRender(state, bounds) {
+    this.nodeFor(state).bounds = bounds;
+    this.exit();
+  }
+  willDestroy(state) {
+    expect(this.refs.get(state)).release();
+  }
+  commit() {
+    this.reset();
+  }
+  capture() {
+    return this.captureRefs(this.roots);
+  }
+  reset() {
+    if (this.stack.size !== 0) {
+      // We probably encountered an error during the rendering loop. This will
+      // likely trigger undefined behavior and memory leaks as the error left
+      // things in an inconsistent state. It is recommended that the user
+      // refresh the page.
 
-function resolveComponent(resolver, constants, name, owner) {
-  let definition = resolver?.lookupComponent?.(name, expect(owner)) ?? null;
+      // TODO: We could warn here? But this happens all the time in our tests?
 
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-  return constants.resolvedComponent(definition, name);
+      // Clean up the root reference to prevent errors from happening if we
+      // attempt to capture the render tree (Ember Inspector may do this)
+      let root = expect(this.stack.toArray()[0]);
+      let ref = this.refs.get(root);
+      if (ref !== undefined) {
+        this.roots.delete(ref);
+      }
+      while (!this.stack.isEmpty()) {
+        this.stack.pop();
+      }
+    }
+  }
+  enter(state) {
+    this.stack.push(state);
+  }
+  exit() {
+    this.stack.pop();
+  }
+  nodeFor(state) {
+    return expect(this.nodes.get(state));
+  }
+  appendChild(node, state) {
+    let parent = this.stack.current;
+    let ref = new Ref(state);
+    this.refs.set(state, ref);
+    if (parent) {
+      let parentNode = this.nodeFor(parent);
+      parentNode.refs.add(ref);
+      node.parent = parentNode;
+    } else {
+      this.roots.add(ref);
+    }
+  }
+  captureRefs(refs) {
+    let captured = [];
+    refs.forEach(ref => {
+      let state = ref.get();
+      if (state) {
+        captured.push(this.captureNode(`render-node:${ref.id}`, state));
+      } else {
+        refs.delete(ref);
+      }
+    });
+    return captured;
+  }
+  captureNode(id, state) {
+    let node = this.nodeFor(state);
+    let {
+      type,
+      name,
+      args,
+      instance,
+      refs
+    } = node;
+    let bounds = this.captureBounds(node);
+    let children = this.captureRefs(refs);
+    return {
+      id,
+      type,
+      name,
+      args: reifyArgsDebug(args),
+      instance,
+      bounds,
+      children
+    };
+  }
+  captureBounds(node) {
+    let bounds = expect(node.bounds);
+    let parentElement = bounds.parentElement();
+    let firstNode = bounds.firstNode();
+    let lastNode = bounds.lastNode();
+    return {
+      parentElement,
+      firstNode,
+      lastNode
+    };
+  }
+}
+function getDebugName(definition, manager = definition.manager) {
+  return definition.resolvedName ?? definition.debugName ?? manager.getDebugName(definition.state);
 }
 
+class AppendOpcodes {
+  // This code is intentionally putting unsafe `null`s into the array that it
+  // will intentionally overwrite before anyone can see them.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  evaluateOpcode = new Array(VM_SYSCALL_SIZE).fill(null);
+  constructor() {
+  }
+  add(name, evaluate, kind = 'syscall') {
+    this.evaluateOpcode[name] = {
+      syscall: kind !== 'machine',
+      evaluate
+    };
+  }
+  evaluate(vm, opcode, type) {
+    let operation = unwrap(this.evaluateOpcode[type]);
+    if (operation.syscall) {
+      assert(!opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
+      operation.evaluate(vm, opcode);
+    } else {
+      assert(opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
+      operation.evaluate(vm.lowlevel, opcode);
+    }
+  }
+}
+function externs(vm) {
+  return undefined;
+}
+const APPEND_OPCODES = new AppendOpcodes();
+
 function createClassListRef(list) {
   return createComputeRef(() => {
     let ret = [];
@@ -1895,155 +2046,4 @@ const EMPTY_NAMED = Object.freeze(Object.create(null));
 const EMPTY_POSITIONAL = EMPTY_REFERENCES;
 const EMPTY_ARGS = createCapturedArgs(EMPTY_NAMED, EMPTY_POSITIONAL);
 
-let GUID = 0;
-class Ref {
-  id = GUID++;
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-  get() {
-    return this.value;
-  }
-  release() {
-    this.value = null;
-  }
-  toString() {
-    let label = `Ref ${this.id}`;
-    if (this.value === null) {
-      return `${label} (released)`;
-    } else {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        return `${label}: ${this.value}`;
-      } catch {
-        return label;
-      }
-    }
-  }
-}
-class DebugRenderTreeImpl {
-  stack = new StackImpl();
-  refs = new WeakMap();
-  roots = new Set();
-  nodes = new WeakMap();
-  begin() {
-    this.reset();
-  }
-  create(state, node) {
-    let internalNode = assign({}, node, {
-      bounds: null,
-      refs: new Set()
-    });
-    this.nodes.set(state, internalNode);
-    this.appendChild(internalNode, state);
-    this.enter(state);
-  }
-  update(state) {
-    this.enter(state);
-  }
-  didRender(state, bounds) {
-    this.nodeFor(state).bounds = bounds;
-    this.exit();
-  }
-  willDestroy(state) {
-    expect(this.refs.get(state)).release();
-  }
-  commit() {
-    this.reset();
-  }
-  capture() {
-    return this.captureRefs(this.roots);
-  }
-  reset() {
-    if (this.stack.size !== 0) {
-      // We probably encountered an error during the rendering loop. This will
-      // likely trigger undefined behavior and memory leaks as the error left
-      // things in an inconsistent state. It is recommended that the user
-      // refresh the page.
-
-      // TODO: We could warn here? But this happens all the time in our tests?
-
-      // Clean up the root reference to prevent errors from happening if we
-      // attempt to capture the render tree (Ember Inspector may do this)
-      let root = expect(this.stack.toArray()[0]);
-      let ref = this.refs.get(root);
-      if (ref !== undefined) {
-        this.roots.delete(ref);
-      }
-      while (!this.stack.isEmpty()) {
-        this.stack.pop();
-      }
-    }
-  }
-  enter(state) {
-    this.stack.push(state);
-  }
-  exit() {
-    this.stack.pop();
-  }
-  nodeFor(state) {
-    return expect(this.nodes.get(state));
-  }
-  appendChild(node, state) {
-    let parent = this.stack.current;
-    let ref = new Ref(state);
-    this.refs.set(state, ref);
-    if (parent) {
-      let parentNode = this.nodeFor(parent);
-      parentNode.refs.add(ref);
-      node.parent = parentNode;
-    } else {
-      this.roots.add(ref);
-    }
-  }
-  captureRefs(refs) {
-    let captured = [];
-    refs.forEach(ref => {
-      let state = ref.get();
-      if (state) {
-        captured.push(this.captureNode(`render-node:${ref.id}`, state));
-      } else {
-        refs.delete(ref);
-      }
-    });
-    return captured;
-  }
-  captureNode(id, state) {
-    let node = this.nodeFor(state);
-    let {
-      type,
-      name,
-      args,
-      instance,
-      refs
-    } = node;
-    let bounds = this.captureBounds(node);
-    let children = this.captureRefs(refs);
-    return {
-      id,
-      type,
-      name,
-      args: reifyArgsDebug(args),
-      instance,
-      bounds,
-      children
-    };
-  }
-  captureBounds(node) {
-    let bounds = expect(node.bounds);
-    let parentElement = bounds.parentElement();
-    let firstNode = bounds.firstNode();
-    let lastNode = bounds.lastNode();
-    return {
-      parentElement,
-      firstNode,
-      lastNode
-    };
-  }
-}
-function getDebugName(definition, manager = definition.manager) {
-  return definition.resolvedName ?? definition.debugName ?? manager.getDebugName(definition.state);
-}
-
-export { APPEND_OPCODES as A, BeginTrackFrameOpcode as B, CurriedValue as C, DebugRenderTreeImpl as D, EMPTY_ARGS as E, JumpIfNotModifiedOpcode as J, VMArgumentsImpl as V, AssertFilter as a, EMPTY_NAMED as b, EMPTY_POSITIONAL as c, EndTrackFrameOpcode as d, check as e, createCapturedArgs as f, curry as g, externs as h, isArgumentError as i, isCurriedType as j, reifyNamed as k, reifyPositional as l, resolveCurriedValue as m, reifyArgs as r };
+export { APPEND_OPCODES as A, BeginTrackFrameOpcode as B, CurriedValue as C, DebugRenderTreeImpl as D, EMPTY_ARGS as E, JumpIfNotModifiedOpcode as J, VMArgumentsImpl as V, EMPTY_NAMED as a, EMPTY_POSITIONAL as b, createCapturedArgs as c, curry as d, reifyNamed as e, reifyPositional as f, check as g, isCurriedType as h, isArgumentError as i, resolveCurriedValue as j, AssertFilter as k, externs as l, EndTrackFrameOpcode as m, reifyArgs as r };

package/dist/prod/packages/shared-chunks/{array-DYFI95FA.js → array-BzReKMeW.js}

@@ -1,6 +1,6 @@
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { s as sendEvent, a as addListener, r as removeListener } from './events-C7aYCy0N.js';
-import { n as notifyPropertyChange } from './computed-D6MVTTDd.js';
+import { s as sendEvent, a as addListener, r as removeListener } from './events-DYrYz3V8.js';
+import { n as notifyPropertyChange } from './computed-DtIStxvq.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
   // if no args are passed assume everything changes
@@ -113,4 +113,4 @@ function removeArrayObserver(array, target, opts) {
   return arrayObserversHelper(array, target, opts, removeListener);
 }
 
-export { addArrayObserver as a, arrayContentDidChange as b, arrayContentWillChange as c, replace as d, replaceInNativeArray as e, removeArrayObserver as r };
+export { arrayContentWillChange as a, arrayContentDidChange as b, addArrayObserver as c, removeArrayObserver as d, replaceInNativeArray as e, replace as r };

package/dist/prod/packages/shared-chunks/{array-utils-BEaSKdEb.js → array-utils-CZQxrdD3.js}

@@ -42,4 +42,4 @@ function* zipArrays(left, right) {
   }
 }
 
-export { EMPTY_ARRAY as E, EMPTY_NUMBER_ARRAY as a, EMPTY_STRING_ARRAY as b, enumerate as c, zipTuples as d, emptyArray as e, isEmptyArray as i, reverse as r, zipArrays as z };
+export { EMPTY_ARRAY as E, EMPTY_NUMBER_ARRAY as a, EMPTY_STRING_ARRAY as b, emptyArray as c, zipTuples as d, enumerate as e, isEmptyArray as i, reverse as r, zipArrays as z };

package/dist/prod/packages/shared-chunks/{cache-CG6_L9db.js → cache-CofLhaS4.js}

@@ -27,7 +27,6 @@ const CONSTANT_TAG_ID = 3;
 //////////
 
 const COMPUTE = Symbol('TAG_COMPUTE');
-Reflect.set(globalThis, 'COMPUTE_SYMBOL', COMPUTE);
 
 //////////
 
@@ -368,4 +367,4 @@ function untrack(callback) {
   }
 }
 
-export { ALLOW_CYCLES as A, COMPUTE as C, DIRTY_TAG as D, INITIAL as I, UPDATE_TAG as U, VOLATILE as V, CONSTANT as a, CONSTANT_TAG as b, CURRENT_TAG as c, CurrentTag as d, VOLATILE_TAG as e, VolatileTag as f, beginTrackFrame as g, beginUntrackFrame as h, bump as i, combine as j, consumeTag as k, createCache as l, createTag as m, createUpdatableTag as n, endTrackFrame as o, endUntrackFrame as p, getValue as q, isConst as r, isConstTag as s, isTracking as t, resetTracking as u, track as v, untrack as w, validateTag as x, valueForTag as y };
+export { ALLOW_CYCLES as A, CONSTANT_TAG as C, DIRTY_TAG as D, INITIAL as I, UPDATE_TAG as U, VOLATILE as V, valueForTag as a, createUpdatableTag as b, consumeTag as c, combine as d, createCache as e, isTracking as f, getValue as g, COMPUTE as h, isConst as i, CONSTANT as j, CURRENT_TAG as k, CurrentTag as l, VOLATILE_TAG as m, VolatileTag as n, beginTrackFrame as o, beginUntrackFrame as p, bump as q, createTag as r, endTrackFrame as s, track as t, untrack as u, validateTag as v, endUntrackFrame as w, isConstTag as x, resetTracking as y };

package/dist/prod/packages/shared-chunks/{capabilities-_5e35539.js → capabilities-BuVYh-vx.js}

@@ -1,4 +1,4 @@
-import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
 
 function buildCapabilities(capabilities) {
   return capabilities;

package/dist/prod/packages/shared-chunks/{chain-tags-BP0V2LnZ.js → chain-tags-B2J7DsxO.js}

@@ -1,8 +1,8 @@
 import { peekMeta, meta } from '../@ember/-internals/meta/lib/meta.js';
 import { i as isObject } from './spec-BXl1reqK.js';
-import { b as CONSTANT_TAG, j as combine, x as validateTag, n as createUpdatableTag, U as UPDATE_TAG } from './cache-CG6_L9db.js';
-import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-Ce6-qROq.js';
-import { g as getCustomTagFor } from './args-proxy-CaXVcI8G.js';
+import { C as CONSTANT_TAG, d as combine, v as validateTag, b as createUpdatableTag, U as UPDATE_TAG } from './cache-CofLhaS4.js';
+import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-BJtIZDir.js';
+import { g as getCustomTagFor } from './args-proxy-CCoFtYLS.js';
 
 function objectAt(array, index) {
   if (Array.isArray(array)) {
@@ -175,4 +175,4 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$1) {
   return chainTags;
 }
 
-export { CHAIN_PASS_THROUGH as C, SELF_TAG as S, getChainTagsForKeys as a, tagForProperty as b, finishLazyChains as f, getChainTagsForKey as g, markObjectAsDirty as m, objectAt as o, tagForObject as t };
+export { CHAIN_PASS_THROUGH as C, SELF_TAG as S, tagForProperty as a, getChainTagsForKeys as b, finishLazyChains as f, getChainTagsForKey as g, markObjectAsDirty as m, objectAt as o, tagForObject as t };

package/dist/prod/packages/shared-chunks/{collections-By4M3cTy.js → collections-GpG8lT2g.js}

@@ -1,3 +1,12 @@
+function unwrap(val) {
+  return val;
+}
+function expect(val, message) {
+  return val;
+}
+function exhausted(value) {
+}
+
 function isPresentArray(list) {
   return list ? list.length > 0 : false;
 }
@@ -21,15 +30,6 @@ function mapPresentArray(list, mapper) {
   return out;
 }
 
-function unwrap(val) {
-  return val;
-}
-function expect(val, message) {
-  return val;
-}
-function exhausted(value) {
-}
-
 function dict() {
   return Object.create(null);
 }
@@ -72,4 +72,4 @@ class StackImpl {
   }
 }
 
-export { StackImpl as S, asPresentArray as a, expect as b, getLast as c, dict as d, exhausted as e, isIndexable as f, getFirst as g, isPresentArray as h, isDict as i, mapPresentArray as m, unwrap as u };
+export { StackImpl as S, isPresentArray as a, getLast as b, isIndexable as c, dict as d, expect as e, asPresentArray as f, getFirst as g, exhausted as h, isDict as i, mapPresentArray as m, unwrap as u };

package/dist/prod/packages/shared-chunks/{compiler-DQmEjFyx.js → compiler-lBSssiWp.js}

@@ -1,10 +1,10 @@
-import { h as isPresentArray, g as getFirst, c as getLast, u as unwrap, a as asPresentArray, b as expect, d as dict, m as mapPresentArray, e as exhausted } from './collections-By4M3cTy.js';
+import { a as isPresentArray, g as getFirst, b as getLast, u as unwrap, f as asPresentArray, e as expect, d as dict, m as mapPresentArray, h as exhausted } from './collections-GpG8lT2g.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { assertNever } from '../@glimmer/util/index.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { o as opcodes } from './opcodes-CplRyHl_.js';
-import { b as CURRIED_MODIFIER, a as CURRIED_HELPER, C as CURRIED_COMPONENT } from './curried-Cnjy9_ug.js';
+import { C as CURRIED_MODIFIER, b as CURRIED_HELPER, a as CURRIED_COMPONENT } from './curried-BZnYakIg.js';
 import { a as WellKnownTagNames, W as WellKnownAttrNames } from './well-known-_EVO9RaV.js';
 
 const Char = {

package/dist/prod/packages/shared-chunks/{computed-D6MVTTDd.js → computed-DtIStxvq.js}

@@ -1,10 +1,10 @@
 import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { b as descriptorForProperty, i as isClassicDecorator, a as ComputedDescriptor, c as isElementDescriptor, m as makeComputedDecorator, d as descriptorForDecorator } from './decorator-B8Lpq40g.js';
-import { e as revalidateObservers, c as flushSyncObservers, d as resumeObserverDeactivation, g as suspendedObserverDeactivation, b as addObserver, s as setObserverSuspended } from './observers-Ci31SE36.js';
+import { d as descriptorForProperty, a as isClassicDecorator, c as ComputedDescriptor, i as isElementDescriptor, m as makeComputedDecorator, b as descriptorForDecorator } from './decorator-9ikVwsjY.js';
+import { c as revalidateObservers, d as flushSyncObservers, e as resumeObserverDeactivation, s as suspendedObserverDeactivation, b as addObserver, g as setObserverSuspended } from './observers-BmobpXAF.js';
 import inspect from '../@ember/debug/lib/inspect.js';
-import { x as validateTag, w as untrack, U as UPDATE_TAG, y as valueForTag, k as consumeTag, A as ALLOW_CYCLES, v as track } from './cache-CG6_L9db.js';
-import { a as tagMetaFor, t as tagFor } from './meta-Ce6-qROq.js';
-import { m as markObjectAsDirty, a as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-BP0V2LnZ.js';
+import { v as validateTag, u as untrack, U as UPDATE_TAG, a as valueForTag, c as consumeTag, A as ALLOW_CYCLES, t as track } from './cache-CofLhaS4.js';
+import { a as tagMetaFor, t as tagFor } from './meta-BJtIZDir.js';
+import { m as markObjectAsDirty, b as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-B2J7DsxO.js';
 
 /**
 @module @ember/object
@@ -936,4 +936,4 @@ function isComputed(obj, key) {
   return Boolean(descriptorForProperty(obj, key));
 }
 
-export { ComputedProperty as C, PROPERTY_DID_CHANGE as P, autoComputed as a, beginPropertyChanges as b, changeProperties as c, computed as d, defineDecorator as e, defineProperty as f, defineValue as g, endPropertyChanges as h, expandProperties as i, isComputed as j, notifyPropertyChange as n };
+export { ComputedProperty as C, PROPERTY_DID_CHANGE as P, endPropertyChanges as a, beginPropertyChanges as b, computed as c, defineProperty as d, expandProperties as e, changeProperties as f, defineValue as g, defineDecorator as h, autoComputed as i, isComputed as j, notifyPropertyChange as n };

package/dist/prod/packages/shared-chunks/{curly-DCYSwLtz.js → curly-a6DP7r87.js}

@@ -1,15 +1,16 @@
 import { getOwner, setOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
 import { getViewElement, clearElementView, clearViewElement, addChildView, setViewElement, setElementView } from '../@ember/-internals/views/lib/system/utils.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
-import { b as createComputeRef, v as valueForRef, g as createPrimitiveRef, c as childRefFor, a as childRefFromParts, d as createConstRef, l as isUpdatableRef, u as updateRef } from './reference-D2agTt1V.js';
-import { l as reifyPositional } from './debug-render-tree-CYENUjgX.js';
-import { E as EMPTY_ARRAY } from './array-utils-BEaSKdEb.js';
-import { y as valueForTag, h as beginUntrackFrame, p as endUntrackFrame, g as beginTrackFrame, o as endTrackFrame, k as consumeTag, x as validateTag } from './cache-CG6_L9db.js';
-import { g as get } from './property_get-Sw0SicEZ.js';
+import { c as createComputeRef, v as valueForRef, e as createPrimitiveRef, f as childRefFor, g as childRefFromParts, a as createConstRef, b as isUpdatableRef, u as updateRef } from './reference-CG0yPgLy.js';
+import { f as reifyPositional } from './arguments-BzAkZVBa.js';
+import { E as EMPTY_ARRAY } from './array-utils-CZQxrdD3.js';
+import { a as valueForTag, p as beginUntrackFrame, w as endUntrackFrame, o as beginTrackFrame, s as endTrackFrame, c as consumeTag, v as validateTag } from './cache-CofLhaS4.js';
+import { g as get } from './property_get-DAKgbeJX.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
 import { MUTABLE_CELL } from '../@ember/-internals/views/lib/compat/attrs.js';
+import { C as CURLY_MANAGER_BRAND } from './curly-brand-B_F79Dep.js';
 
 /**
  * @deprecated
@@ -228,6 +229,7 @@ function applyAttributeBindings(attributeBindings, component, rootRef, operation
   }
 }
 class CurlyComponentManager {
+  [CURLY_MANAGER_BRAND] = true;
   templateFor(component) {
     let {
       layout,
@@ -537,9 +539,6 @@ const CURLY_CAPABILITIES = {
   willDestroy: true,
   hasSubOwner: false
 };
-const CURLY_COMPONENT_MANAGER = new CurlyComponentManager();
-function isCurlyManager(manager) {
-  return manager === CURLY_COMPONENT_MANAGER;
-}
+const CURLY_COMPONENT_MANAGER = /*@__PURE__*/new CurlyComponentManager();
 
-export { BOUNDS as B, CURLY_COMPONENT_MANAGER as C, DIRTY_TAG as D, IS_DISPATCHING_ATTRS as I, ComponentStateBucket as a, CurlyComponentManager as b, isCurlyManager as c, getComponentCapturedArgs as g, initialRenderInstrumentDetails as i, unwrapTemplate as u };
+export { BOUNDS as B, CurlyComponentManager as C, DIRTY_TAG as D, IS_DISPATCHING_ATTRS as I, ComponentStateBucket as a, CURLY_COMPONENT_MANAGER as b, getComponentCapturedArgs as g, initialRenderInstrumentDetails as i, unwrapTemplate as u };

package/dist/prod/packages/shared-chunks/curly-brand-B_F79Dep.js

@@ -0,0 +1,12 @@
+/**
+ * The brand for the curly component manager lives in its own module so that
+ * code which only needs to *detect* the curly manager (e.g. the resolver)
+ * does not have to import the manager itself (and with it the classic
+ * component machinery).
+ */
+const CURLY_MANAGER_BRAND = Symbol('CURLY_MANAGER_BRAND');
+function isCurlyManager(manager) {
+  return manager[CURLY_MANAGER_BRAND] === true;
+}
+
+export { CURLY_MANAGER_BRAND as C, isCurlyManager as i };

package/dist/prod/packages/shared-chunks/{curried-Cnjy9_ug.js → curried-BZnYakIg.js}

@@ -2,4 +2,4 @@ const CURRIED_COMPONENT = 0;
 const CURRIED_HELPER = 1;
 const CURRIED_MODIFIER = 2;
 
-export { CURRIED_COMPONENT as C, CURRIED_HELPER as a, CURRIED_MODIFIER as b };
+export { CURRIED_MODIFIER as C, CURRIED_COMPONENT as a, CURRIED_HELPER as b };

package/dist/prod/packages/shared-chunks/{decorator-B8Lpq40g.js → decorator-9ikVwsjY.js}

@@ -119,4 +119,4 @@ function setClassicDecorator(dec, value = true) {
   DECORATOR_DESCRIPTOR_MAP.set(dec, value);
 }
 
-export { COMPUTED_SETTERS as C, ComputedDescriptor as a, descriptorForProperty as b, isElementDescriptor as c, descriptorForDecorator as d, isClassicDecorator as i, makeComputedDecorator as m, nativeDescDecorator as n, setClassicDecorator as s };
+export { COMPUTED_SETTERS as C, isClassicDecorator as a, descriptorForDecorator as b, ComputedDescriptor as c, descriptorForProperty as d, isElementDescriptor as i, makeComputedDecorator as m, nativeDescDecorator as n, setClassicDecorator as s };