ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/{prod/packages/shared-chunks/registers-ylirb0dq.js → dev/packages/shared-chunks/registers-C_W2qYHJ.js}

@@ -32,4 +32,4 @@ function isLowLevelRegister(register) {
   return register <= $sp;
 }
 
-export { $s0 as $, $pc as a, $ra as b, $fp as c, $sp as d, $v0 as e, $t1 as f, $t0 as g, $s1 as h, isLowLevelRegister as i };
+export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $pc as d, $ra as e, $fp as f, $sp as g, $s1 as h, isLowLevelRegister as i };

package/dist/{prod/packages/shared-chunks/rehydrate-builder-D3t52iGR.js → dev/packages/shared-chunks/rehydrate-builder-DCyIgnCR.js}

@@ -1,8 +1,8 @@
-import { C as ConcreteBounds, x as COMMENT_NODE, b as CursorImpl, y as TEXT_NODE, z as ELEMENT_NODE, N as NS_SVG } from './on-CersD7PL.js';
-import './fragment-D7nBU9ae.js';
-import { e as expect } from './collections-GpG8lT2g.js';
+import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './element-builder--iTIJyCB.js';
 import { c as castToSimple, a as castToBrowser } from './simple-cast-DCvJLSin.js';
-import { N as NewTreeBuilder, R as RemoteBlock } from './element-builder-CzXb9l1W.js';
+import { e as expect } from './collections-DPkjqeA3.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
+import { C as ConcreteBounds, a as CursorImpl } from './normalize-CKySQVU7.js';
 
 const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
 function isSerializationFirstNode(node) {
@@ -381,6 +381,9 @@ class RehydrateTree extends NewTreeBuilder {
   }
   __pushRemoteElement(element, cursorId, insertBefore) {
     const marker = this.getMarker(castToBrowser(element), cursorId);
+    assert(!marker || marker.parentNode === element);
+
+    // when insertBefore is not present, we clear the element
     if (insertBefore === undefined) {
       while (element.firstChild !== null && element.firstChild !== marker) {
         this.remove(element.firstChild);

package/dist/dev/packages/shared-chunks/{render-DCchifOK.js → render-CpKaO-BO.js}

@@ -1,19 +1,103 @@
-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-BbdWMvgs.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 { 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-CgX8M02_.js';
-import { D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-BpJIoi99.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-Zqc4wiAV.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-B3DVwpHS.js';
+import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder--iTIJyCB.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, d as $pc, e as $ra, f as $fp, g as $sp, i as isLowLevelRegister } from './registers-C_W2qYHJ.js';
+import { a as VM_RETURN_TO_OP, b as VM_RETURN_OP, c as VM_JUMP_OP, d as VM_INVOKE_VIRTUAL_OP, V as VM_INVOKE_STATIC_OP, e as VM_POP_FRAME_OP, f as VM_PUSH_FRAME_OP } from './vm-ops-ImHv0Wtg.js';
+import { a as CURRIED_COMPONENT, b as CURRIED_HELPER } from './curried-BZnYakIg.js';
+import { ai as VM_DEBUGGER_OP, p as decodeHandle, aj as VM_CURRY_OP, ak as VM_DYNAMIC_HELPER_OP, al as VM_HELPER_OP, am as VM_GET_VARIABLE_OP, an as VM_SET_VARIABLE_OP, ao as VM_SET_BLOCK_OP, ap as VM_ROOT_SCOPE_OP, aq as VM_GET_PROPERTY_OP, ar as VM_GET_BLOCK_OP, as as VM_SPREAD_BLOCK_OP, at as VM_HAS_BLOCK_OP, au as VM_HAS_BLOCK_PARAMS_OP, av as VM_CONCAT_OP, aw as VM_IF_INLINE_OP, ax as VM_NOT_OP, ay as VM_GET_DYNAMIC_VAR_OP, az as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, aA 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, aB as VM_ENTER_LIST_OP, aC as VM_EXIT_LIST_OP, aD as VM_ITERATE_OP } from './syscall-ops-BPFtDquC.js';
+import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
+import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-BawZUDYD.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 +301,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 +352,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 +1999,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/chunk-3SQBS3Y5-Cj4eryg1.js → dev/packages/shared-chunks/runtime-CYyqkz5q-BOdRhmsS.js}

@@ -1,23 +1,4 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  c: () => decorateClass,
-  f: () => decorateFieldV1,
-  g: () => decorateFieldV2,
-  i: () => initializeDeferredDecorator,
-  m: () => decorateMethodV1,
-  n: () => decorateMethodV2,
-  p: () => decoratePOJO
-});
-var deferred = /* @__PURE__ */new WeakMap();
+const deferred = /* @__PURE__ */new WeakMap();
 function deferDecorator(proto, prop, desc) {
   let map = deferred.get(proto);
   if (!map) {
@@ -27,18 +8,16 @@ function deferDecorator(proto, prop, desc) {
   map.set(prop, desc);
 }
 function findDeferredDecorator(target, prop) {
+  var _a;
   let cursor = target.prototype;
   while (cursor) {
-    let desc = deferred.get(cursor)?.get(prop);
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
     if (desc) {
       return desc;
     }
-    cursor = cursor.prototype;
+    cursor = Object.getPrototypeOf(cursor);
   }
 }
-function decorateFieldV1(target, prop, decorators, initializer) {
-  return decorateFieldV2(target.prototype, prop, decorators, initializer);
-}
 function decorateFieldV2(prototype, prop, decorators, initializer) {
   let desc = {
     configurable: true,
@@ -58,11 +37,6 @@ function decorateFieldV2(prototype, prop, decorators, initializer) {
     deferDecorator(prototype, prop, desc);
   }
 }
-function decorateMethodV1({
-  prototype
-}, prop, decorators) {
-  return decorateMethodV2(prototype, prop, decorators);
-}
 function decorateMethodV2(prototype, prop, decorators) {
   const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
   let desc = {
@@ -88,34 +62,5 @@ function initializeDeferredDecorator(target, prop) {
     });
   }
 }
-function decorateClass(target, decorators) {
-  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
-}
-function decoratePOJO(pojo, decorated) {
-  for (let [type, prop, decorators] of decorated) {
-    if (type === "field") {
-      decoratePojoField(pojo, prop, decorators);
-    } else {
-      decorateMethodV2(pojo, prop, decorators);
-    }
-  }
-  return pojo;
-}
-function decoratePojoField(pojo, prop, decorators) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
-  };
-  for (let decorator of decorators) {
-    desc = decorator(pojo, prop, desc) || desc;
-  }
-  if (desc.initializer) {
-    desc.value = desc.initializer.call(pojo);
-    delete desc.initializer;
-  }
-  Object.defineProperty(pojo, prop, desc);
-}
 
 export { decorateMethodV2 as a, decorateFieldV2 as d, initializeDeferredDecorator as i };

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

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