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

package/dist/prod/packages/shared-chunks/{render-D78XHdek.js → render-DkJJmoI4.js}

@@ -1,16 +1,102 @@
-import { u as unwrap, e as expect, S as StackImpl } from './collections-GpG8lT2g.js';
-import { u as unwrapHandle } from './constants-DThhT5fu.js';
-import { track, updateTag as UPDATE_TAG, 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-BNqcwZWH.js';
-import { P as ProgramImpl } from './program-B7SJZ5NF.js';
-import { G as DebugRenderTreeImpl, H as isArgumentError, e as DOMChangesImpl, I as APPEND_OPCODES, J as move, i as clear, V as VMArgumentsImpl, K as externs, L as JumpIfNotModifiedOpcode, M as BeginTrackFrameOpcode, O as EndTrackFrameOpcode } from './on-CersD7PL.js';
-import { D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-CzXb9l1W.js';
+import { u as unwrap, e as expect, c as isIndexable, S as StackImpl } from './collections-C3Y8z_9v.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, b as isConstRef, u as updateRef, c as createConstRef } from './reference-BshxG6wn.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
+import { P as ProgramImpl } from './program-B7CWdS8W.js';
+import { t as track, U as UPDATE_TAG, m as beginTrackFrame, q as endTrackFrame } from './cache-BIlOoPA7.js';
+import { A as APPEND_OPCODES, D as DebugRenderTreeImpl, i as isArgumentError, h as isCurriedType, d as curry, g as check, j as resolveCurriedValue, f as reifyPositional, k as AssertFilter, V as VMArgumentsImpl, l as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, m as EndTrackFrameOpcode } from './debug-render-tree-CF5O4-WI.js';
+import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-CnlTPNyw.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 { 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-D7nBU9ae.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 { toBool } from '../@glimmer/global-context/index.js';
+import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-zh_k31vb.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-D9jDJVGg.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;
@@ -212,6 +298,7 @@ class EnvironmentImpl {
     return expect(this.updateOperations);
   }
   begin() {
+    assert(!this[TRANSACTION]);
     this.debugRenderTree?.begin();
     this[TRANSACTION] = new TransactionImpl();
   }
@@ -262,6 +349,395 @@ 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) {
+      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();
+  vm.context.resolver;
+  vm.loadValue($v0, createCurryRef(type, definition, owner, capturedArgs));
+});
+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);
+      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);
+      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);
+  }
+  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 {
+    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];
 }
@@ -1459,4 +1935,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/{dev/packages/shared-chunks/chunk-3SQBS3Y5-Cj4eryg1.js → prod/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/{dev/packages/shared-chunks/serialize-builder-DiO7Ak9_.js → prod/packages/shared-chunks/serialize-builder-R3Ozg0sC.js}

@@ -1,13 +1,5 @@
-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 { C as ConcreteBounds } from './dynamic-CgX8M02_.js';
-import './constants-BbdWMvgs.js';
-import '../@glimmer/destroyable/index.js';
-import './capabilities-O_xc7Yqk.js';
-import { N as NewTreeBuilder } from './element-builder-BpJIoi99.js';
+import { C as ConcreteBounds } from './normalize-D9jDJVGg.js';
+import { N as NewTreeBuilder } from './element-builder-CnlTPNyw.js';
 
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 

package/dist/prod/packages/shared-chunks/set_properties-LT3RzRmJ.js

@@ -0,0 +1,48 @@
+import { f as changeProperties } from './computed-DjCIU_ht.js';
+import { s as set } from './property_set-BunbMFtp.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 };