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

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

@@ -1,19 +1,19 @@
-import { u as unwrap, e as expect, c as isIndexable, d as dict, S as StackImpl } from './collections-C3Y8z_9v.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, b as isConstRef, U as UNDEFINED_REFERENCE, N as NULL_REFERENCE, T as TRUE_REFERENCE, F as FALSE_REFERENCE, R as REFERENCE } from './reference-BshxG6wn.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, a as consumeTag, d as valueForTag, m as beginTrackFrame, q as endTrackFrame, i as CURRENT_TAG } from './cache-BIlOoPA7.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-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 { 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-_5e35539.js';
-import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
-import { n as normalizeStringValue, C as ConcreteBounds } from './normalize-D9jDJVGg.js';
-import { b as getInternalModifierManager } from './api-zh_k31vb.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, 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-D6Couewv.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-DYrYz3V8.js';
-import { n as notifyPropertyChange } from './computed-DjCIU_ht.js';
+import { n as notifyPropertyChange } from './computed-DtIStxvq.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
   // if no args are passed assume everything changes

package/dist/prod/packages/shared-chunks/{cache-BIlOoPA7.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, CONSTANT_TAG as C, DIRTY_TAG as D, INITIAL as I, UPDATE_TAG as U, VOLATILE as V, consumeTag as a, createCache as b, createUpdatableTag as c, valueForTag as d, combine as e, COMPUTE as f, getValue as g, CONSTANT as h, CURRENT_TAG as i, CurrentTag as j, VOLATILE_TAG as k, VolatileTag as l, beginTrackFrame as m, beginUntrackFrame as n, bump as o, createTag as p, endTrackFrame as q, endUntrackFrame as r, isConst as s, track as t, untrack as u, validateTag as v, isConstTag as w, isTracking as x, resetTracking 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-C9rFtQ_x.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 { C as CONSTANT_TAG, e as combine, v as validateTag, c as createUpdatableTag, U as UPDATE_TAG } from './cache-BIlOoPA7.js';
-import { t as tagFor, d as dirtyTagFor, a as tagMetaFor } from './meta-B9mldqPL.js';
-import { g as getCustomTagFor } from './args-proxy-BDXbXCF9.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)) {

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

@@ -1,4 +1,4 @@
-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-C3Y8z_9v.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';

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

@@ -1,10 +1,10 @@
 import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.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-CDkeR0nI.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 { v as validateTag, u as untrack, U as UPDATE_TAG, d as valueForTag, a as consumeTag, A as ALLOW_CYCLES, t as track } from './cache-BIlOoPA7.js';
-import { a as tagMetaFor, t as tagFor } from './meta-B9mldqPL.js';
-import { m as markObjectAsDirty, b as getChainTagsForKeys, f as finishLazyChains } from './chain-tags-C9rFtQ_x.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

package/dist/prod/packages/shared-chunks/{curly-ZzX43b50.js → curly-IY06zACp.js}

@@ -2,11 +2,11 @@ import { getOwner, setOwner } from '../@ember/-internals/owner/index.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 { 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-BshxG6wn.js';
-import { f as reifyPositional } from './debug-render-tree-CF5O4-WI.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 { d as valueForTag, n as beginUntrackFrame, r as endUntrackFrame, m as beginTrackFrame, q as endTrackFrame, a as consumeTag, v as validateTag } from './cache-BIlOoPA7.js';
-import { g as get } from './property_get-CAFdpRyu.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';

package/dist/prod/packages/shared-chunks/{element-DUOVW5Ho.js → element-DgHdPZ8u.js}

@@ -1,6 +1,6 @@
-import { a as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BshxG6wn.js';
-import { s as setInternalComponentManager } from './api-zh_k31vb.js';
-import { i as internalHelper } from './internal-helper-DIbr1RgC.js';
+import { c as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-CG0yPgLy.js';
+import { s as setInternalComponentManager } from './api-DlJKfm_f.js';
+import { i as internalHelper } from './internal-helper-Bz1lpDXr.js';
 
 /**
   @module @ember/helper
@@ -82,6 +82,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/prod/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 };

package/dist/prod/packages/shared-chunks/{get-t0-itmA-.js → get-Dago5uGl.js}

@@ -1,8 +1,8 @@
-import { a as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-BshxG6wn.js';
-import { f as reifyPositional } from './debug-render-tree-CF5O4-WI.js';
-import { i as internalHelper } from './hash-mcs3pEFO.js';
+import { c as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-CG0yPgLy.js';
+import { f as reifyPositional } from './arguments-BzAkZVBa.js';
+import { i as internalHelper } from './hash-gEXIsSO4.js';
 import { setPath, getPath } from '../@glimmer/global-context/index.js';
-import { i as isDict } from './collections-C3Y8z_9v.js';
+import { i as isDict } from './collections-GpG8lT2g.js';
 
 const isEmpty = value => {
   return value === null || value === undefined || typeof value.toString !== 'function';
@@ -19,10 +19,15 @@ const normalizeTextValue = value => {
 
   Example:
 
-  ```handlebars
-  {{some-component name=(concat firstName " " lastName)}}
 
-  {{! would pass name="<first name value> <last name value>" to the component}}
+  ```gjs
+  import { concat } from '@ember/helper';
+
+  <template>
+  {{yield (concat firstName " " lastName)}}
+
+  {{! would yield name="<first name value> <last name value>" to the component}}
+  </template>
   ```
 
   or for angle bracket invocation, you actually don't need concat at all.
@@ -46,28 +51,31 @@ const concat = internalHelper(({
 
   For example, these two usages are equivalent:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
+  import { get } from '@ember/object';
 
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
       language: "Ruby"
     }
+    
+    <template>
+      {{this.developer.name}}
+      {{get this.developer "name"}}
+    </template>
   }
   ```
 
-  ```handlebars
-  {{this.developer.name}}
-  {{get this.developer "name"}}
-  ```
-
   If there were several facts about a person, the `{{get}}` helper can dynamically
   pick one:
 
-  ```app/templates/application.hbs
-  <DeveloperDetail @factName="language" />
+  ```app/templates/application.gjs
+  <template>
+    <DeveloperDetail @factName="language" />
+  </template>
   ```
 
   ```handlebars
@@ -77,10 +85,11 @@ const concat = internalHelper(({
   For a more complex example, this template would allow the user to switch
   between showing the user's height and weight with a click:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
-
+  import { get } from '@ember/object';
+    
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
@@ -92,28 +101,16 @@ const concat = internalHelper(({
     showFact = (fact) => {
       this.currentFact = fact;
     }
-  }
-  ```
-
-  ```app/components/developer-detail.js
-  {{get this.developer this.currentFact}}
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
-  ```
+    
+    <template>
+      {{get this.developer this.currentFact}}
 
-  The `{{get}}` helper can also respect mutable values itself. For example:
-
-  ```app/components/developer-detail.js
-  <Input @value={{mut (get this.person this.currentFact)}} />
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+      <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+      <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+    </template>
+  }
   ```
 
-  Would allow the user to swap what fact is being displayed, and also edit
-  that fact via a two-way mutable binding.
-
   @public
   @method get
  */

package/dist/{dev/packages/shared-chunks/get_properties-CIm8IAtP.js → prod/packages/shared-chunks/get_properties-Dg3xFpiS.js}

@@ -1,4 +1,4 @@
-import { g as get } from './property_get-CIBS9umw.js';
+import { g as get } from './property_get-DAKgbeJX.js';
 
 /**
  @module @ember/object