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

package/dist/prod/packages/shared-chunks/helper-Da672z4a.js

@@ -0,0 +1,299 @@
+import { setOwner } from '../@ember/-internals/owner/index.js';
+import { FrameworkObject } from '../@ember/object/-internals.js';
+import { g as getDebugName } from './get-debug-name-BDxIL2Y1.js';
+import './env-DXxsTFkM.js';
+import { join } from '../@ember/runloop/index.js';
+import { a as getInternalHelperManager, i as helperCapabilities } from './api-zh_k31vb.js';
+import { b as setHelperManager } from './api-CM1trl_4.js';
+import { p as createTag, D as DIRTY_TAG, a as consumeTag } from './cache-BIlOoPA7.js';
+
+/**
+@module @ember/component
+*/
+
+const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
+
+// Signature type utilities
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+// Implements Ember's `Factory` interface and tags it for narrowing/checking.
+
+const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
+
+// A zero-runtime-overhead private symbol to use in branding the component to
+// preserve its type parameter.
+
+/**
+  Ember Helpers are functions that can compute values, and are used in templates.
+  For example, this code calls a helper named `format-currency`:
+
+  ```app/templates/application.hbs
+  <Cost @cents={{230}} />
+  ```
+
+  ```app/components/cost.hbs
+  <div>{{format-currency @cents currency="$"}}</div>
+  ```
+
+  Additionally a helper can be called as a nested helper.
+  In this example, we show the formatted currency value if the `showMoney`
+  named argument is truthy.
+
+  ```handlebars
+  {{if @showMoney (format-currency @cents currency="$")}}
+  ```
+
+  Helpers defined using a class must provide a `compute` function. For example:
+
+  ```app/helpers/format-currency.js
+  import Helper from '@ember/component/helper';
+
+  export default class extends Helper {
+    compute([cents], { currency }) {
+      return `${currency}${cents * 0.01}`;
+    }
+  }
+  ```
+
+  Each time the input to a helper changes, the `compute` function will be
+  called again.
+
+  As instances, these helpers also have access to the container and will accept
+  injected dependencies.
+
+  Additionally, class helpers can call `recompute` to force a new computation.
+
+  @class Helper
+  @extends CoreObject
+  @public
+  @since 1.13.0
+*/
+// ESLint doesn't understand declaration merging.
+/* eslint-disable import/export */
+
+class Helper extends FrameworkObject {
+  static isHelperFactory = true;
+  static [IS_CLASSIC_HELPER] = true;
+
+  // `packages/ember/index.js` was setting `Helper.helper`. This seems like
+  // a bad idea and probably not something we want. We've moved that definition
+  // here, but it should definitely be reviewed and probably removed.
+  /** @deprecated */
+  static helper = helper;
+
+  // SAFETY: this is initialized in `init`, rather than `constructor`. It is
+  // safe to `declare` like this *if and only if* nothing uses the constructor
+  // directly in this class, since nothing else can run before `init`.
+
+  // SAFETY: this has no runtime existence whatsoever; it is a "phantom type"
+  // here to preserve the type param.
+
+  init(properties) {
+    super.init(properties);
+    this[RECOMPUTE_TAG] = createTag();
+  }
+
+  /**
+    On a class-based helper, it may be useful to force a recomputation of that
+    helpers value. This is akin to `rerender` on a component.
+     In most cases, `recompute` is not needed because accessing tracked
+    properties in `compute` will automatically re-run the helper when
+    those properties change. Use `recompute` only when you need to
+    trigger a recomputation imperatively, for example in response to an
+    external event:
+     ```app/helpers/current-time.js
+    import Helper from '@ember/component/helper';
+     export default class CurrentTimeHelper extends Helper {
+      interval = null;
+       compute() {
+        return new Date().toLocaleTimeString();
+      }
+       constructor() {
+        super(...arguments);
+        this.interval = setInterval(() => this.recompute(), 1000);
+      }
+       willDestroy() {
+        super.willDestroy();
+        clearInterval(this.interval);
+      }
+    }
+    ```
+     @method recompute
+    @public
+    @since 1.13.0
+  */
+  recompute() {
+    join(() => DIRTY_TAG(this[RECOMPUTE_TAG]));
+  }
+}
+/* eslint-enable import/export */
+
+function isClassicHelper(obj) {
+  return obj[IS_CLASSIC_HELPER] === true;
+}
+class ClassicHelperManager {
+  capabilities = helperCapabilities('3.23', {
+    hasValue: true,
+    hasDestroyable: true
+  });
+  ownerInjection;
+  constructor(owner) {
+    let ownerInjection = {};
+    setOwner(ownerInjection, owner);
+    this.ownerInjection = ownerInjection;
+  }
+  createHelper(definition, args) {
+    let instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
+    return {
+      instance,
+      args
+    };
+  }
+  getDestroyable({
+    instance
+  }) {
+    return instance;
+  }
+  getValue({
+    instance,
+    args
+  }) {
+    let {
+      positional,
+      named
+    } = args;
+    let ret = instance.compute(positional, named);
+    consumeTag(instance[RECOMPUTE_TAG]);
+    return ret;
+  }
+  getDebugName(definition) {
+    return getDebugName((definition.class || definition)['prototype']);
+  }
+}
+function isFactoryManager(obj) {
+  return obj != null && 'class' in obj;
+}
+setHelperManager(owner => {
+  return new ClassicHelperManager(owner);
+}, Helper);
+const CLASSIC_HELPER_MANAGER = getInternalHelperManager(Helper);
+
+///////////
+
+class Wrapper {
+  isHelperFactory = true;
+  constructor(compute) {
+    this.compute = compute;
+  }
+  create() {
+    // needs new instance or will leak containers
+    return {
+      compute: this.compute
+    };
+  }
+}
+class SimpleClassicHelperManager {
+  capabilities = helperCapabilities('3.23', {
+    hasValue: true
+  });
+  createHelper(definition, args) {
+    return () => definition.compute.call(null, args.positional, args.named);
+  }
+  getValue(fn) {
+    return fn();
+  }
+  getDebugName(definition) {
+    return getDebugName(definition.compute);
+  }
+}
+const SIMPLE_CLASSIC_HELPER_MANAGER = new SimpleClassicHelperManager();
+setHelperManager(() => SIMPLE_CLASSIC_HELPER_MANAGER, Wrapper.prototype);
+
+/*
+  Function-based helpers need to present with a constructor signature so that
+  type parameters can be preserved when `helper()` is passed a generic function
+  (this is particularly key for checking helper invocations with Glint).
+  Accordingly, we define an abstract class and declaration merge it with the
+  interface; this inherently provides an `abstract` constructor. Since it is
+  `abstract`, it is not callable, which is important since end users should not
+  be able to do `let myHelper = helper(someFn); new myHelper()`.
+ */
+
+/**
+ * The type of a function-based helper.
+ *
+ * @note This is *not* user-constructible: it is exported only so that the type
+ *   returned by the `helper` function can be named (and indeed can be exported
+ *   like `export default helper(...)` safely).
+ */
+// Making `FunctionBasedHelper` an alias this way allows callers to name it in
+// terms meaningful to *them*, while preserving the type behavior described on
+// the `abstract class FunctionBasedHelperInstance` below.
+
+// This abstract class -- specifically, its `protected abstract __concrete__`
+// member -- prevents subclasses from doing `class X extends helper(..)`, since
+// that is an error at runtime. While it is rare that people would type that, it
+// is not impossible and we use this to give them early signal via the types for
+// a behavior which will break (and in a somewhat inscrutable way!) at runtime.
+//
+// This is needful because we lie about what this actually is for Glint's sake:
+// a function-based helper returns a `Factory<SimpleHelper>`, which is designed
+// to be "opaque" from a consumer's POV, i.e. not user-callable or constructible
+// but only useable in a template (or via `invokeHelper()` which also treats it
+// as a fully opaque `object` from a type POV). But Glint needs a `Helper<S>` to
+// make it work the same way as class-based helpers. (Note that this does not
+// hold for plain functions as helpers, which it can handle distinctly.) This
+// signature thus makes it so that the item is usable *as* a `Helper` in Glint,
+// but without letting end users treat it as a helper class instance.
+
+/**
+  In many cases it is not necessary to use the full `Helper` class.
+  The `helper` method create pure-function helpers without instances.
+  For example:
+
+  ```app/helpers/format-currency.js
+  import { helper } from '@ember/component/helper';
+
+  export default helper(function([cents], {currency}) {
+    return `${currency}${cents * 0.01}`;
+  });
+  ```
+
+  @static
+  @param {Function} helper The helper function
+  @method helper
+  @for @ember/component/helper
+  @public
+  @since 1.13.0
+*/
+// This overload allows users to write types directly on the callback passed to
+// the `helper` function and infer the resulting type correctly.
+
+// This overload allows users to provide a `Signature` type explicitly at the
+// helper definition site, e.g. `helper<Sig>((pos, named) => {...})`. **Note:**
+// this overload must appear second, since TS' inference engine will not
+// correctly infer the type of `S` here from the types on the supplied callback.
+
+function helper(helperFn) {
+  // SAFETY: this is completely lies, in two ways:
+  //
+  // 1. `Wrapper` is a `Factory<SimpleHelper<S>>`, but from the perspective of
+  //    any external callers (i.e. Ember *users*), it is quite important that
+  //    the `Factory` relationship be hidden, because it is not public API for
+  //    an end user to call `.create()` on a helper created this way. Instead,
+  //    we provide them an `abstract new` signature (which means it cannot be
+  //    directly constructed by calling `new` on it) and which does not have the
+  //    `.create()` signature on it anymore.
+  //
+  // 2. The produced type here ends up being a subtype of `Helper`, which is not
+  //    strictly true. This is necessary for the sake of Glint, which provides
+  //    its information by way of a "declaration merge" with `Helper<S>` in the
+  //    case of items produced by `helper()`.
+  //
+  // Long-term, this entire construct can go away in favor of deprecating the
+  // `helper()` invocation in favor of using plain functions.
+  return new Wrapper(helperFn);
+}
+
+export { CLASSIC_HELPER_MANAGER as C, Helper as H, helper as h, isClassicHelper as i };

package/dist/prod/packages/shared-chunks/{index-CjaDF9kC.js → index--2U-v2nf.js}

@@ -1,15 +1,16 @@
-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-D7nBU9ae.js';
-import '../@glimmer/validator/index.js';
-import './reference-BNqcwZWH.js';
-import { e as expect, u as unwrap, S as StackImpl, a as isPresentArray, d as dict } from './collections-GpG8lT2g.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 { h as hasCapability } from './capabilities-DXA-L0iT.js';
-import { 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 { s as VM_PRIMITIVE_OP, aG as VM_RETURN_OP, aM as encodeHandle, aN as isMachineOp, aw as VM_CONCAT_OP, an as VM_GET_VARIABLE_OP, r as VM_CONSTANT_REFERENCE_OP, ar as VM_GET_PROPERTY_OP, au as VM_HAS_BLOCK_OP, at as VM_SPREAD_BLOCK_OP, F as VM_COMPILE_BLOCK_OP, av as VM_HAS_BLOCK_PARAMS_OP, ax as VM_IF_INLINE_OP, ay as VM_NOT_OP, az as VM_GET_DYNAMIC_VAR_OP, aK as VM_PUSH_FRAME_OP, aA as VM_LOG_OP, aJ as VM_POP_FRAME_OP, z as VM_FETCH_OP, v as VM_PRIMITIVE_REFERENCE_OP, am as VM_HELPER_OP, w as VM_DUP_OP, al as VM_DYNAMIC_HELPER_OP, x as VM_POP_OP, a0 as VM_CAPTURE_ARGS_OP, ak as VM_CURRY_OP, aO as isSmallInt, aP as encodeImmediate, n as VM_PUSH_DYNAMIC_SCOPE_OP, A as VM_BIND_DYNAMIC_SCOPE_OP, o as VM_POP_DYNAMIC_SCOPE_OP, as as VM_GET_BLOCK_OP, G as VM_INVOKE_YIELD_OP, m as VM_POP_SCOPE_OP, l as VM_CHILD_SCOPE_OP, ao as VM_SET_VARIABLE_OP, aI as VM_INVOKE_VIRTUAL_OP, p as VM_CONSTANT_OP, E as VM_PUSH_BLOCK_SCOPE_OP, D as VM_PUSH_SYMBOL_TABLE_OP, $ as VM_PUSH_EMPTY_ARGS_OP, _ as VM_PUSH_ARGS_OP, B as VM_ENTER_OP, J as VM_JUMP_EQ_OP, aH as VM_JUMP_OP, C as VM_EXIT_OP, aF as VM_RETURN_TO_OP, I as VM_JUMP_UNLESS_OP, Y as VM_PUSH_COMPONENT_DEFINITION_OP, y as VM_LOAD_OP, a4 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a2 as VM_CREATE_COMPONENT_OP, a3 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a9 as VM_GET_COMPONENT_SELF_OP, aq as VM_ROOT_SCOPE_OP, ap as VM_SET_BLOCK_OP, ah as VM_DID_RENDER_LAYOUT_OP, ai as VM_COMMIT_COMPONENT_TRANSACTION_OP, a1 as VM_PREPARE_ARGS_OP, ad as VM_VIRTUAL_ROOT_SCOPE_OP, ae as VM_SET_NAMED_VARIABLES_OP, af as VM_SET_BLOCKS_OP, ag as VM_INVOKE_COMPONENT_LAYOUT_OP, a5 as VM_PUT_COMPONENT_OPERATIONS_OP, O as VM_OPEN_DYNAMIC_ELEMENT_OP, a8 as VM_DID_CREATE_ELEMENT_OP, R as VM_FLUSH_ELEMENT_OP, S as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Z as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ab as VM_GET_COMPONENT_LAYOUT_OP, ac as VM_POPULATE_LAYOUT_OP, aa as VM_GET_COMPONENT_TAG_NAME_OP, M as VM_COMMENT_OP, T as VM_MODIFIER_OP, U as VM_DYNAMIC_MODIFIER_OP, W as VM_STATIC_ATTR_OP, a7 as VM_STATIC_COMPONENT_ATTR_OP, X as VM_DYNAMIC_ATTR_OP, a6 as VM_COMPONENT_ATTR_OP, N as VM_OPEN_ELEMENT_OP, aj as VM_DEBUGGER_OP, L as VM_TEXT_OP, j as VM_INVOKE_STATIC_OP, aB as VM_DYNAMIC_CONTENT_TYPE_OP, P as VM_PUSH_REMOTE_ELEMENT_OP, Q as VM_POP_REMOTE_ELEMENT_OP, K as VM_TO_BOOLEAN_OP, aC as VM_ENTER_LIST_OP, aE as VM_ITERATE_OP, aD as VM_EXIT_LIST_OP } from './opcode-metadata-9iSW5JGP.js';
+import './curried-BVwSNqpf.js';
+import './reference-BshxG6wn.js';
+import { e as expect, u as unwrap, S as StackImpl, a as isPresentArray, d as dict } from './collections-C3Y8z_9v.js';
+import { a as assert } from './assert-CUCJBR2C.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
+import { A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { o as opcodes } from './opcodes-CplRyHl_.js';
+import { a as $v0, f as $fp, $ as $s0, e as $sp, d as $s1 } from './registers-DoamZwaG.js';
+import { ContentType } from '../@glimmer/vm/index.js';
+import { h as hasCapability } from './capabilities-_5e35539.js';
 
 function isGetLikeTuple(opcode) {
   return Array.isArray(opcode) && opcode.length === 2;
@@ -35,6 +36,7 @@ function assertResolverInvariants(meta) {
  * <Foo @arg={{true}} />
  */
 function resolveComponent(resolver, constants, meta, [, expr, then]) {
+  assert(isGetFreeComponent(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -66,6 +68,7 @@ function resolveComponent(resolver, constants, meta, [, expr, then]) {
  * (helper arg)
  */
 function resolveHelper(resolver, constants, meta, [, expr, then]) {
+  assert(isGetFreeHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -96,6 +99,7 @@ function resolveHelper(resolver, constants, meta, [, expr, then]) {
  * <Foo {{modifier}}/>
  */
 function resolveModifier(resolver, constants, meta, [, expr, then]) {
+  assert(isGetFreeModifier(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -139,6 +143,7 @@ function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
   ifComponent,
   ifHelper
 }]) {
+  assert(isGetFreeComponentOrHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -186,6 +191,7 @@ function resolveOptionalComponentOrHelper(resolver, constants, meta, [, expr, {
   ifHelper,
   ifValue
 }]) {
+  assert(isGetFreeComponentOrHelper(expr));
   let type = expr[0];
   if (type === opcodes.GetLexicalSymbol) {
     let {
@@ -347,6 +353,7 @@ class Labels {
     } of targets) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       let address = labels[target] - at;
+      assert(heap.getbyaddr(at) === -1);
       heap.setbyaddr(at, address);
     }
   }
@@ -507,6 +514,7 @@ class Compilers {
     let name = sexp[0];
     let index = unwrap(this.names[name]);
     let func = this.funcs[index];
+    assert(func, `expected an implementation for ${sexp[0]}`);
     func(op, sexp);
   }
 }

package/dist/prod/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 };