ember-source 7.2.0-alpha.3 → 7.2.0-beta.1

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

@@ -1,20 +1,20 @@
-import { u as unwrap, e as expect, a as isIndexable, d as dict, S as StackImpl } from './collections-DPkjqeA3.js';
-import { a as assign } from './object-utils-AijlD-JH.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 { a as createComputeRef, v as valueForRef, c 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-BoPB2LfI.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 { b as CONSTANT_TAG, I as INITIAL, y as validateTag, k as consumeTag, z as valueForTag, g as beginTrackFrame, p as endTrackFrame, c as CURRENT_TAG } from './cache-B7dqAS38.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-BPFtDquC.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 { 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 { 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-BawZUDYD.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, 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-Bh_kUjzy.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-6aFVjD4k.js';
-import { n as notifyPropertyChange } from './computed-CJnghmXC.js';
+import { n as notifyPropertyChange } from './computed-BPCtuOxQ.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {

package/dist/dev/packages/shared-chunks/{cache-B7dqAS38.js → cache-DGDPVCpC.js}

@@ -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, unwrap 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, validateTag as y, valueForTag 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-D6tuFUj_.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, y as validateTag, n as createUpdatableTag, U as UPDATE_TAG } from './cache-B7dqAS38.js';
-import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-BmRXesrk.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-BNLuRFlO.js';
+import { g as getCustomTagFor } from './args-proxy-CS5Brs3_.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function objectAt(array, index) {

package/dist/dev/packages/shared-chunks/{computed-CJnghmXC.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 { 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-C2DurkLG.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 { y as validateTag, x as untrack, U as UPDATE_TAG, A as ALLOW_CYCLES, z as valueForTag, k as consumeTag, w as track } from './cache-B7dqAS38.js';
-import { a as tagMetaFor, t as tagFor } from './meta-BmRXesrk.js';
-import { m as markObjectAsDirty, b as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-D6tuFUj_.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';
 
 /**

package/dist/dev/packages/shared-chunks/{curly-BBzF_bI8.js → curly-Ei5G8jhk.js}

@@ -3,11 +3,11 @@ import { g as guidFor } from './guid-Cbq2sNV_.js';
 import { getViewElement, clearElementView, clearViewElement, addChildView, setViewElement, setElementView } from '../@ember/-internals/views/lib/system/utils.js';
 import { debugFreeze } from '../@ember/debug/index.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
-import { a as createComputeRef, v as valueForRef, e as createPrimitiveRef, f as childRefFor, g as childRefFromParts, c as createConstRef, d as isUpdatableRef, u as updateRef } from './reference-BoPB2LfI.js';
-import { f as reifyPositional } from './untouchable-this-B3DVwpHS.js';
+import { c as createComputeRef, v as valueForRef, e as createPrimitiveRef, f as childRefFor, g as childRefFromParts, a as createConstRef, d as isUpdatableRef, u as updateRef } from './reference-BqOLhKFy.js';
+import { f as reifyPositional } from './arguments-CDkbOqTS.js';
 import { E as EMPTY_ARRAY } from './array-utils-CZQxrdD3.js';
-import { z as valueForTag, h as beginUntrackFrame, q as endUntrackFrame, g as beginTrackFrame, p as endTrackFrame, k as consumeTag, y as validateTag } from './cache-B7dqAS38.js';
-import { g as get } from './property_get-CIBS9umw.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-DGDPVCpC.js';
+import { g as get } from './property_get-CRP7MFz_.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';

package/dist/dev/packages/shared-chunks/{element-DQJOvSlQ.js → element-BYLB-q7a.js}

@@ -1,7 +1,7 @@
-import { a as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BoPB2LfI.js';
-import { s as setInternalComponentManager } from './api-BawZUDYD.js';
+import { c as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BqOLhKFy.js';
+import { s as setInternalComponentManager } from './api-DuLOZMO_.js';
 import '../@ember/debug/index.js';
-import { i as internalHelper } from './internal-helper-Ez7zbEIa.js';
+import { i as internalHelper } from './internal-helper-CKrni0b_.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**
@@ -84,6 +84,8 @@ function getElementDefinition(tagName) {
   Passing `null`, `undefined`, or non-string values will throw an assertion error.
 
   Changing the tag name will tear down and recreate the element and its contents.
+ 
+  The `element` helper is built-in and does not need to be imported.
 
   @method element
   @for Ember.Templates.helpers

package/dist/dev/packages/shared-chunks/{flags-B9qxc-pB.js → flags-BZxHQ0yn.js}

@@ -21,4 +21,4 @@ const TYPE_MASK = 0b00000000000000000000000011111111;
 const OPERAND_LEN_MASK = 0b00000000000000000000001100000000;
 const MACHINE_MASK = 0b00000000000000000000010000000000;
 
-export { ARG_SHIFT as A, InternalComponentCapabilities as I, MACHINE_MASK as M, OPERAND_LEN_MASK as O, TYPE_MASK as T, MAX_SIZE as a, TYPE_SIZE as b };
+export { ARG_SHIFT as A, InternalComponentCapabilities as I, MACHINE_MASK as M, OPERAND_LEN_MASK as O, TYPE_MASK as T, TYPE_SIZE as a, MAX_SIZE as b };