ember-source 7.1.0-alpha.3 → 7.1.0-alpha.5

package/dist/dev/packages/shared-chunks/{render-C1HzKUcM.js → render-DDdabL30.js}

@@ -1,19 +1,102 @@
-import './debug-to-string-CFb7h0lY.js';
-import { u as unwrap, e as expect, S as StackImpl } from './collections-D_nY_0UJ.js';
-import { u as unwrapHandle } from './constants-p7AL-pog.js';
-import { assertGlobalContextWasSet } from '../@glimmer/global-context/index.js';
-import { track, updateTag as UPDATE_TAG, debug, resetTracking, beginTrackFrame, endTrackFrame } from '../@glimmer/validator/index.js';
-import { U as UNDEFINED_REFERENCE, v as valueForRef, u as updateRef, a as createConstRef, b as childRefFor } from './reference-C3TKDRnP.js';
+import { u as unwrap, e as expect, a as isIndexable, S as StackImpl } from './collections-DPkjqeA3.js';
+import { a as unwrapHandle } from './template-BRrQR6KS.js';
+import { v as valueForRef, f as childRefFor, U as UNDEFINED_REFERENCE, a as createComputeRef, T as TRUE_REFERENCE, F as FALSE_REFERENCE, i as isConstRef, u as updateRef, c as createConstRef } from './reference-BoPB2LfI.js';
+import { w as track, U as UPDATE_TAG, o as debug, v as resetTracking, g as beginTrackFrame, p as endTrackFrame } from './cache-B7dqAS38.js';
 import { a as assert } from './assert-CUCJBR2C.js';
-import { P as ProgramImpl } from './program-DfV0v8aa.js';
-import { H as DebugRenderTreeImpl, I as isArgumentError, f as DOMChangesImpl, J as APPEND_OPCODES, K as move, j as clear, V as VMArgumentsImpl, L as externs, M as JumpIfNotModifiedOpcode, O as BeginTrackFrameOpcode, P as EndTrackFrameOpcode } from './dynamic-BfDKO5NI.js';
-import { D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-DO43ztVP.js';
+import { P as ProgramImpl } from './program-DzAfcWFj.js';
+import { A as APPEND_OPCODES, D as DebugRenderTreeImpl, i as isArgumentError, j as isCurriedType, d as curry, h as check, k as resolveCurriedValue, f as reifyPositional, l as AssertFilter, V as VMArgumentsImpl, m as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, n as EndTrackFrameOpcode } from './untouchable-this-cH6_N2LJ.js';
+import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-kHVx0F__.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
-import { destroyChildren, associateDestroyableChild, destroy, registerDestructor } from '../@glimmer/destroyable/index.js';
-import { createIteratorItemRef } from '../@glimmer/reference/index.js';
+import { associateDestroyableChild, _hasDestroyableChildren, destroy, destroyChildren, registerDestructor } from '../@glimmer/destroyable/index.js';
+import { toBool, debugAssert, assertGlobalContextWasSet } from '../@glimmer/global-context/index.js';
+import { createIteratorRef, createIteratorItemRef } from '../@glimmer/reference/index.js';
 import { r as reverse } from './array-utils-CZQxrdD3.js';
-import { a as $pc, b as $ra, c as $fp, d as $sp, i as isLowLevelRegister } from './registers-ylirb0dq.js';
-import { l as VM_RETURN_TO_OP, m as VM_RETURN_OP, n as VM_JUMP_OP, o as VM_INVOKE_VIRTUAL_OP, k as VM_INVOKE_STATIC_OP, p as VM_POP_FRAME_OP, q as VM_PUSH_FRAME_OP } from './fragment-Cc5k9Oy4.js';
+import { a as $v0, h as $pc, g as $ra, f as $fp, e as $sp, i as isLowLevelRegister } from './registers-DoamZwaG.js';
+import { aj as VM_DEBUGGER_OP, q as decodeHandle, ak as VM_CURRY_OP, al as VM_DYNAMIC_HELPER_OP, am as VM_HELPER_OP, an as VM_GET_VARIABLE_OP, ao as VM_SET_VARIABLE_OP, ap as VM_SET_BLOCK_OP, aq as VM_ROOT_SCOPE_OP, ar as VM_GET_PROPERTY_OP, as as VM_GET_BLOCK_OP, at as VM_SPREAD_BLOCK_OP, au as VM_HAS_BLOCK_OP, av as VM_HAS_BLOCK_PARAMS_OP, aw as VM_CONCAT_OP, ax as VM_IF_INLINE_OP, ay as VM_NOT_OP, az as VM_GET_DYNAMIC_VAR_OP, aA as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, aB as VM_DYNAMIC_CONTENT_TYPE_OP, c as VM_APPEND_HTML_OP, g as VM_APPEND_SAFE_HTML_OP, d as VM_APPEND_TEXT_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, aC as VM_ENTER_LIST_OP, aD as VM_EXIT_LIST_OP, aE as VM_ITERATE_OP, aF as VM_RETURN_TO_OP, aG as VM_RETURN_OP, aH as VM_JUMP_OP, aI as VM_INVOKE_VIRTUAL_OP, j as VM_INVOKE_STATIC_OP, aJ as VM_POP_FRAME_OP, aK as VM_PUSH_FRAME_OP } from './opcode-metadata-9iSW5JGP.js';
+import { b as CURRIED_COMPONENT, a as CURRIED_HELPER } from './curried-BVwSNqpf.js';
+import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
+import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-WvJPuo9z.js';
+import { ContentType } from '../@glimmer/vm/index.js';
+import { b as isEmpty, d as isString, s as shouldCoerce, i as isSafeString, e as isFragment, f as isNode, m as move, c as clear } from './normalize-CKySQVU7.js';
+
+// Allow the contents of `debugCallback` without extra annotations
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+
+function debugCallback(context, get) {
+  // eslint-disable-next-line no-console
+  console.info('Use `context`, and `get(<path>)` to debug this template.');
+
+  // for example...
+  context === get('this');
+
+  // eslint-disable-next-line no-debugger
+  debugger;
+}
+let callback = debugCallback;
+
+// For testing purposes
+function setDebuggerCallback(cb) {
+  callback = cb;
+}
+function resetDebuggerCallback() {
+  callback = debugCallback;
+}
+class ScopeInspector {
+  #symbols;
+  constructor(scope, symbols) {
+    this.scope = scope;
+    this.#symbols = symbols;
+  }
+  get(path) {
+    let {
+      scope
+    } = this;
+    let symbols = this.#symbols;
+    let parts = path.split('.');
+    let [head, ...tail] = path.split('.');
+    let ref;
+    if (head === 'this') {
+      ref = scope.getSelf();
+    } else if (symbols.locals[head]) {
+      ref = unwrap(scope.getSymbol(symbols.locals[head]));
+    } else {
+      ref = this.scope.getSelf();
+      tail = parts;
+    }
+    return tail.reduce((r, part) => childRefFor(r, part), ref);
+  }
+}
+APPEND_OPCODES.add(VM_DEBUGGER_OP, (vm, {
+  op1: _debugInfo
+}) => {
+  let debuggerInfo = vm.constants.getValue(decodeHandle(_debugInfo));
+  let inspector = new ScopeInspector(vm.scope(), debuggerInfo);
+  callback(valueForRef(vm.getSelf()), path => valueForRef(inspector.get(path)));
+});
+
+['b', 'big', 'blockquote', 'body', 'br', 'center', 'code', 'dd', 'div', 'dl', 'dt', 'em', 'embed', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'hr', 'i', 'img', 'li', 'listing', 'main', 'meta', 'nobr', 'ol', 'p', 'pre', 'ruby', 's', 'small', 'span', 'strong', 'strike', 'sub', 'sup', 'table', 'tt', 'u', 'ul', 'var'].forEach(tag => BLACKLIST_TABLE[tag] = 1);
+const WHITESPACE = /[\t\n\v\f\r \xa0\u{1680}\u{180e}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}]/u;
+function isWhitespace(string) {
+  return WHITESPACE.test(string);
+}
+class DOMChangesImpl extends DOMOperations {
+  namespace;
+  constructor(document) {
+    super(document);
+    this.document = document;
+    this.namespace = null;
+  }
+  setAttribute(element, name, value) {
+    element.setAttribute(name, value);
+  }
+  removeAttribute(element, name) {
+    element.removeAttribute(name);
+  }
+  insertAfter(element, node, reference) {
+    this.insertBefore(element, node, reference.nextSibling);
+  }
+}
+const DOMChanges = DOMChangesImpl;
 
 class DynamicScopeImpl {
   bucket;
@@ -217,7 +300,7 @@ class EnvironmentImpl {
     return expect(this.updateOperations);
   }
   begin() {
-    (!(!this[TRANSACTION]) && assert(!this[TRANSACTION]));
+    assert(!this[TRANSACTION]);
     this.debugRenderTree?.begin();
     this[TRANSACTION] = new TransactionImpl();
   }
@@ -268,6 +351,418 @@ function inTransaction(env, block) {
   }
 }
 
+function createCurryRef(type, inner, owner, args, resolver, isStrict) {
+  let lastValue, curriedDefinition;
+  return createComputeRef(() => {
+    let value = valueForRef(inner);
+    if (value === lastValue) {
+      return curriedDefinition;
+    }
+    if (isCurriedType(value, type)) {
+      curriedDefinition = args ? curry(type, value, owner, args) : args;
+    } else if (type === CURRIED_COMPONENT && typeof value === 'string' && value) {
+      // Only components should enter this path, as helpers and modifiers do not
+      // support string based resolution
+
+      {
+        if (isStrict) {
+          throw new Error(`Attempted to resolve a dynamic component with a string definition, \`${value}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`);
+        }
+        let resolvedDefinition = expect(resolver).lookupComponent?.(value, owner) ?? null;
+        if (!resolvedDefinition) {
+          throw new Error(`Attempted to resolve \`${value}\`, which was expected to be a component, but nothing was found.`);
+        }
+      }
+      curriedDefinition = curry(type, value, owner, args);
+    } else if (isIndexable(value)) {
+      curriedDefinition = curry(type, value, owner, args);
+    } else {
+      curriedDefinition = null;
+    }
+    lastValue = value;
+    return curriedDefinition;
+  });
+}
+
+function createConcatRef(partsRefs) {
+  return createComputeRef(() => {
+    const parts = [];
+    for (const ref of partsRefs) {
+      const value = valueForRef(ref);
+      if (value !== null && value !== undefined) {
+        parts.push(castToString(value));
+      }
+    }
+    if (parts.length > 0) {
+      return parts.join('');
+    }
+    return null;
+  });
+}
+function castToString(value) {
+  if (typeof value === 'string') {
+    return value;
+  } else if (typeof value.toString !== 'function') {
+    return '';
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+  return String(value);
+}
+
+APPEND_OPCODES.add(VM_CURRY_OP, (vm, {
+  op1: type,
+  op2: _isStrict
+}) => {
+  let stack = vm.stack;
+  let definition = check(stack.pop());
+  let capturedArgs = check(stack.pop());
+  let owner = vm.getOwner();
+  let resolver = vm.context.resolver;
+  let isStrict = false;
+  {
+    // strict check only happens in import.meta.env.DEV builds, no reason to load it otherwise
+    isStrict = vm.constants.getValue(decodeHandle(_isStrict));
+  }
+  vm.loadValue($v0, createCurryRef(type, definition, owner, capturedArgs, resolver, isStrict));
+});
+APPEND_OPCODES.add(VM_DYNAMIC_HELPER_OP, vm => {
+  let stack = vm.stack;
+  let ref = check(stack.pop());
+  let args = check(stack.pop()).capture();
+  let helperRef;
+  let initialOwner = vm.getOwner();
+  let helperInstanceRef = createComputeRef(() => {
+    if (helperRef !== undefined) {
+      destroy(helperRef);
+    }
+    let definition = valueForRef(ref);
+    if (isCurriedType(definition, CURRIED_HELPER)) {
+      let {
+        definition: resolvedDef,
+        owner,
+        positional,
+        named
+      } = resolveCurriedValue(definition);
+      let helper = resolveHelper(resolvedDef, ref);
+      if (named !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        args.named = assign({}, ...named, args.named);
+      }
+      if (positional !== undefined) {
+        args.positional = positional.concat(args.positional);
+      }
+      helperRef = helper(args, owner);
+      associateDestroyableChild(helperInstanceRef, helperRef);
+    } else if (isIndexable(definition)) {
+      let helper = resolveHelper(definition, ref);
+      helperRef = helper(args, initialOwner);
+      if (_hasDestroyableChildren(helperRef)) {
+        associateDestroyableChild(helperInstanceRef, helperRef);
+      }
+    } else {
+      helperRef = UNDEFINED_REFERENCE;
+    }
+  });
+  let helperValueRef = createComputeRef(() => {
+    valueForRef(helperInstanceRef);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+    return valueForRef(helperRef);
+  });
+  vm.associateDestroyable(helperInstanceRef);
+  vm.loadValue($v0, helperValueRef);
+});
+function resolveHelper(definition, ref) {
+  let managerOrHelper = getInternalHelperManager(definition, true);
+  let helper;
+  if (managerOrHelper === null) {
+    helper = null;
+  } else {
+    helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definition);
+  }
+  debugAssert(helper !== null, () => `Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\` or \`(${ref.debugLabel})\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${debugToString?.(definition)}`);
+  return helper;
+}
+APPEND_OPCODES.add(VM_HELPER_OP, (vm, {
+  op1: handle
+}) => {
+  let stack = vm.stack;
+  let helper = check(vm.constants.getValue(handle));
+  let args = check(stack.pop());
+  let value = helper(args.capture(), vm.getOwner(), vm.dynamicScope());
+  if (_hasDestroyableChildren(value)) {
+    vm.associateDestroyable(value);
+  }
+  vm.loadValue($v0, value);
+});
+APPEND_OPCODES.add(VM_GET_VARIABLE_OP, (vm, {
+  op1: symbol
+}) => {
+  let expr = vm.referenceForSymbol(symbol);
+  vm.stack.push(expr);
+});
+APPEND_OPCODES.add(VM_SET_VARIABLE_OP, (vm, {
+  op1: symbol
+}) => {
+  let expr = check(vm.stack.pop());
+  vm.scope().bindSymbol(symbol, expr);
+});
+APPEND_OPCODES.add(VM_SET_BLOCK_OP, (vm, {
+  op1: symbol
+}) => {
+  let handle = check(vm.stack.pop());
+  let scope = check(vm.stack.pop());
+  let table = check(vm.stack.pop());
+  vm.scope().bindBlock(symbol, [handle, scope, table]);
+});
+APPEND_OPCODES.add(VM_ROOT_SCOPE_OP, (vm, {
+  op1: size
+}) => {
+  vm.pushRootScope(size, vm.getOwner());
+});
+APPEND_OPCODES.add(VM_GET_PROPERTY_OP, (vm, {
+  op1: _key
+}) => {
+  let key = vm.constants.getValue(_key);
+  let expr = check(vm.stack.pop());
+  vm.stack.push(childRefFor(expr, key));
+});
+APPEND_OPCODES.add(VM_GET_BLOCK_OP, (vm, {
+  op1: _block
+}) => {
+  let {
+    stack
+  } = vm;
+  let block = vm.scope().getBlock(_block);
+  stack.push(block);
+});
+APPEND_OPCODES.add(VM_SPREAD_BLOCK_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let block = check(stack.pop());
+  if (block && !isUndefinedReference(block)) {
+    let [handleOrCompilable, scope, table] = block;
+    stack.push(table);
+    stack.push(scope);
+    stack.push(handleOrCompilable);
+  } else {
+    stack.push(null);
+    stack.push(null);
+    stack.push(null);
+  }
+});
+function isUndefinedReference(input) {
+  return input === UNDEFINED_REFERENCE;
+}
+APPEND_OPCODES.add(VM_HAS_BLOCK_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let block = check(stack.pop());
+  if (block && !isUndefinedReference(block)) {
+    stack.push(TRUE_REFERENCE);
+  } else {
+    stack.push(FALSE_REFERENCE);
+  }
+});
+APPEND_OPCODES.add(VM_HAS_BLOCK_PARAMS_OP, vm => {
+  // FIXME(mmun): should only need to push the symbol table
+  vm.stack.pop();
+  vm.stack.pop();
+  let table = check(vm.stack.pop());
+  let hasBlockParams = table && table.parameters.length;
+  vm.stack.push(hasBlockParams ? TRUE_REFERENCE : FALSE_REFERENCE);
+});
+APPEND_OPCODES.add(VM_CONCAT_OP, (vm, {
+  op1: count
+}) => {
+  let out = new Array(count);
+  for (let i = count; i > 0; i--) {
+    let offset = i - 1;
+    out[offset] = check(vm.stack.pop());
+  }
+  vm.stack.push(createConcatRef(out));
+});
+APPEND_OPCODES.add(VM_IF_INLINE_OP, vm => {
+  let condition = check(vm.stack.pop());
+  let truthy = check(vm.stack.pop());
+  let falsy = check(vm.stack.pop());
+  vm.stack.push(createComputeRef(() => {
+    if (toBool(valueForRef(condition))) {
+      return valueForRef(truthy);
+    } else {
+      return valueForRef(falsy);
+    }
+  }));
+});
+APPEND_OPCODES.add(VM_NOT_OP, vm => {
+  let ref = check(vm.stack.pop());
+  vm.stack.push(createComputeRef(() => {
+    return !toBool(valueForRef(ref));
+  }));
+});
+APPEND_OPCODES.add(VM_GET_DYNAMIC_VAR_OP, vm => {
+  let scope = vm.dynamicScope();
+  let stack = vm.stack;
+  let nameRef = check(stack.pop());
+  stack.push(createComputeRef(() => {
+    let name = String(valueForRef(nameRef));
+    return valueForRef(scope.get(name));
+  }));
+});
+APPEND_OPCODES.add(VM_LOG_OP, vm => {
+  let {
+    positional
+  } = check(vm.stack.pop()).capture();
+  vm.loadValue($v0, createComputeRef(() => {
+    // eslint-disable-next-line no-console
+    console.log(...reifyPositional(positional));
+  }));
+});
+
+class DynamicTextContent {
+  constructor(node, reference, lastValue) {
+    this.node = node;
+    this.reference = reference;
+    this.lastValue = lastValue;
+  }
+  evaluate() {
+    let value = valueForRef(this.reference);
+    let {
+      lastValue
+    } = this;
+    if (value === lastValue) return;
+    let normalized;
+    if (isEmpty(value)) {
+      normalized = '';
+    } else if (isString(value)) {
+      normalized = value;
+    } else {
+      normalized = String(value);
+    }
+    if (normalized !== lastValue) {
+      let textNode = this.node;
+      textNode.nodeValue = this.lastValue = normalized;
+    }
+  }
+}
+
+function toContentType(value) {
+  if (shouldCoerce(value)) {
+    return ContentType.String;
+  } else if (isCurriedType(value, CURRIED_COMPONENT) || hasInternalComponentManager(value)) {
+    return ContentType.Component;
+  } else if (isCurriedType(value, CURRIED_HELPER) || hasInternalHelperManager(value)) {
+    return ContentType.Helper;
+  } else if (isSafeString(value)) {
+    return ContentType.SafeString;
+  } else if (isFragment(value)) {
+    return ContentType.Fragment;
+  } else if (isNode(value)) {
+    return ContentType.Node;
+  } else {
+    return ContentType.String;
+  }
+}
+function toDynamicContentType(value) {
+  if (!isIndexable(value)) {
+    return ContentType.String;
+  }
+  if (isCurriedType(value, CURRIED_COMPONENT) || hasInternalComponentManager(value)) {
+    return ContentType.Component;
+  } else {
+    if (!isCurriedType(value, CURRIED_HELPER) && !hasInternalHelperManager(value)) {
+      throw new Error(
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+      `Attempted use a dynamic value as a component or helper, but that value did not have an associated component or helper manager. The value was: ${value}`);
+    }
+    return ContentType.Helper;
+  }
+}
+APPEND_OPCODES.add(VM_CONTENT_TYPE_OP, vm => {
+  let reference = check(vm.stack.peek());
+  vm.stack.push(toContentType(valueForRef(reference)));
+  if (!isConstRef(reference)) {
+    vm.updateWith(new AssertFilter(reference, toContentType));
+  }
+});
+APPEND_OPCODES.add(VM_DYNAMIC_CONTENT_TYPE_OP, vm => {
+  let reference = check(vm.stack.peek());
+  vm.stack.push(toDynamicContentType(valueForRef(reference)));
+  if (!isConstRef(reference)) {
+    vm.updateWith(new AssertFilter(reference, toDynamicContentType));
+  }
+});
+APPEND_OPCODES.add(VM_APPEND_HTML_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = valueForRef(reference);
+  let value = isEmpty(rawValue) ? '' : String(rawValue);
+  vm.tree().appendDynamicHTML(value);
+});
+APPEND_OPCODES.add(VM_APPEND_SAFE_HTML_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = check(valueForRef(reference)).toHTML();
+  let value = isEmpty(rawValue) ? '' : check(rawValue);
+  vm.tree().appendDynamicHTML(value);
+});
+APPEND_OPCODES.add(VM_APPEND_TEXT_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = valueForRef(reference);
+  let value = isEmpty(rawValue) ? '' : String(rawValue);
+  let node = vm.tree().appendDynamicText(value);
+  if (!isConstRef(reference)) {
+    vm.updateWith(new DynamicTextContent(node, reference, value));
+  }
+});
+APPEND_OPCODES.add(VM_APPEND_DOCUMENT_FRAGMENT_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let value = check(valueForRef(reference));
+  vm.tree().appendDynamicFragment(value);
+});
+APPEND_OPCODES.add(VM_APPEND_NODE_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let value = check(valueForRef(reference));
+  vm.tree().appendDynamicNode(value);
+});
+
+APPEND_OPCODES.add(VM_ENTER_LIST_OP, (vm, {
+  op1: relativeStart,
+  op2: elseTarget
+}) => {
+  let stack = vm.stack;
+  let listRef = check(stack.pop());
+  let keyRef = check(stack.pop());
+  let keyValue = valueForRef(keyRef);
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+  let key = keyValue === null ? '@identity' : String(keyValue);
+  let iteratorRef = createIteratorRef(listRef, key);
+  let iterator = valueForRef(iteratorRef);
+  vm.updateWith(new AssertFilter(iteratorRef, iterator => iterator.isEmpty()));
+  if (iterator.isEmpty()) {
+    // TODO: Fix this offset, should be accurate
+    vm.lowlevel.goto(elseTarget + 1);
+  } else {
+    vm.enterList(iteratorRef, relativeStart);
+    vm.stack.push(iterator);
+  }
+});
+APPEND_OPCODES.add(VM_EXIT_LIST_OP, vm => {
+  vm.exitList();
+});
+APPEND_OPCODES.add(VM_ITERATE_OP, (vm, {
+  op1: breaks
+}) => {
+  let stack = vm.stack;
+  let iterator = check(stack.peek());
+  let item = iterator.next();
+  if (item !== null) {
+    vm.registerItem(vm.enterItem(item));
+  } else {
+    vm.lowlevel.goto(breaks);
+  }
+});
+
 function initializeRegistersWithSP(sp) {
   return [0, -1, sp, 0];
 }
@@ -1503,4 +1998,4 @@ function recordToReference(record) {
   }, {});
 }
 
-export { DynamicScopeImpl as D, EnvironmentImpl as E, LowLevelVM as L, ScopeImpl as S, UpdatingVM as U, renderMain as a, renderSync as b, runtimeOptions as c, inTransaction as i, renderComponent as r };
+export { DOMChanges as D, EnvironmentImpl as E, LowLevelVM as L, ScopeImpl as S, UpdatingVM as U, DynamicScopeImpl as a, DOMChangesImpl as b, isWhitespace as c, renderMain as d, renderSync as e, resetDebuggerCallback as f, runtimeOptions as g, inTransaction as i, renderComponent as r, setDebuggerCallback as s };

package/dist/{prod/packages/shared-chunks/serialize-builder-DgpXSc2Q.js → dev/packages/shared-chunks/serialize-builder-B3u9Wr3n.js}

@@ -1,10 +1,5 @@
-import './fragment-D7nBU9ae.js';
-import '../@glimmer/validator/index.js';
-import './reference-BNqcwZWH.js';
-import { C as ConcreteBounds } from './on-CLxdmpmk.js';
-import './constants-2M371WiB.js';
-import './capabilities-DXA-L0iT.js';
-import { N as NewTreeBuilder } from './element-builder-BmLF0C-1.js';
+import { C as ConcreteBounds } from './normalize-CKySQVU7.js';
+import { N as NewTreeBuilder } from './element-builder-kHVx0F__.js';
 
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 

package/dist/dev/packages/shared-chunks/set_properties-BghuuGJx.js

@@ -0,0 +1,48 @@
+import { f as changeProperties } from './computed-CJnghmXC.js';
+import { s as set } from './property_set-D3PKyisF.js';
+
+/**
+ @module @ember/object
+*/
+/**
+  Set a list of properties on an object. These properties are set inside
+  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+  observers will be buffered.
+
+  ```javascript
+  import EmberObject from '@ember/object';
+  let anObject = EmberObject.create();
+
+  anObject.setProperties({
+    firstName: 'Stanley',
+    lastName: 'Stuart',
+    age: 21
+  });
+  ```
+
+  @method setProperties
+  @static
+  @for @ember/object
+  @param obj
+  @param {Object} properties
+  @return properties
+  @public
+*/
+
+function setProperties(obj, properties) {
+  if (properties === null || typeof properties !== 'object') {
+    return properties;
+  }
+  changeProperties(() => {
+    let props = Object.keys(properties);
+    for (let propertyName of props) {
+      // SAFETY: casting `properties` this way is safe because any object in JS
+      // can be indexed this way, and the result will be `unknown`, making it
+      // safe for callers.
+      set(obj, propertyName, properties[propertyName]);
+    }
+  });
+  return properties;
+}
+
+export { setProperties as s };

package/dist/dev/packages/shared-chunks/{setup-registry-B7-RknRf.js → setup-registry-XxD0xvgf.js}

@@ -1,21 +1,41 @@
 import { privatize } from '../@ember/-internals/container/index.js';
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import '../@ember/debug/index.js';
-import { O as OutletView, a as OutletTemplate, I as Input, L as LinkTo, T as Textarea, R as RootTemplate, b as Renderer } from './index-QZstta6s.js';
-import './fragment-Cc5k9Oy4.js';
-import './debug-to-string-CFb7h0lY.js';
-import '../@glimmer/global-context/index.js';
-import '../@glimmer/validator/index.js';
-import './reference-C3TKDRnP.js';
-import './dynamic-BfDKO5NI.js';
-import './constants-p7AL-pog.js';
-import '../@glimmer/destroyable/index.js';
-import './capabilities-O_xc7Yqk.js';
-import { c as clientBuilder } from './element-builder-DO43ztVP.js';
-import { r as rehydrationBuilder } from './rehydrate-builder-CEk2KOIk.js';
-import { s as serializeBuilder } from './serialize-builder-CPKxdfiH.js';
+import { I as Input, T as Textarea } from './textarea-C0Us0PNJ.js';
+import { LinkTo } from '../@ember/routing/index.js';
+import './render-DDdabL30.js';
+import { c as clientBuilder } from './element-builder-kHVx0F__.js';
+import { r as rehydrationBuilder } from './rehydrate-builder-DdzXTaJk.js';
+import { s as serializeBuilder } from './serialize-builder-B3u9Wr3n.js';
+import { o as outletHelper, O as OutletView, R as Renderer } from './index-CTxkmV78.js';
+import { t as templateFactory } from './index-DmGmwWPJ.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
+const OutletTemplate = templateFactory(
+/*
+  {{component (outletHelper)}}
+*/
+{
+  "id": null,
+  "block": "[[[46,[28,[32,0],null,null],null,null,null]],[],[\"component\"]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/outlet.hbs",
+  "scope": () => ({
+    outletHelper
+  }),
+  "isStrictMode": true
+});
+
+const RootTemplate = templateFactory(
+/*
+  {{component this}}
+*/
+{
+  "id": null,
+  "block": "[[[46,[30,0],null,null,null]],[],[\"component\"]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/root.hbs",
+  "isStrictMode": true
+});
+
 function setupApplicationRegistry(registry) {
   // because we are using injections we can't use instantiate false
   // we need to use bind() to copy the function so factory for
@@ -54,4 +74,4 @@ function setupEngineRegistry(registry) {
   registry.register('component:textarea', Textarea);
 }
 
-export { setupEngineRegistry as a, setupApplicationRegistry as s };
+export { RootTemplate as R, setupEngineRegistry as a, setupApplicationRegistry as s };

package/dist/dev/packages/shared-chunks/spec-BXl1reqK.js

@@ -0,0 +1,16 @@
+/**
+  Returns whether Type(value) is Object.
+
+  Useful for checking whether a value is a valid WeakMap key.
+
+  Refs: https://tc39.github.io/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
+        https://tc39.github.io/ecma262/#sec-weakmap.prototype.set
+
+  @private
+  @function isObject
+*/
+function isObject(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+export { isObject as i };