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

package/dist/dev/packages/shared-chunks/{fragment-Cc5k9Oy4.js → curried-BVwSNqpf.js}

@@ -1,292 +1,5 @@
-import { e as $v0, f as $t1, g as $t0, h as $s1, $ as $s0, d as $sp, c as $fp, b as $ra, a as $pc } from './registers-ylirb0dq.js';
-import './debug-to-string-CFb7h0lY.js';
 import { b as assertNever } from './assert-CUCJBR2C.js';
 
-const CURRIED_COMPONENT = 0;
-const CURRIED_HELPER = 1;
-const CURRIED_MODIFIER = 2;
-
-const SIGN_BIT = -536870913;
-const MAX_INT = ~SIGN_BIT - 1;
-const MIN_INT = ~MAX_INT;
-function isHandle(value) {
-  return value >= 0;
-}
-function constants(...values) {
-  return [false, true, null, undefined, ...values];
-}
-function isSmallInt(value) {
-  return value % 1 === 0 && value <= MAX_INT && value >= MIN_INT;
-}
-function encodeNegative(num) {
-  return num & SIGN_BIT;
-}
-function decodeNegative(num) {
-  return num | ~SIGN_BIT;
-}
-function encodePositive(num) {
-  return ~num;
-}
-function decodePositive(num) {
-  return ~num;
-}
-function encodeHandle(num) {
-  return num;
-}
-function decodeHandle(num) {
-  return num;
-}
-function encodeImmediate(num) {
-  num |= 0;
-  return num < 0 ? encodeNegative(num) : encodePositive(num);
-}
-function decodeImmediate(num) {
-  num |= 0;
-  return num > SIGN_BIT ? decodePositive(num) : decodeNegative(num);
-}
-[1, -1].forEach(x => decodeImmediate(encodeImmediate(x)));
-
-const VM_HELPER_OP = 16;
-const VM_SET_NAMED_VARIABLES_OP = 17;
-const VM_SET_BLOCKS_OP = 18;
-const VM_SET_VARIABLE_OP = 19;
-const VM_SET_BLOCK_OP = 20;
-const VM_GET_VARIABLE_OP = 21;
-const VM_GET_PROPERTY_OP = 22;
-const VM_GET_BLOCK_OP = 23;
-const VM_SPREAD_BLOCK_OP = 24;
-const VM_HAS_BLOCK_OP = 25;
-const VM_HAS_BLOCK_PARAMS_OP = 26;
-const VM_CONCAT_OP = 27;
-const VM_CONSTANT_OP = 28;
-const VM_CONSTANT_REFERENCE_OP = 29;
-const VM_PRIMITIVE_OP = 30;
-const VM_PRIMITIVE_REFERENCE_OP = 31;
-const VM_DUP_OP = 33;
-const VM_POP_OP = 34;
-const VM_LOAD_OP = 35;
-const VM_FETCH_OP = 36;
-const VM_ROOT_SCOPE_OP = 37;
-const VM_VIRTUAL_ROOT_SCOPE_OP = 38;
-const VM_CHILD_SCOPE_OP = 39;
-const VM_POP_SCOPE_OP = 40;
-const VM_TEXT_OP = 41;
-const VM_COMMENT_OP = 42;
-const VM_APPEND_HTML_OP = 43;
-const VM_APPEND_SAFE_HTML_OP = 44;
-const VM_APPEND_DOCUMENT_FRAGMENT_OP = 45;
-const VM_APPEND_NODE_OP = 46;
-const VM_APPEND_TEXT_OP = 47;
-const VM_OPEN_ELEMENT_OP = 48;
-const VM_OPEN_DYNAMIC_ELEMENT_OP = 49;
-const VM_PUSH_REMOTE_ELEMENT_OP = 50;
-const VM_STATIC_ATTR_OP = 51;
-const VM_DYNAMIC_ATTR_OP = 52;
-const VM_COMPONENT_ATTR_OP = 53;
-const VM_FLUSH_ELEMENT_OP = 54;
-const VM_CLOSE_ELEMENT_OP = 55;
-const VM_POP_REMOTE_ELEMENT_OP = 56;
-const VM_MODIFIER_OP = 57;
-const VM_BIND_DYNAMIC_SCOPE_OP = 58;
-const VM_PUSH_DYNAMIC_SCOPE_OP = 59;
-const VM_POP_DYNAMIC_SCOPE_OP = 60;
-const VM_COMPILE_BLOCK_OP = 61;
-const VM_PUSH_BLOCK_SCOPE_OP = 62;
-const VM_PUSH_SYMBOL_TABLE_OP = 63;
-const VM_INVOKE_YIELD_OP = 64;
-const VM_JUMP_IF_OP = 65;
-const VM_JUMP_UNLESS_OP = 66;
-const VM_JUMP_EQ_OP = 67;
-const VM_ASSERT_SAME_OP = 68;
-const VM_ENTER_OP = 69;
-const VM_EXIT_OP = 70;
-const VM_TO_BOOLEAN_OP = 71;
-const VM_ENTER_LIST_OP = 72;
-const VM_EXIT_LIST_OP = 73;
-const VM_ITERATE_OP = 74;
-const VM_MAIN_OP = 75;
-const VM_CONTENT_TYPE_OP = 76;
-const VM_CURRY_OP = 77;
-const VM_PUSH_COMPONENT_DEFINITION_OP = 78;
-const VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP = 79;
-const VM_RESOLVE_DYNAMIC_COMPONENT_OP = 80;
-const VM_RESOLVE_CURRIED_COMPONENT_OP = 81;
-const VM_PUSH_ARGS_OP = 82;
-const VM_PUSH_EMPTY_ARGS_OP = 83;
-const VM_PREPARE_ARGS_OP = 85;
-const VM_CAPTURE_ARGS_OP = 86;
-const VM_CREATE_COMPONENT_OP = 87;
-const VM_REGISTER_COMPONENT_DESTRUCTOR_OP = 88;
-const VM_PUT_COMPONENT_OPERATIONS_OP = 89;
-const VM_GET_COMPONENT_SELF_OP = 90;
-const VM_GET_COMPONENT_TAG_NAME_OP = 91;
-const VM_GET_COMPONENT_LAYOUT_OP = 92;
-const VM_POPULATE_LAYOUT_OP = 95;
-const VM_INVOKE_COMPONENT_LAYOUT_OP = 96;
-const VM_BEGIN_COMPONENT_TRANSACTION_OP = 97;
-const VM_COMMIT_COMPONENT_TRANSACTION_OP = 98;
-const VM_DID_CREATE_ELEMENT_OP = 99;
-const VM_DID_RENDER_LAYOUT_OP = 100;
-const VM_DEBUGGER_OP = 103;
-const VM_STATIC_COMPONENT_ATTR_OP = 105;
-const VM_DYNAMIC_CONTENT_TYPE_OP = 106;
-const VM_DYNAMIC_HELPER_OP = 107;
-const VM_DYNAMIC_MODIFIER_OP = 108;
-const VM_IF_INLINE_OP = 109;
-const VM_NOT_OP = 110;
-const VM_GET_DYNAMIC_VAR_OP = 111;
-const VM_LOG_OP = 112;
-const VM_SYSCALL_SIZE = 113;
-
-const VM_PUSH_FRAME_OP = 0;
-const VM_POP_FRAME_OP = 1;
-const VM_INVOKE_VIRTUAL_OP = 2;
-const VM_INVOKE_STATIC_OP = 3;
-const VM_JUMP_OP = 4;
-const VM_RETURN_OP = 5;
-const VM_RETURN_TO_OP = 6;
-const VM_MACHINE_SIZE = 7;
-function isMachineOp(value) {
-  return value >= 0 && value <= 15;
-}
-
-function decodeCurry(curry) {
-  switch (curry) {
-    case CURRIED_COMPONENT:
-      return 'component';
-    case CURRIED_HELPER:
-      return 'helper';
-    case CURRIED_MODIFIER:
-      return 'modifier';
-    default:
-      throw Error(`Unexpected curry value: ${curry}`);
-  }
-}
-function decodeRegister(register) {
-  switch (register) {
-    case $pc:
-      return '$pc';
-    case $ra:
-      return '$ra';
-    case $fp:
-      return '$fp';
-    case $sp:
-      return '$sp';
-    case $s0:
-      return '$s0';
-    case $s1:
-      return '$s1';
-    case $t0:
-      return '$t0';
-    case $t1:
-      return '$t1';
-    case $v0:
-      return '$v0';
-    default:
-      return `$bug${register}`;
-  }
-}
-function decodePrimitive(primitive, constants) {
-  if (primitive >= 0) {
-    return constants.getValue(decodeHandle(primitive));
-  }
-  return decodeImmediate(primitive);
-}
-
-const todo = ({
-  label,
-  value
-}) => ['error:operand', value, {
-  label
-}];
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-class Disassembler {
-  static build(builder) {
-    return builder(new Disassembler()).#disms;
-  }
-  #disms;
-  constructor() {
-    this.#disms = {};
-  }
-  addNullable(names, dism) {
-    for (const name of names) {
-      this.#disms[name] = dism;
-      this.#disms[`${name}?`] = dism;
-    }
-    return this;
-  }
-  add(names, dism) {
-    const add = (name, dism) => this.#disms[name] = dism;
-    for (const name of names) {
-      add(name, dism);
-    }
-    return this;
-  }
-}
-Disassembler.build(d => {
-  return d.add(['imm/u32', 'imm/i32', 'imm/u32{todo}', 'imm/i32{todo}'], ({
-    value
-  }) => ['number', value]).add(['const/i32[]'], ({
-    value,
-    constants
-  }) => ['array', constants.getArray(value), {
-    kind: Number
-  }]).add(['const/bool'], ({
-    value
-  }) => ['boolean', !!value]).add(['imm/bool'], ({
-    value,
-    constants
-  }) => ['boolean', constants.getValue(decodeHandle(value))]).add(['handle'], ({
-    constants,
-    value
-  }) => ['constant', constants.getValue(value)]).add(['handle/block'], ({
-    value,
-    heap
-  }) => ['instruction', heap.getaddr(value)]).add(['imm/pc'], ({
-    value
-  }) => ['instruction', value]).add(['const/any[]'], ({
-    value,
-    constants
-  }) => ['array', constants.getArray(value)]).add(['const/primitive'], ({
-    value,
-    constants
-  }) => ['primitive', decodePrimitive(value, constants)]).add(['register'], ({
-    value
-  }) => ['register', decodeRegister(value)]).add(['const/any'], ({
-    value,
-    constants
-  }) => ['dynamic', constants.getValue(value)]).add(['variable'], ({
-    value,
-    meta
-  }) => {
-    return ['variable', value, {
-      name: meta?.symbols.lexical?.at(value) ?? null
-    }];
-  }).add(['register/instruction'], ({
-    value
-  }) => ['instruction', value]).add(['imm/enum<curry>'], ({
-    value
-  }) => ['enum<curry>', decodeCurry(value)]).addNullable(['const/str'], ({
-    value,
-    constants
-  }) => ['string', constants.getValue(value)]).addNullable(['const/str[]'], ({
-    value,
-    constants
-  }) => ['array', constants.getArray(value), {
-    kind: String
-  }]).add(['imm/block:handle'], todo).add(['const/definition'], todo).add(['const/fn'], todo).add(['instruction/relative'], ({
-    value,
-    offset
-  }) => ['instruction', offset + value]).add(['register/sN'], todo).add(['register/stack'], todo).add(['register/tN'], todo).add(['register/v0'], todo);
-});
-
-/* This file is generated by build/debug.js */
-
-new Array(VM_SYSCALL_SIZE).fill(null);
-new Array(VM_MACHINE_SIZE).fill(null);
-
 const ANNOTATION_STYLES = ['background-color: oklch(93% 0.03 300); color: oklch(34% 0.18 300)', 'background-color: oklch(93% 0.03 250); color: oklch(34% 0.18 250)', 'background-color: oklch(93% 0.03 200); color: oklch(34% 0.18 200)', 'background-color: oklch(93% 0.03 150); color: oklch(34% 0.18 150)', 'background-color: oklch(93% 0.03 100); color: oklch(34% 0.18 100)', 'background-color: oklch(93% 0.03 50); color: oklch(34% 0.18 50)', 'background-color: oklch(93% 0.03 0); color: oklch(34% 0.18 0)'];
 
 /**
@@ -908,4 +621,8 @@ const as = Object.fromEntries(Object.entries(STYLES).map(([k, v]) => [k, value =
   style: v
 })]));
 
-export { VM_CLOSE_ELEMENT_OP as $, isHandle as A, decodeImmediate as B, CURRIED_COMPONENT as C, VM_PRIMITIVE_REFERENCE_OP as D, VM_DUP_OP as E, VM_POP_OP as F, VM_LOAD_OP as G, VM_FETCH_OP as H, VM_BIND_DYNAMIC_SCOPE_OP as I, VM_ENTER_OP as J, VM_EXIT_OP as K, VM_PUSH_SYMBOL_TABLE_OP as L, VM_PUSH_BLOCK_SCOPE_OP as M, VM_COMPILE_BLOCK_OP as N, VM_INVOKE_YIELD_OP as O, VM_JUMP_IF_OP as P, VM_JUMP_UNLESS_OP as Q, VM_JUMP_EQ_OP as R, VM_TO_BOOLEAN_OP as S, VM_TEXT_OP as T, VM_COMMENT_OP as U, VM_MAIN_OP as V, VM_OPEN_ELEMENT_OP as W, VM_OPEN_DYNAMIC_ELEMENT_OP as X, VM_PUSH_REMOTE_ELEMENT_OP as Y, VM_POP_REMOTE_ELEMENT_OP as Z, VM_FLUSH_ELEMENT_OP as _, VM_CONTENT_TYPE_OP as a, VM_MODIFIER_OP as a0, VM_DYNAMIC_MODIFIER_OP as a1, VM_STATIC_ATTR_OP as a2, VM_DYNAMIC_ATTR_OP as a3, CURRIED_MODIFIER as a4, VM_PUSH_COMPONENT_DEFINITION_OP as a5, VM_RESOLVE_DYNAMIC_COMPONENT_OP as a6, VM_PUSH_ARGS_OP as a7, VM_PUSH_EMPTY_ARGS_OP as a8, VM_CAPTURE_ARGS_OP as a9, VM_GET_PROPERTY_OP as aA, VM_GET_BLOCK_OP as aB, VM_SPREAD_BLOCK_OP as aC, VM_HAS_BLOCK_OP as aD, VM_HAS_BLOCK_PARAMS_OP as aE, VM_CONCAT_OP as aF, VM_IF_INLINE_OP as aG, VM_NOT_OP as aH, VM_GET_DYNAMIC_VAR_OP as aI, VM_LOG_OP as aJ, VM_DYNAMIC_CONTENT_TYPE_OP as aK, VM_DEBUGGER_OP as aL, VM_ENTER_LIST_OP as aM, VM_EXIT_LIST_OP as aN, VM_ITERATE_OP as aO, encodeHandle as aP, isMachineOp as aQ, isSmallInt as aR, encodeImmediate as aS, VM_PREPARE_ARGS_OP as aa, VM_CREATE_COMPONENT_OP as ab, VM_REGISTER_COMPONENT_DESTRUCTOR_OP as ac, VM_BEGIN_COMPONENT_TRANSACTION_OP as ad, VM_PUT_COMPONENT_OPERATIONS_OP as ae, VM_COMPONENT_ATTR_OP as af, VM_STATIC_COMPONENT_ATTR_OP as ag, VM_DID_CREATE_ELEMENT_OP as ah, VM_GET_COMPONENT_SELF_OP as ai, VM_GET_COMPONENT_TAG_NAME_OP as aj, VM_GET_COMPONENT_LAYOUT_OP as ak, VM_POPULATE_LAYOUT_OP as al, VM_VIRTUAL_ROOT_SCOPE_OP as am, VM_SET_NAMED_VARIABLES_OP as an, VM_SET_BLOCKS_OP as ao, VM_INVOKE_COMPONENT_LAYOUT_OP as ap, VM_DID_RENDER_LAYOUT_OP as aq, VM_COMMIT_COMPONENT_TRANSACTION_OP as ar, VM_CURRY_OP as as, VM_DYNAMIC_HELPER_OP as at, CURRIED_HELPER as au, VM_HELPER_OP as av, VM_GET_VARIABLE_OP as aw, VM_SET_VARIABLE_OP as ax, VM_SET_BLOCK_OP as ay, VM_ROOT_SCOPE_OP as az, VM_ASSERT_SAME_OP as b, constants as c, VM_APPEND_HTML_OP as d, VM_APPEND_TEXT_OP as e, VM_RESOLVE_CURRIED_COMPONENT_OP as f, VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP as g, VM_APPEND_SAFE_HTML_OP as h, VM_APPEND_DOCUMENT_FRAGMENT_OP as i, VM_APPEND_NODE_OP as j, VM_INVOKE_STATIC_OP as k, VM_RETURN_TO_OP as l, VM_RETURN_OP as m, VM_JUMP_OP as n, VM_INVOKE_VIRTUAL_OP as o, VM_POP_FRAME_OP as p, VM_PUSH_FRAME_OP as q, VM_SYSCALL_SIZE as r, VM_CHILD_SCOPE_OP as s, VM_POP_SCOPE_OP as t, VM_PUSH_DYNAMIC_SCOPE_OP as u, VM_POP_DYNAMIC_SCOPE_OP as v, VM_CONSTANT_OP as w, decodeHandle as x, VM_CONSTANT_REFERENCE_OP as y, VM_PRIMITIVE_OP as z };
+const CURRIED_COMPONENT = 0;
+const CURRIED_HELPER = 1;
+const CURRIED_MODIFIER = 2;
+
+export { CURRIED_MODIFIER as C, CURRIED_HELPER as a, CURRIED_COMPONENT as b };

package/dist/dev/packages/shared-chunks/decorator-B5Uh5NFI.js

@@ -0,0 +1,135 @@
+import { meta, peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import '../@ember/debug/index.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+// Same as built-in MethodDecorator but with more arguments
+
+function isElementDescriptor(args) {
+  let [maybeTarget, maybeKey, maybeDesc] = args;
+  return (
+    // Ensure we have the right number of args
+    args.length === 3 && (
+    // Make sure the target is a class or object (prototype)
+    typeof maybeTarget === 'function' || typeof maybeTarget === 'object' && maybeTarget !== null) &&
+    // Make sure the key is a string
+    typeof maybeKey === 'string' && (
+    // Make sure the descriptor is the right shape
+    typeof maybeDesc === 'object' && maybeDesc !== null || maybeDesc === undefined)
+  );
+}
+function nativeDescDecorator(propertyDesc) {
+  let decorator = function () {
+    return propertyDesc;
+  };
+  setClassicDecorator(decorator);
+  return decorator;
+}
+
+/**
+  Objects of this type can implement an interface to respond to requests to
+  get and set. The default implementation handles simple properties.
+
+  @class Descriptor
+  @private
+*/
+class ComputedDescriptor {
+  enumerable = true;
+  configurable = true;
+  _dependentKeys = undefined;
+  _meta = undefined;
+  setup(_obj, keyName, _propertyDesc, meta) {
+    meta.writeDescriptors(keyName, this);
+  }
+  teardown(_obj, keyName, meta) {
+    meta.removeDescriptors(keyName);
+  }
+}
+let COMPUTED_GETTERS;
+{
+  COMPUTED_GETTERS = new WeakSet();
+}
+function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
+  function getter() {
+    return descriptor.get(this, name);
+  }
+  {
+    COMPUTED_GETTERS.add(getter);
+  }
+  return getter;
+}
+function DESCRIPTOR_SETTER_FUNCTION(name, descriptor) {
+  let set = function CPSETTER_FUNCTION(value) {
+    return descriptor.set(this, name, value);
+  };
+  COMPUTED_SETTERS.add(set);
+  return set;
+}
+const COMPUTED_SETTERS = new WeakSet();
+function makeComputedDecorator(desc, DecoratorClass) {
+  let decorator = function COMPUTED_DECORATOR(target, key, propertyDesc, maybeMeta, isClassicDecorator) {
+    (!(isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)) && assert(`Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`, isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)));
+    let meta$1 = arguments.length === 3 ? meta(target) : maybeMeta;
+    desc.setup(target, key, propertyDesc, meta$1);
+    let computedDesc = {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      get: DESCRIPTOR_GETTER_FUNCTION(key, desc),
+      set: DESCRIPTOR_SETTER_FUNCTION(key, desc)
+    };
+    return computedDesc;
+  };
+  setClassicDecorator(decorator, desc);
+  Object.setPrototypeOf(decorator, DecoratorClass.prototype);
+  return decorator;
+}
+
+/////////////
+
+const DECORATOR_DESCRIPTOR_MAP = new WeakMap();
+
+/**
+  Returns the CP descriptor associated with `obj` and `keyName`, if any.
+
+  @method descriptorForProperty
+  @param {Object} obj the object to check
+  @param {String} keyName the key to check
+  @return {Descriptor}
+  @private
+*/
+function descriptorForProperty(obj, keyName, _meta) {
+  (!(obj !== null) && assert('Cannot call `descriptorForProperty` on null', obj !== null));
+  (!(obj !== undefined) && assert('Cannot call `descriptorForProperty` on undefined', obj !== undefined));
+  (!(typeof obj === 'object' || typeof obj === 'function') && assert(`Cannot call \`descriptorForProperty\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function'));
+  let meta = _meta === undefined ? peekMeta(obj) : _meta;
+  if (meta !== null) {
+    return meta.peekDescriptors(keyName);
+  }
+}
+function descriptorForDecorator(dec) {
+  return DECORATOR_DESCRIPTOR_MAP.get(dec);
+}
+
+/**
+  Check whether a value is a decorator
+
+  @method isClassicDecorator
+  @param {any} possibleDesc the value to check
+  @return {boolean}
+  @private
+*/
+function isClassicDecorator(dec) {
+  return typeof dec === 'function' && DECORATOR_DESCRIPTOR_MAP.has(dec);
+}
+
+/**
+  Set a value as a decorator
+
+  @method setClassicDecorator
+  @param {function} decorator the value to mark as a decorator
+  @private
+*/
+function setClassicDecorator(dec, value = true) {
+  DECORATOR_DESCRIPTOR_MAP.set(dec, value);
+}
+
+export { COMPUTED_SETTERS as C, isClassicDecorator as a, descriptorForDecorator as b, ComputedDescriptor as c, descriptorForProperty as d, isElementDescriptor as i, makeComputedDecorator as m, nativeDescDecorator as n, setClassicDecorator as s };

package/dist/dev/packages/shared-chunks/element-C-QcIABg.js

@@ -0,0 +1,109 @@
+import { a as createComputeRef, v as valueForRef, N as NULL_REFERENCE } from './reference-BoPB2LfI.js';
+import { s as setInternalComponentManager } from './api-WvJPuo9z.js';
+import '../@ember/debug/index.js';
+import { i as internalHelper } from './internal-helper-Dsl9_7H_.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+/**
+  @module @ember/helper
+*/
+
+
+// ============ Element Component (for string tag names) ============
+// Renders content wrapped in the specified HTML element, or just renders
+// content without a wrapper for empty string.
+
+const ELEMENT_CAPABILITIES = {
+  createInstance: true,
+  wrapped: true
+};
+class ElementComponentManager {
+  getCapabilities() {
+    return ELEMENT_CAPABILITIES;
+  }
+  getDebugName(state) {
+    return `(element "${state.tagName}")`;
+  }
+  getSelf() {
+    return NULL_REFERENCE;
+  }
+  getDestroyable() {
+    return null;
+  }
+  didCreateElement() {}
+  create(_owner, state) {
+    // For empty string, return null so getTagName returns null (no wrapper element)
+    return state.tagName || null;
+  }
+  getTagName(state) {
+    return state;
+  }
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  didCreate() {}
+  didUpdate() {}
+}
+const ELEMENT_COMPONENT_MANAGER = new ElementComponentManager();
+class ElementComponentDefinition {
+  constructor(tagName) {
+    this.tagName = tagName;
+  }
+  toString() {
+    return `(element "${this.tagName}")`;
+  }
+}
+setInternalComponentManager(ELEMENT_COMPONENT_MANAGER, ElementComponentDefinition.prototype);
+
+// Cache component definitions per tag name to avoid creating duplicate definitions
+const ELEMENT_DEFINITIONS = new Map();
+function getElementDefinition(tagName) {
+  let definition = ELEMENT_DEFINITIONS.get(tagName);
+  if (definition === undefined) {
+    definition = new ElementComponentDefinition(tagName);
+    ELEMENT_DEFINITIONS.set(tagName, definition);
+  }
+  return definition;
+}
+
+// ============ Element Helper ============
+
+/**
+  The `element` helper lets you dynamically set the tag name of an element.
+
+  ```handlebars
+  {{#let (element @tagName) as |Tag|}}
+    <Tag class="my-element">Hello</Tag>
+  {{/let}}
+  ```
+
+  When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
+
+  When `@tagName` is an empty string `""`, the block content is rendered without
+  a wrapping element.
+
+  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.
+
+  @method element
+  @for Ember.Templates.helpers
+  @public
+*/
+const element = internalHelper(({
+  positional,
+  named
+}) => {
+  return createComputeRef(() => {
+    {
+      (!(positional.length === 1) && assert('The `element` helper takes a single positional argument', positional.length === 1));
+      (!(Object.keys(named).length === 0) && assert('The `element` helper does not take any named arguments', Object.keys(named).length === 0));
+    }
+    let tagName = valueForRef(positional[0]);
+    {
+      (!(typeof tagName === 'string') && assert(`The argument passed to the \`element\` helper must be a string${tagName === null || tagName === undefined || typeof tagName === 'object' ? '' : ` (you passed \`${tagName}\`)`}`, typeof tagName === 'string'));
+    }
+    return getElementDefinition(tagName);
+  }, null, 'element');
+});
+
+export { element as e };