ember-source 6.12.0 → 7.0.0-alpha.1

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/compile-options.js

@@ -1,7 +1,7 @@
 import '../../debug/index.js';
 import { STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS, RESOLUTION_MODE_TRANSFORMS } from './plugins/index.js';
+import { ALLOWED_GLOBALS } from './plugins/allowed-globals.js';
 import COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE from './dasherize-component-name.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../debug/lib/assert.js';
 
 let USER_PLUGINS = [];
@@ -19,7 +19,7 @@ function buildCompileOptions(_options) {
     ..._options,
     moduleName,
     customizeComponentName(tagname) {
-      (isDevelopingApp() && !(!malformedComponentLookup(tagname)) && assert(`You tried to invoke a component named <${tagname} /> in "${moduleName ?? '[NO MODULE]'}", but that is not a valid name for a component. Did you mean to use the "::" syntax for nested components?`, !malformedComponentLookup(tagname)));
+      (!(!malformedComponentLookup(tagname)) && assert(`You tried to invoke a component named <${tagname} /> in "${moduleName ?? '[NO MODULE]'}", but that is not a valid name for a component. Did you mean to use the "::" syntax for nested components?`, !malformedComponentLookup(tagname)));
       return COMPONENT_NAME_SIMPLE_DASHERIZE_CACHE.get(tagname);
     }
   };
@@ -27,6 +27,9 @@ function buildCompileOptions(_options) {
     const localScopeEvaluator = options.eval;
     const globalScopeEvaluator = value => new Function(`return ${value};`)();
     options.lexicalScope = variable => {
+      if (ALLOWED_GLOBALS.has(variable)) {
+        return variable in globalThis;
+      }
       if (inScope(variable, localScopeEvaluator)) {
         return !inScope(variable, globalScopeEvaluator);
       }
@@ -36,7 +39,9 @@ function buildCompileOptions(_options) {
   }
   if ('scope' in options) {
     const scope = options.scope();
-    options.lexicalScope = variable => variable in scope;
+    options.lexicalScope = variable => {
+      return variable in scope;
+    };
     delete options.scope;
   }
   if ('locals' in options && !options.locals) {
@@ -51,7 +56,7 @@ function buildCompileOptions(_options) {
   // move `moduleName` into `meta` property
   if (options.moduleName) {
     let meta = options.meta;
-    (isDevelopingApp() && !(meta) && assert('has meta', meta)); // We just set it
+    (!(meta) && assert('has meta', meta)); // We just set it
     meta.moduleName = options.moduleName;
   }
   if (options.strictMode) {
@@ -71,9 +76,9 @@ function compileOptions(_options = {}) {
     };
   } else {
     let potententialPugins = [...USER_PLUGINS, ...builtInPlugins];
-    (isDevelopingApp() && !(options.plugins) && assert('expected plugins', options.plugins));
+    (!(options.plugins) && assert('expected plugins', options.plugins));
     let pluginsToAdd = potententialPugins.filter(plugin => {
-      (isDevelopingApp() && !(options.plugins) && assert('expected plugins', options.plugins));
+      (!(options.plugins) && assert('expected plugins', options.plugins));
       return options.plugins.ast.indexOf(plugin) === -1;
     });
     options.plugins.ast = [...options.plugins.ast, ...pluginsToAdd];

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/dasherize-component-name.js

@@ -1,5 +1,4 @@
-import '../../../shared-chunks/mandatory-setter-DLKyVs4Q.js';
-import '@embroider/macros';
+import '../../../shared-chunks/mandatory-setter-DHZe7-kW.js';
 import { C as Cache } from '../../../shared-chunks/cache-qDyqAcpg.js';
 
 /*

package/dist/dev/packages/@ember/template-compiler/lib/plugins/allowed-globals.js

@@ -0,0 +1,56 @@
+/**
+ * @private
+ *
+ * RFC: https://github.com/emberjs/rfcs/pull/1070
+ *
+ * Criteria for inclusion in this list:
+ *
+ *   Any of:
+ *     - begins with an uppercase letter
+ *     - guaranteed to never be added to glimmer as a keyword (e.g.: globalThis)
+ *
+ *   And:
+ *     - must not need new to invoke
+ *     - must not require lifetime management (e.g.: setTimeout)
+ *     - must not be a single-word lower-case API, because of potential collision with future new HTML elements
+ *     - if the API is a function, the return value should not be a promise
+ *     - must be one one of these lists:
+ *        - https://tc39.es/ecma262/#sec-global-object
+ *        - https://tc39.es/ecma262/#sec-function-properties-of-the-global-object
+ *        - https://html.spec.whatwg.org/multipage/nav-history-apis.html#window
+ *        - https://html.spec.whatwg.org/multipage/indices.html#all-interfaces
+ *        - https://html.spec.whatwg.org/multipage/webappapis.html
+ */
+const ALLOWED_GLOBALS = new Set([
+// ////////////////
+// namespaces
+// ////////////////
+//   TC39
+'globalThis', 'Atomics', 'JSON', 'Math', 'Reflect',
+//   WHATWG
+'localStorage', 'sessionStorage', 'URL',
+// ////////////////
+// functions / utilities
+// ////////////////
+//   TC39
+'isNaN', 'isFinite', 'parseInt', 'parseFloat', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent',
+//   WHATWG
+'postMessage', 'structuredClone',
+// ////////////////
+// new-less Constructors (still functions)
+// ////////////////
+//   TC39
+'Array',
+// different behavior from (array)
+'BigInt', 'Boolean', 'Date', 'Number', 'Object',
+// different behavior from (hash)
+'String',
+// ////////////////
+// Values
+// ////////////////
+//   TC39
+'Infinity', 'NaN',
+//   WHATWG
+'isSecureContext']);
+
+export { ALLOWED_GLOBALS };

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/assert-against-attrs.js

@@ -1,9 +1,25 @@
 import { deprecate } from '../../../debug/index.js';
 import calculateLocationDisplay from '../system/calculate-location-display.js';
 import { trackLocals } from './utils.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that asserts against
+
+  ```handlebars
+  {{attrs.foo.bar}}
+  ```
+
+  ...as well as `{{#if attrs.foo}}`, `{{deeply (nested attrs.foobar.baz)}}`.
+
+  @private
+  @class AssertAgainstAttrs
+*/
+
 function assertAgainstAttrs(env) {
   let {
     builders: b
@@ -19,14 +35,14 @@ function assertAgainstAttrs(env) {
       ...visitor,
       PathExpression(node) {
         if (isAttrs(node, hasLocal)) {
-          (isDevelopingApp() && true && assert(`Using {{attrs}} to reference named arguments is not supported. {{${node.original}}} should be updated to {{@${node.original.slice(6)}}}. ${calculateLocationDisplay(moduleName, node.loc)}`));
+          (assert(`Using {{attrs}} to reference named arguments is not supported. {{${node.original}}} should be updated to {{@${node.original.slice(6)}}}. ${calculateLocationDisplay(moduleName, node.loc)}`));
         } else if (isThisDotAttrs(node)) {
           // When removing this, ensure `{{this.attrs.foo}}` is left as-is, without triggering
           // any assertions/deprecations. It's perfectly legal to reference `{{this.attrs.foo}}`
           // in the template since it is a real property on the backing class – it will give you
           // a `MutableCell` wrapper object, but maybe that's what you want. And in any case,
           // there is no compelling to special case that property access.
-          (isDevelopingApp() && true && deprecate(`Using {{this.attrs}} to reference named arguments has been deprecated. {{${node.original}}} should be updated to {{@${node.original.slice(11)}}}. ${calculateLocationDisplay(moduleName, node.loc)}`, false, {
+          (deprecate(`Using {{this.attrs}} to reference named arguments has been deprecated. {{${node.original}}} should be updated to {{@${node.original.slice(11)}}}. ${calculateLocationDisplay(moduleName, node.loc)}`, false, {
             id: 'attrs-arg-access',
             url: 'https://deprecations.emberjs.com/v3.x/#toc_attrs-arg-access',
             until: '6.0.0',

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/assert-against-named-outlets.js

@@ -1,9 +1,18 @@
 import '../../../debug/index.js';
 import calculateLocationDisplay from '../system/calculate-location-display.js';
 import { trackLocals } from './utils.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 
+/**
+ @module ember
+*/
+
+/**
+  Prevents usage of named outlets, a legacy concept in Ember removed in 4.0.
+
+  @private
+  @class AssertAgainstNamedOutlets
+*/
 function assertAgainstNamedOutlets(env) {
   let moduleName = env.meta?.moduleName;
   let {
@@ -17,7 +26,7 @@ function assertAgainstNamedOutlets(env) {
       MustacheStatement(node) {
         if (node.path.type === 'PathExpression' && node.path.original === 'outlet' && node.params[0] && !hasLocal('outlet')) {
           let sourceInformation = calculateLocationDisplay(moduleName, node.loc);
-          (isDevelopingApp() && true && assert(`Named outlets were removed in Ember 4.0. See https://deprecations.emberjs.com/v3.x#toc_route-render-template for guidance on alternative APIs for named outlet use cases. ${sourceInformation}`));
+          (assert(`Named outlets were removed in Ember 4.0. See https://deprecations.emberjs.com/v3.x#toc_route-render-template for guidance on alternative APIs for named outlet use cases. ${sourceInformation}`));
         }
       }
     }

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.js

@@ -1,7 +1,6 @@
 import '../../../debug/index.js';
 import calculateLocationDisplay from '../system/calculate-location-display.js';
 import { isPath, trackLocals } from './utils.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 
 function errorOnInputWithContent(env) {
@@ -17,7 +16,7 @@ function errorOnInputWithContent(env) {
       BlockStatement(node) {
         if (hasLocal('input')) return;
         if (isPath(node.path) && node.path.original === 'input') {
-          (isDevelopingApp() && true && assert(assertMessage(moduleName, node)));
+          (assert(assertMessage(moduleName, node)));
         }
       }
     }

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.js

@@ -1,6 +1,5 @@
 import '../../../debug/index.js';
 import calculateLocationDisplay from '../system/calculate-location-display.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 
 function assertReservedNamedArguments(env) {
@@ -18,7 +17,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (name === '@__ARGS__') {
-          (isDevelopingApp() && true && assert(`${assertMessage(name)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (assert(`${assertMessage(name)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       },
       HashPair({
@@ -26,7 +25,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (key === '__ARGS__') {
-          (isDevelopingApp() && true && assert(`${assertMessage(key)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (assert(`${assertMessage(key)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       },
       PathExpression({
@@ -34,7 +33,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (isReserved(original)) {
-          (isDevelopingApp() && true && assert(`${assertMessage(original)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (assert(`${assertMessage(original)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       }
     }

package/dist/dev/packages/@ember/template-compiler/lib/plugins/index.js

@@ -0,0 +1,40 @@
+import assertAgainstAttrs from './assert-against-attrs.js';
+import assertAgainstNamedOutlets from './assert-against-named-outlets.js';
+import errorOnInputWithContent from './assert-input-helper-without-block.js';
+import assertReservedNamedArguments from './assert-reserved-named-arguments.js';
+import transformActionSyntax from './transform-action-syntax.js';
+import transformEachInIntoEach from './transform-each-in-into-each.js';
+import transformEachTrackArray from './transform-each-track-array.js';
+import transformInElement from './transform-in-element.js';
+import transformQuotedBindingsIntoJustBindings from './transform-quoted-bindings-into-just-bindings.js';
+import { a1 as transformResolutions } from '../../../../shared-chunks/transform-resolutions-fXGQKGsL.js';
+import transformWrapMountAndOutlet from './transform-wrap-mount-and-outlet.js';
+
+const INTERNAL_PLUGINS = {
+  AssertAgainstAttrs: assertAgainstAttrs,
+  AssertAgainstNamedOutlets: assertAgainstNamedOutlets,
+  AssertInputHelperWithoutBlock: errorOnInputWithContent,
+  AssertReservedNamedArguments: assertReservedNamedArguments,
+  TransformActionSyntax: transformActionSyntax,
+  TransformEachInIntoEach: transformEachInIntoEach,
+  TransformEachTrackArray: transformEachTrackArray,
+  TransformInElement: transformInElement,
+  TransformQuotedBindingsIntoJustBindings: transformQuotedBindingsIntoJustBindings,
+  TransformResolutions: transformResolutions,
+  TransformWrapMountAndOutlet: transformWrapMountAndOutlet
+};
+
+// order of plugins is important
+const RESOLUTION_MODE_TRANSFORMS = Object.freeze([transformQuotedBindingsIntoJustBindings, assertReservedNamedArguments, transformActionSyntax, assertAgainstAttrs, transformEachInIntoEach, errorOnInputWithContent, transformInElement, transformEachTrackArray, assertAgainstNamedOutlets, transformWrapMountAndOutlet, transformResolutions]);
+const STRICT_MODE_TRANSFORMS = Object.freeze([transformQuotedBindingsIntoJustBindings, assertReservedNamedArguments, transformActionSyntax, transformEachInIntoEach, transformInElement, transformEachTrackArray, assertAgainstNamedOutlets, transformWrapMountAndOutlet]);
+const STRICT_MODE_KEYWORDS = Object.freeze(['action', 'mut', 'readonly', 'unbound',
+// TransformEachInIntoEach
+'-each-in',
+// TransformInElement
+'-in-el-null',
+// TransformEachTrackArray
+'-track-array',
+// TransformWrapMountAndOutlet
+'-mount', '-outlet']);
+
+export { INTERNAL_PLUGINS, RESOLUTION_MODE_TRANSFORMS, STRICT_MODE_KEYWORDS, STRICT_MODE_TRANSFORMS };

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/transform-each-track-array.js

@@ -1,8 +1,27 @@
 import '../../../debug/index.js';
 import { isPath, trackLocals } from './utils.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that replaces all instances of
+
+  ```handlebars
+  {{#each iterableThing as |key value|}}
+  ```
+
+  with
+
+  ```handlebars
+  {{#each (-track-array iterableThing) as |key value|}}
+  ```
+
+  @private
+  @class TransformHasBlockSyntax
+*/
 function transformEachTrackArray(env) {
   let {
     builders: b
@@ -18,7 +37,7 @@ function transformEachTrackArray(env) {
       BlockStatement(node) {
         if (isPath(node.path) && node.path.original === 'each' && !hasLocal('each')) {
           let firstParam = node.params[0];
-          (isDevelopingApp() && !(firstParam) && assert('has firstParam', firstParam));
+          (!(firstParam) && assert('has firstParam', firstParam));
           if (firstParam.type === 'SubExpression' && firstParam.path.type === 'PathExpression' && firstParam.path.original === '-each-in') {
             return;
           }

package/dist/dev/packages/@ember/template-compiler/lib/plugins/transform-in-element.js

@@ -0,0 +1,50 @@
+import '../../../debug/index.js';
+import { isPath } from './utils.js';
+import { assert } from '../../../debug/lib/assert.js';
+
+/**
+ @module ember
+*/
+
+/**
+  A Glimmer2 AST transformation that handles the public `{{in-element}}` as per RFC287.
+
+  Issues a build time assertion for:
+
+  ```handlebars
+  {{#in-element someElement insertBefore="some-none-null-value"}}
+    {{modal-display text=text}}
+  {{/in-element}}
+  ```
+
+  @private
+  @class TransformInElement
+*/
+function transformInElement(env) {
+  let {
+    builders: b
+  } = env.syntax;
+  return {
+    name: 'transform-in-element',
+    visitor: {
+      BlockStatement(node) {
+        if (!isPath(node.path)) return;
+        if (node.path.original === 'in-element') {
+          let originalValue = node.params[0];
+          if (originalValue && !env.isProduction) {
+            let subExpr = b.sexpr('-in-el-null', [originalValue]);
+            node.params.shift();
+            node.params.unshift(subExpr);
+          }
+          node.hash.pairs.forEach(pair => {
+            if (pair.key === 'insertBefore') {
+              (!(pair.value.type === 'NullLiteral' || pair.value.type === 'UndefinedLiteral') && assert(`Can only pass null to insertBefore in in-element, received: ${JSON.stringify(pair.value)}`, pair.value.type === 'NullLiteral' || pair.value.type === 'UndefinedLiteral'));
+            }
+          });
+        }
+      }
+    }
+  };
+}
+
+export { transformInElement as default };

package/dist/{packages → dev/packages}/@ember/template-compiler/lib/plugins/transform-resolutions.js

@@ -1,7 +1,6 @@
 import '../../../debug/index.js';
-export { t as default } from '../../../../shared-chunks/transform-resolutions-vHYYonpB.js';
-import '../../../../shared-chunks/debug-to-string-BsFOvUtQ.js';
-import '@embroider/macros';
+export { a1 as default } from '../../../../shared-chunks/transform-resolutions-fXGQKGsL.js';
+import '../../../../shared-chunks/debug-to-string-CFb7h0lY.js';
 import '../../../../@glimmer/wire-format/index.js';
 import '../system/calculate-location-display.js';
 import './utils.js';

package/dist/dev/packages/@ember/template-compiler/lib/template.js

@@ -0,0 +1,248 @@
+import './plugins/allowed-globals.js';
+import templateOnly from '../../component/template-only.js';
+import '../../../shared-chunks/fragment-Cc5k9Oy4.js';
+import '../../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../../@glimmer/wire-format/index.js';
+import { p as precompile } from '../../../shared-chunks/compiler-CNj62pww.js';
+import '../../../@glimmer/global-context/index.js';
+import '../../../@glimmer/destroyable/index.js';
+import '../../../@glimmer/validator/index.js';
+import '../../../shared-chunks/reference-C3TKDRnP.js';
+import '../../../shared-chunks/capabilities-O_xc7Yqk.js';
+import { s as setComponentTemplate } from '../../../shared-chunks/template-kM-7TTcc.js';
+import { t as templateFactory } from '../../../shared-chunks/index-Q7JnrdBn.js';
+import compileOptions from './compile-options.js';
+
+/**
+ * All possible options passed to `template()` may specify a `moduleName`.
+ */
+
+/**
+ * When using `template` in a class, you call it in a `static` block and pass
+ * the class as the `component` option.
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       // explicit or implicit option goes here
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * For the full explicit form, see {@linkcode ExplicitClassOptions}. For the
+ * full implicit form, see {@linkcode ImplicitClassOptions}.
+ */
+
+/**
+ * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+ * a `scope` option that explicitly provides the lexical scope for the template.
+ *
+ * This is called the "explicit form".
+ *
+ * ```ts
+ * const greeting = 'Hello';
+ * const HelloWorld = template('{{greeting}} World!', { scope: () => ({ greeting }) });
+ * ```
+ */
+
+/**
+ * When using `template` *inside* a class (see
+ * {@linkcode BaseClassTemplateOptions}), you can pass a `scope` option that
+ * explicitly provides the lexical scope for the template, just like a template-only
+ * component (see {@linkcode ExplicitTemplateOnlyOptions}).
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       // explicit or implicit option goes here
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * ## The Scope Function's `instance` Parameter
+ *
+ * However, the explicit `scope` function in a *class* also takes an `instance` option
+ * that provides access to the component's instance.
+ *
+ * Once it's supported in Handlebars, this will make it possible to represent private
+ * fields when using the explicit form.
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.#greeting}}, {{@place}}!',
+ *       { component: this },
+ *       scope: (instance) => ({ '#greeting': instance.#greeting }),
+ *     );
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * The *implicit* form of the `template` function takes an `eval` option that
+ * allows the runtime compiler to evaluate local template variables without
+ * needing to maintain an explicit list of the local variables used in the
+ * template scope.
+ *
+ * The eval options *must* be passed in the following form:
+ *
+ * ```ts
+ * {
+ *   eval() { return eval(arguments[0]) }
+ * }
+ * ```
+ *
+ * ## Requirements of the `eval` Option
+ *
+ * **The syntactic form presented above is the only form you should use when
+ * passing an `eval` option.**
+ *
+ * This is _required_ if you want your code to be compatible with the
+ * compile-time implementation of `@ember/template-compiler`. While the runtime
+ * compiler offers a tiny bit of additional wiggle room, you still need to follow
+ * very strict rules.
+ *
+ * We don't recommend trying to memorize the rules. Instead, we recommend using
+ * the snippet presented above and supported by the compile-time implementation.
+ *
+ * ### The Technical Requirements of the `eval` Option
+ *
+ * The `eval` function is passed a single parameter that is a JavaScript
+ * identifier. This will be extended in the future to support private fields.
+ *
+ * Since keywords in JavaScript are contextual (e.g. `await` and `yield`), the
+ * parameter might be a keyword. The `@ember/template-compiler/runtime` expects
+ * the function to throw a `SyntaxError` if the identifier name is not valid in
+ * the current scope. (The direct `eval` function takes care of this out of the
+ * box.)
+ *
+ * Requirements:
+ *
+ * 1. The `eval` method must receive its parameter as `arguments[0]`, which
+ *    ensures that the variable name passed to `eval()` is not shadowed by the
+ *    function's parameter name.
+ * 2. The `eval` option must be a function or concise method, and not an arrow.
+ *    This is because arrows do not have their own `arguments`, which breaks
+ *    (1).
+ * 3. The `eval` method must call "*direct* `eval`", and not an alias of `eval`.
+ *    Direct `eval` evaluates the code in the scope it was called from, while
+ *    aliased versions of `eval` (including `new Function`) evaluate the code in
+ *    the global scope.
+ * 4. The `eval` method must return the result of calling "direct `eval`".
+ *
+ * The easiest way to achieve these requirements is to use the exact syntax
+ * presented above. This is *also* the only way to be compatible
+ *
+ * ## Rationale
+ *
+ * This is useful for two reasons:
+ *
+ * 1. This form is a useful _intermediate_ form for the compile-time toolchain.
+ *    It allows the content-tag preprocessor to convert the `<template>` syntax
+ *    into valid JavaScript without needing to involve full-fledged lexical
+ *    analysis.
+ * 2. This form is a convenient form for manual prototyping when using the
+ *    runtime compiler directly. While it requires some extra typing relative to
+ *    `<template>`, it's a mechanical 1:1 transformation of the syntax.
+ *
+ * In practice, implementations that use a runtime compiler (for example, a
+ * playground running completely in the browser) should probably use the
+ * `content-tag` preprocessor to convert the template into the implicit form,
+ * and then rely on `@ember/template-compiler/runtime` to evaluate the template.
+ */
+
+/**
+ * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+ * an `eval` option that _implicitly_ provides the lexical scope for the template.
+ *
+ * This is called the "implicit form".
+ *
+ * ```ts
+ * const greeting = 'Hello';
+ * const HelloWorld = template('{{greeting}} World!', {
+ *   eval() { return arguments[0] }
+ * });
+ * ```
+ *
+ * For more details on the requirements of the `eval` option, see {@linkcode ImplicitEvalOption}.
+ */
+
+/**
+ * When using `template` inside of a class, you can pass an `eval` option that
+ * _implicitly_ provides the lexical scope for the template, just as you can
+ * with a {@linkcode ImplicitTemplateOnlyOptions | template-only component}.
+ *
+ * This is called the "implicit form".
+ *
+ * ```ts
+ * class MyComponent extends Component {
+ *   static {
+ *     template('{{this.greeting}}, {{@place}}!',
+ *       { component: this },
+ *       eval() { return arguments[0] }
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * ## Note  on Private Fields
+ *
+ * The current implementation of `@ember/template-compiler` does not support
+ * private fields, but once the Handlebars parser adds support for private field
+ * syntax and it's implemented in the Glimmer compiler, the implicit form should
+ * be able to support them.
+ */
+
+function template(templateString, providedOptions) {
+  const options = {
+    strictMode: true,
+    ...providedOptions
+  };
+  const evaluate = buildEvaluator(options);
+  const normalizedOptions = compileOptions(options);
+  const component = normalizedOptions.component ?? templateOnly();
+  const source = precompile(templateString, normalizedOptions);
+  const template = templateFactory(evaluate(`(${source})`));
+  setComponentTemplate(template, component);
+  return component;
+}
+const evaluator = source => {
+  return new Function(`return  ${source}`)();
+};
+function buildEvaluator(options) {
+  if (options === undefined) {
+    return evaluator;
+  }
+  if (options.eval) {
+    return options.eval;
+  } else {
+    const scope = options.scope?.();
+    if (!scope) {
+      return evaluator;
+    }
+    return source => {
+      let hasThis = Object.prototype.hasOwnProperty.call(scope, 'this');
+      let thisValue = hasThis ? scope.this : undefined;
+      let argNames = [];
+      let argValues = [];
+      for (let [name, value] of Object.entries(scope)) {
+        if (name === 'this') {
+          continue;
+        }
+        argNames.push(name);
+        argValues.push(value);
+      }
+      let fn = new Function(...argNames, `return (${source})`);
+      return hasThis ? fn.call(thisValue, ...argValues) : fn(...argValues);
+    };
+  }
+}
+
+export { template };

package/dist/dev/packages/@ember/template-factory/index.js

@@ -0,0 +1,8 @@
+import '../../shared-chunks/fragment-Cc5k9Oy4.js';
+import '../../shared-chunks/debug-to-string-CFb7h0lY.js';
+import '../../@glimmer/global-context/index.js';
+import '../../@glimmer/validator/index.js';
+import '../../shared-chunks/reference-C3TKDRnP.js';
+export { t as createTemplateFactory } from '../../shared-chunks/index-Q7JnrdBn.js';
+import '../../@glimmer/destroyable/index.js';
+import '../../shared-chunks/capabilities-O_xc7Yqk.js';

package/dist/dev/packages/@ember/test/index.js

@@ -0,0 +1,18 @@
+let registerWaiter;
+let unregisterWaiter;
+let _impl;
+let testingNotAvailableMessage = () => {
+  throw new Error('Attempted to use test utilities, but `ember-testing` was not included');
+};
+registerWaiter = testingNotAvailableMessage;
+unregisterWaiter = testingNotAvailableMessage;
+function registerTestImplementation(impl) {
+  let {
+    Test
+  } = impl;
+  registerWaiter = Test.registerWaiter;
+  unregisterWaiter = Test.unregisterWaiter;
+  _impl = impl;
+}
+
+export { _impl, registerTestImplementation, registerWaiter, unregisterWaiter };