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

package/dist/dev/packages/shared-chunks/{index-BUPd6pkm.js → index-CyZiGiEI.js}

@@ -1,20 +1,17 @@
-import { z as VM_PRIMITIVE_OP, m as VM_RETURN_OP, aP as encodeHandle, aQ as isMachineOp, aF as VM_CONCAT_OP, aw as VM_GET_VARIABLE_OP, y as VM_CONSTANT_REFERENCE_OP, aA as VM_GET_PROPERTY_OP, aD as VM_HAS_BLOCK_OP, aC as VM_SPREAD_BLOCK_OP, N as VM_COMPILE_BLOCK_OP, aE as VM_HAS_BLOCK_PARAMS_OP, aG as VM_IF_INLINE_OP, aH as VM_NOT_OP, aI as VM_GET_DYNAMIC_VAR_OP, q as VM_PUSH_FRAME_OP, aJ as VM_LOG_OP, p as VM_POP_FRAME_OP, H as VM_FETCH_OP, D as VM_PRIMITIVE_REFERENCE_OP, av as VM_HELPER_OP, E as VM_DUP_OP, at as VM_DYNAMIC_HELPER_OP, F as VM_POP_OP, a9 as VM_CAPTURE_ARGS_OP, as as VM_CURRY_OP, aR as isSmallInt, aS as encodeImmediate, u as VM_PUSH_DYNAMIC_SCOPE_OP, I as VM_BIND_DYNAMIC_SCOPE_OP, v as VM_POP_DYNAMIC_SCOPE_OP, aB as VM_GET_BLOCK_OP, O as VM_INVOKE_YIELD_OP, t as VM_POP_SCOPE_OP, s as VM_CHILD_SCOPE_OP, ax as VM_SET_VARIABLE_OP, o as VM_INVOKE_VIRTUAL_OP, w as VM_CONSTANT_OP, M as VM_PUSH_BLOCK_SCOPE_OP, L as VM_PUSH_SYMBOL_TABLE_OP, a8 as VM_PUSH_EMPTY_ARGS_OP, a7 as VM_PUSH_ARGS_OP, J as VM_ENTER_OP, R as VM_JUMP_EQ_OP, n as VM_JUMP_OP, K as VM_EXIT_OP, l as VM_RETURN_TO_OP, Q as VM_JUMP_UNLESS_OP, a5 as VM_PUSH_COMPONENT_DEFINITION_OP, G as VM_LOAD_OP, ad as VM_BEGIN_COMPONENT_TRANSACTION_OP, ab as VM_CREATE_COMPONENT_OP, ac as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, ai as VM_GET_COMPONENT_SELF_OP, az as VM_ROOT_SCOPE_OP, ay as VM_SET_BLOCK_OP, aq as VM_DID_RENDER_LAYOUT_OP, ar as VM_COMMIT_COMPONENT_TRANSACTION_OP, aa as VM_PREPARE_ARGS_OP, am as VM_VIRTUAL_ROOT_SCOPE_OP, an as VM_SET_NAMED_VARIABLES_OP, ao as VM_SET_BLOCKS_OP, ap as VM_INVOKE_COMPONENT_LAYOUT_OP, ae as VM_PUT_COMPONENT_OPERATIONS_OP, X as VM_OPEN_DYNAMIC_ELEMENT_OP, ah as VM_DID_CREATE_ELEMENT_OP, _ as VM_FLUSH_ELEMENT_OP, $ as VM_CLOSE_ELEMENT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, a6 as VM_RESOLVE_DYNAMIC_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ak as VM_GET_COMPONENT_LAYOUT_OP, al as VM_POPULATE_LAYOUT_OP, aj as VM_GET_COMPONENT_TAG_NAME_OP, U as VM_COMMENT_OP, a0 as VM_MODIFIER_OP, a1 as VM_DYNAMIC_MODIFIER_OP, a2 as VM_STATIC_ATTR_OP, ag as VM_STATIC_COMPONENT_ATTR_OP, a3 as VM_DYNAMIC_ATTR_OP, af as VM_COMPONENT_ATTR_OP, W as VM_OPEN_ELEMENT_OP, aL as VM_DEBUGGER_OP, T as VM_TEXT_OP, k as VM_INVOKE_STATIC_OP, aK as VM_DYNAMIC_CONTENT_TYPE_OP, Y as VM_PUSH_REMOTE_ELEMENT_OP, Z as VM_POP_REMOTE_ELEMENT_OP, S as VM_TO_BOOLEAN_OP, aM as VM_ENTER_LIST_OP, aO as VM_ITERATE_OP, aN as VM_EXIT_LIST_OP } from './fragment-Cc5k9Oy4.js';
-import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
-import '../@glimmer/global-context/index.js';
-import '../@glimmer/validator/index.js';
-import './reference-C3TKDRnP.js';
-import { a as assert } from './assert-CUCJBR2C.js';
-import { e as expect, u as unwrap, S as StackImpl, d as dict } from './collections-D_nY_0UJ.js';
-import { SexpOpcodes as opcodes } from '../@glimmer/wire-format/index.js';
-import { e as $v0, c as $fp, $ as $s0, d as $sp, h as $s1 } from './registers-ylirb0dq.js';
-import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
-import { ContentType } from '../@glimmer/vm/index.js';
-import '../@glimmer/destroyable/index.js';
-import { h as hasCapability } from './capabilities-O_xc7Yqk.js';
-import { b as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
+import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
+import { r as VM_PRIMITIVE_OP, aF as encodeHandle, av as VM_CONCAT_OP, am as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, aq as VM_GET_PROPERTY_OP, at as VM_HAS_BLOCK_OP, as as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, au as VM_HAS_BLOCK_PARAMS_OP, aw as VM_IF_INLINE_OP, ax as VM_NOT_OP, ay as VM_GET_DYNAMIC_VAR_OP, az as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, al as VM_HELPER_OP, v as VM_DUP_OP, ak as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, aj as VM_CURRY_OP, aG as isSmallInt, aH as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, ar as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, an as VM_SET_VARIABLE_OP, o as VM_CONSTANT_OP, D as VM_PUSH_BLOCK_SCOPE_OP, C as VM_PUSH_SYMBOL_TABLE_OP, _ as VM_PUSH_EMPTY_ARGS_OP, Z as VM_PUSH_ARGS_OP, A as VM_ENTER_OP, I as VM_JUMP_EQ_OP, B as VM_EXIT_OP, H as VM_JUMP_UNLESS_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, x as VM_LOAD_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a8 as VM_GET_COMPONENT_SELF_OP, ap as VM_ROOT_SCOPE_OP, ao as VM_SET_BLOCK_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP, a0 as VM_PREPARE_ARGS_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, a7 as VM_DID_CREATE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, ab as VM_POPULATE_LAYOUT_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, L as VM_COMMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, a5 as VM_COMPONENT_ATTR_OP, M as VM_OPEN_ELEMENT_OP, ai as VM_DEBUGGER_OP, K as VM_TEXT_OP, aA as VM_DYNAMIC_CONTENT_TYPE_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, J as VM_TO_BOOLEAN_OP, aB as VM_ENTER_LIST_OP, aD as VM_ITERATE_OP, aC as VM_EXIT_LIST_OP } from './syscall-ops-BPFtDquC.js';
+import { b as VM_RETURN_OP, i as isMachineOp, f as VM_PUSH_FRAME_OP, e as VM_POP_FRAME_OP, d as VM_INVOKE_VIRTUAL_OP, c as VM_JUMP_OP, a as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { e as expect, u as unwrap, S as StackImpl, d as dict } from './collections-DPkjqeA3.js';
 import { i as isPresentArray } from './present-B1rrjAVM.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
+import { b as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
+import { o as opcodes } from './opcodes-CplRyHl_.js';
+import { a as $v0, f as $fp, $ as $s0, g as $sp, h as $s1 } from './registers-C_W2qYHJ.js';
+import { ContentType } from '../@glimmer/vm/index.js';
+import { h as hasCapability } from './capabilities-CZkuOqqC.js';
 
 function isGetLikeTuple(opcode) {
   return Array.isArray(opcode) && opcode.length === 2;
@@ -48,10 +45,10 @@ function assertResolverInvariants(meta) {
  * <Foo @arg={{true}} />
  */
 function resolveComponent(resolver, constants, meta, [, expr, then]) {
-  (!(isGetFreeComponent(expr)) && assert(isGetFreeComponent(expr)));
+  assert(isGetFreeComponent(expr));
   let type = expr[0];
   if (expr[0] === opcodes.GetStrictKeyword) {
-    (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+    assert(!meta.isStrictMode);
     throw new Error(`Attempted to resolve a component in a strict mode template, but that value was not in scope: ${
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
     meta.symbols.upvars[expr[1]] ?? '{unknown variable}'}`);
@@ -76,7 +73,7 @@ function resolveComponent(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let definition = resolver?.lookupComponent?.(name, owner) ?? null;
     if ((typeof definition !== 'object' || definition === null)) {
-      (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+      assert(!meta.isStrictMode);
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
     }
 
@@ -90,7 +87,7 @@ function resolveComponent(resolver, constants, meta, [, expr, then]) {
  * (helper arg)
  */
 function resolveHelper(resolver, constants, meta, [, expr, then]) {
-  (!(isGetFreeHelper(expr)) && assert(isGetFreeHelper(expr)));
+  assert(isGetFreeHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -110,7 +107,7 @@ function resolveHelper(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let helper = resolver?.lookupHelper?.(name, owner) ?? null;
     if (helper === null) {
-      (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+      assert(!meta.isStrictMode);
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a helper, but nothing was found.`);
     }
 
@@ -125,7 +122,7 @@ function resolveHelper(resolver, constants, meta, [, expr, then]) {
  * <Foo {{modifier}}/>
  */
 function resolveModifier(resolver, constants, meta, [, expr, then]) {
-  (!(isGetFreeModifier(expr)) && assert(isGetFreeModifier(expr)));
+  assert(isGetFreeModifier(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -145,7 +142,7 @@ function resolveModifier(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let modifier = resolver?.lookupBuiltInModifier?.(name) ?? null;
     if (modifier === null) {
-      (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+      assert(!meta.isStrictMode);
       throw new Error(`Attempted to resolve a modifier in a strict mode template, but it was not in scope: ${name}`);
     }
 
@@ -161,7 +158,7 @@ function resolveModifier(resolver, constants, meta, [, expr, then]) {
     let name = unwrap(upvars[expr[1]]);
     let modifier = resolver?.lookupModifier?.(name, owner) ?? null;
     if (modifier === null) {
-      (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+      assert(!meta.isStrictMode);
       throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a modifier, but nothing was found.`);
     }
 
@@ -177,7 +174,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
   ifComponent,
   ifHelper
 }]) {
-  (!(isGetFreeComponentOrHelper(expr)) && assert(isGetFreeComponentOrHelper(expr)));
+  assert(isGetFreeComponentOrHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -195,7 +192,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
     }
     let helper = constants.helper(definition, null, true);
     if (helper === null) {
-      (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+      assert(!meta.isStrictMode);
       throw new Error(
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       `Attempted to use a value as either a component or helper, but it did not have a component manager or helper manager associated with it. The value was: ${debugToString(definition)}`);
@@ -217,7 +214,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
     } else {
       let helper = resolver?.lookupHelper?.(name, owner) ?? null;
       if (helper === null) {
-        (!(!meta.isStrictMode) && assert(!meta.isStrictMode));
+        assert(!meta.isStrictMode);
         throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component or helper, but nothing was found.`);
       }
 
@@ -235,7 +232,7 @@ function resolveOptionalComponentOrHelper(resolver, constants, meta, [, expr, {
   ifHelper,
   ifValue
 }]) {
-  (!(isGetFreeComponentOrHelper(expr)) && assert(isGetFreeComponentOrHelper(expr)));
+  assert(isGetFreeComponentOrHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -292,7 +289,9 @@ function lookupBuiltInHelper(expr, resolver, meta, constants, type) {
   let name = unwrap(upvars[expr[1]]);
   let helper = resolver?.lookupBuiltInHelper?.(name) ?? null;
   if (helper === null) {
-    (!(!meta.isStrictMode) && assert(!meta.isStrictMode)); // Keyword helper did not exist, which means that we're attempting to use a
+    assert(!meta.isStrictMode);
+
+    // Keyword helper did not exist, which means that we're attempting to use a
     // value of some kind that is not in scope
     throw new Error(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
@@ -404,7 +403,7 @@ class Labels {
     } of targets) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       let address = labels[target] - at;
-      (!(heap.getbyaddr(at) === -1) && assert(heap.getbyaddr(at) === -1));
+      assert(heap.getbyaddr(at) === -1);
       heap.setbyaddr(at, address);
     }
   }
@@ -568,7 +567,7 @@ class Compilers {
     let name = sexp[0];
     let index = unwrap(this.names[name]);
     let func = this.funcs[index];
-    (!(func) && assert(func, `expected an implementation for ${sexp[0]}`));
+    assert(func, `expected an implementation for ${sexp[0]}`);
     func(op, sexp);
   }
 }

package/dist/dev/packages/shared-chunks/index-D-xTBV4B.js

@@ -0,0 +1,220 @@
+/**
+@module @ember/template
+*/
+
+/**
+  A wrapper around a string that has been marked as "trusted". **When
+  rendered in HTML, Ember will not perform any escaping.**
+
+  Note:
+
+  1. This does not *make* the string safe; it means that some code in your
+     application has *marked* it as trusted using the `trustHTML()` function.
+
+  2. The only public API for getting a `TrustedHTML` is calling `trustHTML()`. It
+     is *not* user-constructible.
+
+  If a string contains user inputs or other untrusted data, you must sanitize
+  the string before using the `trustHTML` method. Otherwise your code is
+  vulnerable to [Cross-Site Scripting][xss]. There are many open source
+  sanitization libraries to choose from, both for front end and server-side
+  sanitization.
+
+  [xss]: https://owasp.org/www-community/attacks/DOM_Based_XSS
+
+  ```javascript
+  import { trustHTML } from '@ember/template';
+
+  let someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  trustHTML(someTrustedorSanitizedString);
+  ```
+
+  @for @ember/template
+  @class TrustedHTML
+  @since 6.7.0
+  @public
+ */
+class TrustedHTML {
+  __string;
+  constructor(string) {
+    this.__string = string;
+  }
+
+  /**
+    Get the string back to use as a string.
+     @public
+    @method toString
+    @returns {String} The string marked as trusted
+   */
+  toString() {
+    return `${this.__string}`;
+  }
+
+  /**
+    Get the wrapped string as HTML to use without escaping.
+     @public
+    @method toHTML
+    @returns {String} the trusted string, without any escaping applied
+   */
+  toHTML() {
+    return this.toString();
+  }
+}
+
+/**
+  A wrapper around a string that has been marked as safe ("trusted"). **When
+  rendered in HTML, Ember will not perform any escaping.**
+
+  Note:
+
+  1. This does not *make* the string safe; it means that some code in your
+     application has *marked* it as safe using the `htmlSafe()` function.
+
+  2. The only public API for getting a `SafeString` is calling `htmlSafe()`. It
+     is *not* user-constructible.
+
+  If a string contains user inputs or other untrusted data, you must sanitize
+  the string before using the `htmlSafe` method. Otherwise your code is
+  vulnerable to [Cross-Site Scripting][xss]. There are many open source
+  sanitization libraries to choose from, both for front end and server-side
+  sanitization.
+
+  [xss]: https://owasp.org/www-community/attacks/DOM_Based_XSS
+
+  ```javascript
+  import { htmlSafe } from '@ember/template';
+
+  let someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  htmlSafe(someTrustedorSanitizedString);
+  ```
+
+  @for @ember/template
+  @class SafeString
+  @since 4.12.0
+  @public
+ */
+const SafeString = TrustedHTML;
+/**
+  Use this method to indicate that a string should be rendered as HTML
+  when the string is used in a template. To say this another way,
+  strings marked with `htmlSafe` will not be HTML escaped.
+
+  A word of warning -   The `htmlSafe` method does not make the string safe;
+  it only tells the framework to treat the string as if it is safe to render
+  as HTML. If a string contains user inputs or other untrusted
+  data, you must sanitize the string before using the `htmlSafe` method.
+  Otherwise your code is vulnerable to
+  [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+  There are many open source sanitization libraries to choose from,
+  both for front end and server-side sanitization.
+
+  ```javascript
+  import { htmlSafe } from '@ember/template';
+
+  const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  htmlSafe(someTrustedorSanitizedString)
+  ```
+
+  @method htmlSafe
+  @for @ember/template
+  @param str {String} The string to treat as trusted.
+  @static
+  @return {SafeString} A string that will not be HTML escaped by Handlebars.
+  @public
+*/
+const htmlSafe = trustHTML;
+
+/**
+  Use this method to indicate that a string should be rendered as HTML
+  without escaping when the string is used in a template. To say this another way,
+  strings marked with `trustHTML` will not be HTML escaped.
+
+  A word of warning -   The `trustHTML` method does not make the string safe;
+  it only tells the framework to treat the string as if it is safe to render
+  as HTML - that we trust its contents to be safe. If a string contains user inputs or other untrusted
+  data, you must sanitize the string before using the `trustHTML` method.
+  Otherwise your code is vulnerable to
+  [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+  There are many open source sanitization libraries to choose from,
+  both for front end and server-side sanitization.
+
+  ```glimmer-js
+  import { trustHTML } from '@ember/template';
+
+  const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  <template>
+    {{trustHTML someTrustedOrSanitizedString}}
+  </template>
+  ```
+
+  @method trustHTML
+  @for @ember/template
+  @param str {String} The string to treat as trusted.
+  @static
+  @return {TrustedHTML} A string that will not be HTML escaped by Handlebars.
+  @public
+ */
+function trustHTML(str) {
+  if (str === null || str === undefined) {
+    str = '';
+  } else if (typeof str !== 'string') {
+    str = String(str);
+  }
+  return new TrustedHTML(str);
+}
+
+/**
+  Detects if a string was decorated using `htmlSafe`.
+
+  ```javascript
+  import { htmlSafe, isHTMLSafe } from '@ember/template';
+
+  let plainString = 'plain string';
+  let safeString = htmlSafe('<div>someValue</div>');
+
+  isHTMLSafe(plainString); // false
+  isHTMLSafe(safeString);  // true
+  ```
+
+  @method isHTMLSafe
+  @for @ember/template
+  @static
+  @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
+  @public
+*/
+const isHTMLSafe = isTrustedHTML;
+
+/**
+  Detects if a string was decorated using `trustHTML`.
+
+  ```javascript
+  import { trustHTML, isTrustedHTML } from '@ember/template';
+
+  let plainString = 'plain string';
+  let safeString = trustHTML('<div>someValue</div>');
+
+  isTrustedHTML(plainString); // false
+  isTrustedHTML(safeString);  // true
+  ```
+
+  @method isTrustedHTML
+  @for @ember/template
+  @static
+  @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
+  @public
+*/
+function isTrustedHTML(str) {
+  return (
+    // SAFETY: cast `as SafeString` only present to make this check "legal"; we
+    // can further improve this by changing the behavior to do an `in` check
+    // instead, but that's worth landing as a separate change for bisecting if
+    // it happens to have an impact on e.g. perf.
+    str !== null && typeof str === 'object' && typeof str.toHTML === 'function'
+  );
+}
+
+export { SafeString as S, TrustedHTML as T, isTrustedHTML as a, htmlSafe as h, isHTMLSafe as i, trustHTML as t };

package/dist/dev/packages/shared-chunks/injected_property-B4T-FzZZ.js

@@ -0,0 +1,70 @@
+import { getOwner } from '../@ember/-internals/owner/index.js';
+import '../@ember/debug/index.js';
+import { c as computed, d as defineProperty } from './computed-CJnghmXC.js';
+import { i as isElementDescriptor } from './decorator-B5Uh5NFI.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+let DEBUG_INJECTION_FUNCTIONS;
+{
+  DEBUG_INJECTION_FUNCTIONS = new WeakMap();
+}
+
+/**
+ @module ember
+ @private
+ */
+
+/**
+  Read-only property that returns the result of a container lookup.
+
+  @class InjectedProperty
+  @namespace Ember
+  @constructor
+  @param {String} type The container type the property will lookup
+  @param {String} nameOrDesc (optional) The name the property will lookup, defaults
+         to the property's name
+  @private
+*/
+// Decorator factory (with args)
+// (Also matches non-decorator form, types may be incorrect for this.)
+
+// Non-decorator
+
+// Decorator (without args)
+
+// Catch-all for service and controller injections
+
+function inject(type, ...args) {
+  (!(typeof type === 'string') && assert('a string type must be provided to inject', typeof type === 'string'));
+  let elementDescriptor;
+  let name;
+  if (isElementDescriptor(args)) {
+    elementDescriptor = args;
+  } else if (typeof args[0] === 'string') {
+    name = args[0];
+  }
+  let getInjection = function (propertyName) {
+    let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
+    (!(Boolean(owner)) && assert(`Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`, Boolean(owner)));
+    return owner.lookup(`${type}:${name || propertyName}`);
+  };
+  {
+    DEBUG_INJECTION_FUNCTIONS.set(getInjection, {
+      type,
+      name
+    });
+  }
+  let decorator = computed({
+    get: getInjection,
+    set(keyName, value) {
+      defineProperty(this, keyName, null, value);
+    }
+  });
+  if (elementDescriptor) {
+    return decorator(elementDescriptor[0], elementDescriptor[1], elementDescriptor[2]);
+  } else {
+    return decorator;
+  }
+}
+
+export { DEBUG_INJECTION_FUNCTIONS as D, inject as i };

package/dist/dev/packages/shared-chunks/intern-zquhAEIg.js

@@ -0,0 +1,51 @@
+/**
+  Strongly hint runtimes to intern the provided string.
+
+  When do I need to use this function?
+
+  For the most part, never. Pre-mature optimization is bad, and often the
+  runtime does exactly what you need it to, and more often the trade-off isn't
+  worth it.
+
+  Why?
+
+  Runtimes store strings in at least 2 different representations:
+  Ropes and Symbols (interned strings). The Rope provides a memory efficient
+  data-structure for strings created from concatenation or some other string
+  manipulation like splitting.
+
+  Unfortunately checking equality of different ropes can be quite costly as
+  runtimes must resort to clever string comparison algorithms. These
+  algorithms typically cost in proportion to the length of the string.
+  Luckily, this is where the Symbols (interned strings) shine. As Symbols are
+  unique by their string content, equality checks can be done by pointer
+  comparison.
+
+  How do I know if my string is a rope or symbol?
+
+  Typically (warning general sweeping statement, but truthy in runtimes at
+  present) static strings created as part of the JS source are interned.
+  Strings often used for comparisons can be interned at runtime if some
+  criteria are met.  One of these criteria can be the size of the entire rope.
+  For example, in chrome 38 a rope longer then 12 characters will not
+  intern, nor will segments of that rope.
+
+  Some numbers: http://jsperf.com/eval-vs-keys/8
+
+  Known Trick™
+
+  @private
+  @return {String} interned version of the provided string
+*/
+function intern(str) {
+  let obj = Object.create(null);
+  obj[str] = 1;
+  for (let key in obj) {
+    if (key === str) {
+      return key;
+    }
+  }
+  return str;
+}
+
+export { intern as i };

package/dist/dev/packages/shared-chunks/internal-CAL-jHZt.js

@@ -0,0 +1,140 @@
+import { setOwner } from '../@ember/-internals/owner/index.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
+import '../@ember/debug/index.js';
+import { s as setComponentTemplate } from './template-R_5UMHhb.js';
+import { s as setInternalComponentManager } from './api-BawZUDYD.js';
+import { v as valueForRef, i as isConstRef, c as createConstRef } from './reference-BoPB2LfI.js';
+import { x as untrack } from './cache-B7dqAS38.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+function NOOP() {}
+class InternalComponent {
+  // Override this
+  static toString() {
+    return 'internal component';
+  }
+  constructor(owner, args, caller) {
+    this.owner = owner;
+    this.args = args;
+    this.caller = caller;
+    setOwner(this, owner);
+  }
+
+  /**
+   * The default HTML id attribute. We don't really _need_ one, this is just
+   * added for compatibility as it's hard to tell if people rely on it being
+   * present, and it doens't really hurt.
+   *
+   * However, don't rely on this internally, like passing it to `getElementId`.
+   * This can be (and often is) overriden by passing an `id` attribute on the
+   * invocation, which shadows this default id via `...attributes`.
+   */
+  get id() {
+    return guidFor(this);
+  }
+
+  /**
+   * The default HTML class attribute. Similar to the above, we don't _need_
+   * them, they are just added for compatibility as it's similarly hard to tell
+   * if people rely on it in their CSS etc, and it doens't really hurt.
+   */
+  get class() {
+    return 'ember-view';
+  }
+  validateArguments() {
+    for (let name of Object.keys(this.args.named)) {
+      if (!this.isSupportedArgument(name)) {
+        this.onUnsupportedArgument(name);
+      }
+    }
+  }
+  named(name) {
+    let ref = this.args.named[name];
+    return ref ? valueForRef(ref) : undefined;
+  }
+  positional(index) {
+    let ref = this.args.positional[index];
+    return ref ? valueForRef(ref) : undefined;
+  }
+  listenerFor(name) {
+    let listener = this.named(name);
+    if (listener) {
+      (!(typeof listener === 'function') && assert(`The \`@${name}\` argument to the <${this.constructor}> component must be a function`, typeof listener === 'function'));
+      return listener;
+    } else {
+      return NOOP;
+    }
+  }
+  isSupportedArgument(_name) {
+    return false;
+  }
+  onUnsupportedArgument(_name) {}
+  toString() {
+    return `<${this.constructor}:${guidFor(this)}>`;
+  }
+}
+const OPAQUE_CONSTRUCTOR_MAP = new WeakMap();
+function opaquify(constructor, template) {
+  let _opaque = {
+    // Factory interface
+    create() {
+      throw assert('Use constructor instead of create');
+    },
+    toString() {
+      return constructor.toString();
+    }
+  };
+  let opaque = _opaque;
+  OPAQUE_CONSTRUCTOR_MAP.set(opaque, constructor);
+  setInternalComponentManager(INTERNAL_COMPONENT_MANAGER, opaque);
+  setComponentTemplate(template, opaque);
+  return opaque;
+}
+function deopaquify(opaque) {
+  let constructor = OPAQUE_CONSTRUCTOR_MAP.get(opaque);
+  (!(constructor) && assert(`[BUG] Invalid internal component constructor: ${opaque}`, constructor));
+  return constructor;
+}
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: true,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: true,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: true,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+class InternalManager {
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+  create(owner, definition, args, _env, _dynamicScope, caller) {
+    (!(isConstRef(caller)) && assert('caller must be const', isConstRef(caller)));
+    let ComponentClass = deopaquify(definition);
+    let instance = new ComponentClass(owner, args.capture(), valueForRef(caller));
+    untrack(instance['validateArguments'].bind(instance));
+    return instance;
+  }
+  didCreate() {}
+  didUpdate() {}
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  getDebugName(definition) {
+    return definition.toString();
+  }
+  getSelf(instance) {
+    return createConstRef(instance, 'this');
+  }
+  getDestroyable(instance) {
+    return instance;
+  }
+}
+const INTERNAL_COMPONENT_MANAGER = new InternalManager();
+
+export { InternalComponent as I, opaquify as o };

package/dist/dev/packages/shared-chunks/internal-helper-Ez7zbEIa.js

@@ -0,0 +1,7 @@
+import { j as setInternalHelperManager } from './api-BawZUDYD.js';
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+export { internalHelper as i };