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

package/dist/dev/packages/shared-chunks/{untouchable-this-BHdAERUu.js → arguments-CDkbOqTS.js}

@@ -1,20 +1,20 @@
-import { u as unwrap, a as expect, b as isIndexable, d as dict, S as StackImpl } from './collections-DEt-i-8B.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, e as createDebugAliasRef } from './reference-C-OXd_kp.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, z as validateTag, k as consumeTag, B as valueForTag, g as beginTrackFrame, p as endTrackFrame, c as CURRENT_TAG } from './cache-CeWOBNQg.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, a as isIndexable, d as dict } from './collections-DPkjqeA3.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, h as createDebugAliasRef } from './reference-BqOLhKFy.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-DGDPVCpC.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 { d as debugToString } from './debug-to-string-C6LsA_qz.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-CZkuOqqC.js';
-import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
-import { n as normalizeStringValue, C as ConcreteBounds } from './normalize-CxG_iVLJ.js';
-import { b as getInternalModifierManager } from './api-DG5kRT-o.js';
+import { m as managerHasCapability } from './capabilities-CajW4QjE.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-CKySQVU7.js';
+import { b as getInternalModifierManager } from './api-DuLOZMO_.js';
 import { toBool } from '../@glimmer/global-context/index.js';
 
 function CheckInstanceof(Class) {
@@ -49,34 +49,45 @@ 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
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+function buildUntouchableThis(source) {
+  let context = null;
+  {
+    let assertOnProperty = property => {
+      let access = typeof property === 'symbol' || typeof property === 'number' ? `[${String(property)}]` : `.${property}`;
+      throw new Error(`You accessed \`this${access}\` from a function passed to the ${source}, but the function itself was not bound to a valid \`this\` context. Consider updating to use a bound function (for instance, use an arrow function, \`() => {}\`).`);
     };
+    context = new Proxy({}, {
+      get(_target, property) {
+        assertOnProperty(property);
+      },
+      set(_target, property) {
+        assertOnProperty(property);
+        return false;
+      },
+      has(_target, property) {
+        assertOnProperty(property);
+        return false;
+      }
+    });
   }
-  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);
-    }
-  }
+  return context;
 }
-function externs(vm) {
-  return undefined;
+
+/** @internal */
+function hasCustomDebugRenderTreeLifecycle(manager) {
+  return 'getDebugCustomRenderTree' in manager;
+}
+
+function resolveComponent(resolver, constants, name, owner) {
+  let definition = resolver?.lookupComponent?.(name, expect(owner)) ?? null;
+  if (!definition) {
+    throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
+  }
+
+  // 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');
@@ -153,20 +164,198 @@ 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() {
+    if (this.value === null) {
+      throw new Error('BUG: double 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) {
+    if (this.stack.current !== state) {
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);
+    }
+    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;
-  if (!definition) {
-    throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
+      // 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() {
+    if (this.stack.size === 0) {
+      throw new Error('BUG: unbalanced pop');
+    }
+    this.stack.pop();
+  }
+  nodeFor(state) {
+    return expect(this.nodes.get(state));
+  }
+  appendChild(node, state) {
+    if (this.refs.has(state)) {
+      throw new Error('BUG: child already appended');
+    }
+    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);
+}
 
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-  return constants.resolvedComponent(definition, name);
+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(() => {
@@ -1932,193 +2121,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() {
-    if (this.value === null) {
-      throw new Error('BUG: double 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) {
-    if (this.stack.current !== state) {
-      // eslint-disable-next-line @typescript-eslint/no-base-to-string
-      throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);
-    }
-    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() {
-    if (this.stack.size === 0) {
-      throw new Error('BUG: unbalanced pop');
-    }
-    this.stack.pop();
-  }
-  nodeFor(state) {
-    return expect(this.nodes.get(state));
-  }
-  appendChild(node, state) {
-    if (this.refs.has(state)) {
-      throw new Error('BUG: child already appended');
-    }
-    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);
-}
-
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-function buildUntouchableThis(source) {
-  let context = null;
-  {
-    let assertOnProperty = property => {
-      let access = typeof property === 'symbol' || typeof property === 'number' ? `[${String(property)}]` : `.${property}`;
-      throw new Error(`You accessed \`this${access}\` from a function passed to the ${source}, but the function itself was not bound to a valid \`this\` context. Consider updating to use a bound function (for instance, use an arrow function, \`() => {}\`).`);
-    };
-    context = new Proxy({}, {
-      get(_target, property) {
-        assertOnProperty(property);
-      },
-      set(_target, property) {
-        assertOnProperty(property);
-        return false;
-      },
-      has(_target, property) {
-        assertOnProperty(property);
-        return false;
-      }
-    });
-  }
-  return context;
-}
-
-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, buildUntouchableThis as e, check as f, createCapturedArgs as g, curry as h, externs as i, isArgumentError as j, isCurriedType as k, reifyNamed as l, reifyPositional as m, resolveCurriedValue as n, 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, buildUntouchableThis as g, check as h, isArgumentError as i, isCurriedType as j, resolveCurriedValue as k, AssertFilter as l, externs as m, EndTrackFrameOpcode as n, reifyArgs as r };

package/dist/dev/packages/shared-chunks/{array-BMaSKezP.js → array-CVEnNWng.js}

@@ -1,7 +1,7 @@
 import '../@ember/debug/index.js';
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { s as sendEvent, a as addListener, r as removeListener } from './events-B1lx9T1I.js';
-import { n as notifyPropertyChange } from './computed-Daavz6vC.js';
+import { s as sendEvent, a as addListener, r as removeListener } from './events-6aFVjD4k.js';
+import { n as notifyPropertyChange } from './computed-BPCtuOxQ.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
@@ -116,4 +116,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/dev/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/dev/packages/shared-chunks/{cache-CeWOBNQg.js → cache-DGDPVCpC.js}

@@ -1,4 +1,4 @@
-import { b as getLast, a as asPresentArray } from './present-D0EfKzC6.js';
+import { g as getLast, b as asPresentArray } from './present-B1rrjAVM.js';
 import { assert, scheduleRevalidate } from '../@glimmer/global-context/index.js';
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion -- @fixme */
@@ -182,7 +182,6 @@ const CONSTANT_TAG_ID = 3;
 //////////
 
 const COMPUTE = Symbol('TAG_COMPUTE');
-Reflect.set(globalThis, 'COMPUTE_SYMBOL', COMPUTE);
 
 //////////
 
@@ -593,4 +592,4 @@ function untrack(callback) {
   }
 }
 
-export { ALLOW_CYCLES as A, valueForTag as B, 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, debug as o, endTrackFrame as p, endUntrackFrame as q, getValue as r, isConst as s, isConstTag as t, isTracking as u, resetTracking as v, track as w, untrack as x, unwrap as y, validateTag as z };
+export { ALLOW_CYCLES as A, resetTracking as B, 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, unwrap as d, debug as e, combine as f, createCache as g, getValue as h, COMPUTE 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, isConst as x, isConstTag as y, isTracking as z };

package/dist/dev/packages/shared-chunks/{capabilities-CZkuOqqC.js → capabilities-CajW4QjE.js}

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

package/dist/dev/packages/shared-chunks/{chain-tags-DfmU63mS.js → chain-tags-uWSImHzB.js}

@@ -1,12 +1,12 @@
 import { peekMeta, meta } from '../@ember/-internals/meta/lib/meta.js';
 import { i as isObject } from './spec-BXl1reqK.js';
 import '../@ember/debug/index.js';
-import { b as CONSTANT_TAG, j as combine, z as validateTag, n as createUpdatableTag, U as UPDATE_TAG } from './cache-CeWOBNQg.js';
-import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-Cjo3zQJq.js';
+import { C as CONSTANT_TAG, f as combine, v as validateTag, b as createUpdatableTag, U as UPDATE_TAG } from './cache-DGDPVCpC.js';
+import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-BqC7f9Ia.js';
 import { a as setupMandatorySetter } from './mandatory-setter-BpbAMTzV.js';
 import { t as toString } from './to-string-C7M8LBLH.js';
 import { isDestroyed } from '../@glimmer/destroyable/index.js';
-import { g as getCustomTagFor } from './args-proxy-CB0SM6jC.js';
+import { g as getCustomTagFor } from './args-proxy-CS5Brs3_.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function objectAt(array, index) {
@@ -187,4 +187,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/dev/packages/shared-chunks/{collections-DEt-i-8B.js → collections-DPkjqeA3.js}

@@ -1,4 +1,4 @@
-import { b as getLast } from './present-D0EfKzC6.js';
+import { g as getLast } from './present-B1rrjAVM.js';
 
 function unwrap(val) {
   return val;
@@ -51,4 +51,4 @@ class StackImpl {
   }
 }
 
-export { StackImpl as S, expect as a, isIndexable as b, dict as d, exhausted as e, isDict as i, unwrap as u };
+export { StackImpl as S, isIndexable as a, exhausted as b, dict as d, expect as e, isDict as i, unwrap as u };

package/dist/dev/packages/shared-chunks/{compiler-DhH2WLpA.js → compiler-QUSl_urU.js}

@@ -1,12 +1,12 @@
-import { i as isPresentArray, g as getFirst, b as getLast, a as asPresentArray, m as mapPresentArray } from './present-D0EfKzC6.js';
+import { i as isPresentArray, a as getFirst, g as getLast, b as asPresentArray, m as mapPresentArray } from './present-B1rrjAVM.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 { i as isVoidTag, b as build, v as voidMap, P as Printer } from './transform-resolutions-h1ik8gqW.js';
-import { u as unwrap, a as expect, d as dict, e as exhausted } from './collections-DEt-i-8B.js';
+import { u as unwrap, e as expect, d as dict, b as exhausted } from './collections-DPkjqeA3.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 UNKNOWN_POSITION = Object.freeze({

package/dist/dev/packages/shared-chunks/{computed-Daavz6vC.js → computed-BPCtuOxQ.js}

@@ -1,14 +1,14 @@
 import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
 import { s as setWithMandatorySetter } from './mandatory-setter-BpbAMTzV.js';
-import { b as descriptorForProperty, i as isClassicDecorator, a as ComputedDescriptor, c as isElementDescriptor, m as makeComputedDecorator, d as descriptorForDecorator } from './decorator-DYQwMItS.js';
-import { e as revalidateObservers, c as flushSyncObservers, d as resumeObserverDeactivation, g as suspendedObserverDeactivation, b as addObserver, s as setObserverSuspended } from './observers-CejcZw5s.js';
+import { d as descriptorForProperty, a as isClassicDecorator, c as ComputedDescriptor, i as isElementDescriptor, m as makeComputedDecorator, b as descriptorForDecorator } from './decorator-B5Uh5NFI.js';
+import { c as revalidateObservers, d as flushSyncObservers, e as resumeObserverDeactivation, s as suspendedObserverDeactivation, b as addObserver, g as setObserverSuspended } from './observers-DMlX2nCi.js';
 import { t as toString } from './to-string-C7M8LBLH.js';
 import inspect from '../@ember/debug/lib/inspect.js';
 import '../@ember/debug/index.js';
 import { isDestroyed } from '../@glimmer/destroyable/index.js';
-import { z as validateTag, x as untrack, U as UPDATE_TAG, A as ALLOW_CYCLES, B as valueForTag, k as consumeTag, w as track } from './cache-CeWOBNQg.js';
-import { a as tagMetaFor, t as tagFor } from './meta-Cjo3zQJq.js';
-import { m as markObjectAsDirty, a as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-DfmU63mS.js';
+import { v as validateTag, u as untrack, U as UPDATE_TAG, A as ALLOW_CYCLES, a as valueForTag, c as consumeTag, t as track } from './cache-DGDPVCpC.js';
+import { a as tagMetaFor, t as tagFor } from './meta-BqC7f9Ia.js';
+import { m as markObjectAsDirty, b as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-uWSImHzB.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**
@@ -977,4 +977,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 };