ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/{packages/shared-chunks/api-CkUl6KyJ.js → dev/packages/shared-chunks/api-BqXkkT0p.js}

@@ -1,18 +1,17 @@
-import { d as debugToString } from './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
 import { debugAssert } from '../@glimmer/global-context/index.js';
 import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
 import '../@glimmer/validator/index.js';
-import { b as createComputeRef, d as createConstRef, U as UNDEFINED_REFERENCE } from './reference-B6HMX4y0.js';
-import { a as argsProxyFor } from './args-proxy-B91L3LRK.js';
-import { F as FROM_CAPABILITIES, b as buildCapabilities } from './capabilities-DHiXCCuB.js';
+import { c as createComputeRef, a as createConstRef, U as UNDEFINED_REFERENCE } from './reference-C3TKDRnP.js';
+import { a as argsProxyFor } from './args-proxy-DgXMc9b5.js';
+import { F as FROM_CAPABILITIES, b as buildCapabilities } from './capabilities-O_xc7Yqk.js';
 
 function helperCapabilities(managerAPI, options = {}) {
   debugAssert(managerAPI === '3.23', () => `Invalid helper manager compatibility specified; you specified ${managerAPI}, but only '3.23' is supported.`);
-  if (isDevelopingApp() && (!(options.hasValue || options.hasScheduledEffect) || options.hasValue && options.hasScheduledEffect)) {
+  if ((!(options.hasValue || options.hasScheduledEffect) || options.hasValue && options.hasScheduledEffect)) {
     throw new Error('You must pass either the `hasValue` OR the `hasScheduledEffect` capability when defining a helper manager. Passing neither, or both, is not permitted.');
   }
-  if (isDevelopingApp() && options.hasScheduledEffect) {
+  if (options.hasScheduledEffect) {
     throw new Error('The `hasScheduledEffect` capability has not yet been implemented for helper managers. Please pass `hasValue` instead');
   }
   return buildCapabilities({
@@ -48,7 +47,7 @@ class CustomHelperManager {
       delegate = factory(owner);
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (!FROM_CAPABILITIES.has(delegate.capabilities)) {
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom helper managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.23')\` (imported via \`import { capabilities } from '@ember/helper';\`). Received: \`${JSON.stringify(delegate.capabilities
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
@@ -80,13 +79,13 @@ class CustomHelperManager {
       const args = argsProxyFor(capturedArgs, 'helper');
       const bucket = manager.createHelper(definition, args);
       if (hasValue(manager)) {
-        let cache = createComputeRef(() => manager.getValue(bucket), null, isDevelopingApp() && manager.getDebugName && manager.getDebugName(definition));
+        let cache = createComputeRef(() => manager.getValue(bucket), null, manager.getDebugName && manager.getDebugName(definition));
         if (hasDestroyable(manager)) {
           associateDestroyableChild(cache, manager.getDestroyable(bucket));
         }
         return cache;
       } else if (hasDestroyable(manager)) {
-        let ref = createConstRef(undefined, isDevelopingApp() && (manager.getDebugName?.(definition) ?? 'unknown helper'));
+        let ref = createConstRef(undefined, (manager.getDebugName?.(definition) ?? 'unknown helper'));
         associateDestroyableChild(ref, manager.getDestroyable(bucket));
         return ref;
       } else {
@@ -143,7 +142,7 @@ const HELPER_MANAGERS = new WeakMap();
  */
 const getPrototypeOf = Object.getPrototypeOf;
 function setManager(map, manager, obj) {
-  if (isDevelopingApp()) {
+  {
     debugAssert(obj !== null && (typeof obj === 'object' || typeof obj === 'function'),
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
     `Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString(obj)}`);
@@ -172,14 +171,14 @@ function setInternalModifierManager(manager, definition) {
   return setManager(MODIFIER_MANAGERS, manager, definition);
 }
 function getInternalModifierManager(definition, isOptional) {
-  if (isDevelopingApp()) {
+  {
     debugAssert(typeof definition === 'object' && definition !== null || typeof definition === 'function', () =>
     // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
     `Attempted to use a value as a modifier, but it was not an object or function. Modifier definitions must be objects or functions with an associated modifier manager. The value was: ${definition}`);
   }
   const manager = getManager(MODIFIER_MANAGERS, definition);
   if (manager === undefined) {
-    if (isDevelopingApp()) {
+    {
       debugAssert(isOptional,
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       `Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was: ${debugToString(definition)}`);
@@ -207,12 +206,11 @@ function getInternalHelperManager(definition, isOptional) {
     return manager;
   } else if (isOptional === true) {
     return null;
-  } else if (isDevelopingApp()) {
+  } else {
     throw new Error(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
     `Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was: ${debugToString(definition)}`);
   }
-  return null;
 }
 function setInternalComponentManager(factory, obj) {
   return setManager(COMPONENT_MANAGERS, factory, obj);
@@ -246,4 +244,4 @@ function hasDefaultHelperManager(definition) {
   return typeof definition === 'function';
 }
 
-export { CustomHelperManager as C, getInternalHelperManager as a, getInternalModifierManager as b, hasInternalComponentManager as c, hasInternalHelperManager as d, hasInternalModifierManager as e, hasValue as f, getInternalComponentManager as g, hasDestroyable as h, helperCapabilities as i, setInternalHelperManager as j, setInternalModifierManager as k, setInternalComponentManager as s };
+export { CustomHelperManager as C, hasDestroyable as a, hasInternalComponentManager as b, helperCapabilities as c, getInternalModifierManager as d, getInternalComponentManager as e, hasInternalHelperManager as f, getInternalHelperManager as g, hasValue as h, setInternalHelperManager as i, setInternalModifierManager as j, hasInternalModifierManager as k, setInternalComponentManager as s };

package/dist/{packages/shared-chunks/args-proxy-B91L3LRK.js → dev/packages/shared-chunks/args-proxy-DgXMc9b5.js}

@@ -1,8 +1,7 @@
 import '../@glimmer/global-context/index.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
+import './debug-to-string-CFb7h0lY.js';
 import { track } from '../@glimmer/validator/index.js';
-import { v as valueForRef } from './reference-B6HMX4y0.js';
+import { v as valueForRef } from './reference-C3TKDRnP.js';
 
 const CUSTOM_TAG_FOR = new WeakMap();
 function getCustomTagFor(obj) {
@@ -32,7 +31,7 @@ function tagForPositionalArg(positionalArgs, key) {
       positionalArgs.forEach(valueForRef);
     }
     const parsed = convertToInt(key);
-    if (parsed !== null && parsed < positionalArgs.length) {
+    if (parsed !== null && parsed >= 0 && parsed < positionalArgs.length) {
       // consume the tag of the referenced index
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       valueForRef(positionalArgs[parsed]);
@@ -69,7 +68,7 @@ class NamedArgsProxy {
 
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
   getOwnPropertyDescriptor(_target, prop) {
-    if (isDevelopingApp() && !(prop in this.named)) {
+    if (!(prop in this.named)) {
       throw new Error(`args proxies do not have real property descriptors, so you should never need to call getOwnPropertyDescriptor yourself. This code exists for enumerability, such as in for-in loops and Object.keys(). Attempted to get the descriptor for \`${String(prop)}\``);
     }
     return {
@@ -90,7 +89,7 @@ class PositionalArgsProxy {
       return positional.length;
     }
     const parsed = convertToInt(prop);
-    if (parsed !== null && parsed < positional.length) {
+    if (parsed !== null && parsed >= 0 && parsed < positional.length) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       return valueForRef(positional[parsed]);
     }
@@ -103,7 +102,7 @@ class PositionalArgsProxy {
   }
   has(_target, prop) {
     const parsed = convertToInt(prop);
-    return parsed !== null && parsed < this.positional.length;
+    return parsed !== null && parsed >= 0 && parsed < this.positional.length;
   }
 }
 const argsProxyFor = (capturedArgs, type) => {
@@ -119,7 +118,7 @@ const argsProxyFor = (capturedArgs, type) => {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
   const namedTarget = Object.create(null);
   const positionalTarget = [];
-  if (isDevelopingApp()) {
+  {
     const setHandler = function (_target, prop) {
       throw new Error(`You attempted to set ${String(prop)} on the arguments of a component, helper, or modifier. Arguments are immutable and cannot be updated directly; they always represent the values that are passed down. If you want to set default values, you should use a getter and local tracked state instead.`);
     };

package/dist/{packages/shared-chunks/array-BqYCCatg.js → dev/packages/shared-chunks/array-D8PfjQHi.js}

@@ -1,7 +1,6 @@
 import '../@ember/debug/index.js';
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
-import { k as sendEvent, n as notifyPropertyChange, F as addListener, G as removeListener } from './observers-DhgQ6ba5.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { k as sendEvent, n as notifyPropertyChange, E as addListener, F as removeListener } from './observers-Bj9qLVau.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
@@ -73,7 +72,7 @@ function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
   if (isMutableArray(array)) {
     array.replace(start, deleteCount, items);
   } else {
-    (isDevelopingApp() && !(Array.isArray(array)) && assert('Can only replace content of a native array or MutableArray', Array.isArray(array)));
+    (!(Array.isArray(array)) && assert('Can only replace content of a native array or MutableArray', Array.isArray(array)));
     replaceInNativeArray(array, start, deleteCount, items);
   }
 }
@@ -116,4 +115,4 @@ function removeArrayObserver(array, target, opts) {
   return arrayObserversHelper(array, target, opts, removeListener);
 }
 
-export { replace as a, arrayContentWillChange as b, arrayContentDidChange as c, addArrayObserver as d, removeArrayObserver as e, replaceInNativeArray as r };
+export { arrayContentWillChange as a, arrayContentDidChange as b, addArrayObserver as c, removeArrayObserver as d, replaceInNativeArray as e, replace as r };

package/dist/dev/packages/shared-chunks/capabilities-O_xc7Yqk.js

@@ -0,0 +1,34 @@
+import './debug-to-string-CFb7h0lY.js';
+import './fragment-Cc5k9Oy4.js';
+import '../@glimmer/global-context/index.js';
+import '../@glimmer/validator/index.js';
+import './reference-C3TKDRnP.js';
+import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+
+const FROM_CAPABILITIES = new WeakSet() ;
+function buildCapabilities(capabilities) {
+  {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+    FROM_CAPABILITIES.add(capabilities);
+    Object.freeze(capabilities);
+  }
+  return capabilities;
+}
+const EMPTY = InternalComponentCapabilities.Empty;
+/**
+ * Converts a ComponentCapabilities object into a 32-bit integer representation.
+ */
+function capabilityFlagsFrom(capabilities) {
+  return EMPTY | capability(capabilities, 'dynamicLayout') | capability(capabilities, 'dynamicTag') | capability(capabilities, 'prepareArgs') | capability(capabilities, 'createArgs') | capability(capabilities, 'attributeHook') | capability(capabilities, 'elementHook') | capability(capabilities, 'dynamicScope') | capability(capabilities, 'createCaller') | capability(capabilities, 'updateHook') | capability(capabilities, 'createInstance') | capability(capabilities, 'wrapped') | capability(capabilities, 'willDestroy') | capability(capabilities, 'hasSubOwner');
+}
+function capability(capabilities, capability) {
+  return capabilities[capability] ? InternalComponentCapabilities[capability] : EMPTY;
+}
+function managerHasCapability(_manager, capabilities, capability) {
+  return !!(capabilities & capability);
+}
+function hasCapability(capabilities, capability) {
+  return !!(capabilities & capability);
+}
+
+export { FROM_CAPABILITIES as F, buildCapabilities as b, capabilityFlagsFrom as c, hasCapability as h, managerHasCapability as m };

package/dist/{packages/shared-chunks/collections-B8me-ZlQ.js → dev/packages/shared-chunks/collections-D_nY_0UJ.js}

@@ -1,6 +1,5 @@
-import './debug-to-string-BsFOvUtQ.js';
+import './debug-to-string-CFb7h0lY.js';
 import { g as getLast } from './present-B1rrjAVM.js';
-import '@embroider/macros';
 
 function unwrap(val) {
   return val;

package/dist/{packages/@ember/template-compiler/lib/template.js → dev/packages/shared-chunks/compiler-CNj62pww.js}

@@ -1,21 +1,15 @@
-import templateOnly from '../../component/template-only.js';
-import { a9 as CURRIED_MODIFIER, az as CURRIED_HELPER, C as CURRIED_COMPONENT } from '../../../shared-chunks/capabilities-DHiXCCuB.js';
-import '../../../shared-chunks/debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { SexpOpcodes as opcodes, WellKnownTagNames, WellKnownAttrNames } from '../../../@glimmer/wire-format/index.js';
-import { S as SourceOffset, a as SourceSpan, c as cannotReplaceOrRemoveInKeyHandlerYet, b as cannotRemoveNode, d as cannotReplaceNode, e as SYNTHETIC_LOCATION, i as isVoidTag, E as EntityParser, f as EventedTokenizer, n as namedCharRefs, N as NON_EXISTENT_LOCATION, p as parseWithoutProcessing, g as parse, h as build, v as voidMap, j as STRICT_RESOLUTION, T as Template$1, B as Block, k as NamedBlock$1, l as SourceSlice, A as Args$1, P as PositionalArguments, m as NamedArgument$1, o as NamedArguments$1, H as HtmlAttr, q as SplatAttr$1, C as ComponentArg, r as PathExpression$1, K as KeywordExpression, s as ThisReference, u as ArgReference, F as FreeVarReference, L as LocalVarReference, w as CallExpression$1, I as InterpolateExpression$1, x as LiteralExpression, y as AppendContent, z as ElementModifier, D as NamedBlocks$1, G as InvokeBlock$1, J as SimpleElement$1, M as InvokeComponent$1, O as SpanList, Q as LooseModeResolution, R as COMPONENT_NAMESPACE, U as MODIFIER_NAMESPACE, V as HELPER_NAMESPACE, W as HtmlText, X as HtmlComment, Y as GlimmerComment, Z as Printer, _ as node, $ as isLiteral$1, a0 as maybeLoc, a1 as loc } from '../../../shared-chunks/transform-resolutions-vHYYonpB.js';
-import { a as assert } from '../../../shared-chunks/assert-CUCJBR2C.js';
-import { s as setLocalDebugType } from '../../../shared-chunks/debug-brand-B1TWjOCH.js';
-import { i as isPresentArray, b as asPresentArray, g as getLast, a as getFirst, m as mapPresentArray } from '../../../shared-chunks/present-B1rrjAVM.js';
-import { a as assign } from '../../../shared-chunks/object-utils-AijlD-JH.js';
-import { u as unwrap, e as expect, d as dict, b as exhausted } from '../../../shared-chunks/collections-B8me-ZlQ.js';
-import '../../../@glimmer/global-context/index.js';
-import '../../../@glimmer/validator/index.js';
-import '../../../shared-chunks/reference-B6HMX4y0.js';
-import '../../../@glimmer/destroyable/index.js';
-import { s as setComponentTemplate } from '../../../shared-chunks/template-CMHIG4cn.js';
-import { t as templateFactory } from '../../../shared-chunks/index-CQkjwqTv.js';
-import compileOptions from './compile-options.js';
+import './debug-to-string-CFb7h0lY.js';
+import { S as SourceOffset, a as SourceSpan, c as cannotReplaceOrRemoveInKeyHandlerYet, d as cannotRemoveNode, e as cannotReplaceNode, f as SYNTHETIC_LOCATION, i as isVoidTag, E as EntityParser, g as EventedTokenizer, n as namedCharRefs, N as NON_EXISTENT_LOCATION, p as parseWithoutProcessing, h as parse, b as build, v as voidMap, j as STRICT_RESOLUTION, T as Template$1, B as Block, k as NamedBlock$1, l as SourceSlice, A as Args$1, P as PositionalArguments, m as NamedArgument$1, o as NamedArguments$1, H as HtmlAttr, q as SplatAttr$1, C as ComponentArg, r as PathExpression$1, K as KeywordExpression, s as ThisReference, t as ArgReference, F as FreeVarReference, L as LocalVarReference, u as CallExpression$1, I as InterpolateExpression$1, w as LiteralExpression, x as AppendContent, y as ElementModifier, z as NamedBlocks$1, D as InvokeBlock$1, G as SimpleElement$1, J as InvokeComponent$1, M as SpanList, O as LooseModeResolution, Q as COMPONENT_NAMESPACE, R as MODIFIER_NAMESPACE, U as HELPER_NAMESPACE, V as HtmlText, W as HtmlComment, X as GlimmerComment, Y as Printer, Z as node, _ as isLiteral$1, $ as maybeLoc, a0 as loc } from './transform-resolutions-fXGQKGsL.js';
+import { a as assert } from './assert-CUCJBR2C.js';
+import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
+import { SexpOpcodes as opcodes, WellKnownTagNames, WellKnownAttrNames } from '../@glimmer/wire-format/index.js';
+import { i as isPresentArray, b as asPresentArray, g as getLast, a as getFirst, m as mapPresentArray } from './present-B1rrjAVM.js';
+import { a as assign } from './object-utils-AijlD-JH.js';
+import { u as unwrap, e as expect, d as dict, b as exhausted } from './collections-D_nY_0UJ.js';
+import { a4 as CURRIED_MODIFIER, au as CURRIED_HELPER, C as CURRIED_COMPONENT } from './fragment-Cc5k9Oy4.js';
+import '../@glimmer/global-context/index.js';
+import '../@glimmer/validator/index.js';
+import './reference-C3TKDRnP.js';
 
 function isKeyword(word, type) {
   if (word in KEYWORDS_TYPES) {
@@ -131,7 +125,7 @@ class Source {
         if (seenChars + column > nextLine) return nextLine;
 
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (isDevelopingApp()) {
+        {
           let roundTrip = this.hbsPosFor(seenChars + column);
           assert(roundTrip.line === line);
           assert(roundTrip.column === column);
@@ -6293,232 +6287,17 @@ function precompile(source, options = defaultOptions) {
   // JSON is javascript
   let stringified = JSON.stringify(templateJSONObject);
   if (usedLocals.length > 0) {
-    const scopeFn = `()=>[${usedLocals.join(',')}]`;
+    const scopeEntries = usedLocals.map(name => {
+      // Reserved words like "this" can't use shorthand property syntax
+      if (name === 'this') {
+        return `"this":this`;
+      }
+      return name;
+    });
+    const scopeFn = `()=>({${scopeEntries.join(',')}})`;
     stringified = stringified.replace(`"${SCOPE_PLACEHOLDER}"`, scopeFn);
   }
   return stringified;
 }
 
-/**
- * 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 => {
-      const argNames = Object.keys(scope);
-      const argValues = Object.values(scope);
-      return new Function(...argNames, `return (${source})`)(...argValues);
-    };
-  }
-}
-
-export { template };
+export { preprocess as a, precompile as p };

package/dist/{packages/shared-chunks/constants-oDhF27qL.js → dev/packages/shared-chunks/constants-eoaL3OJQ.js}

@@ -1,16 +1,16 @@
-import { a as constants, c as capabilityFlagsFrom, m as managerHasCapability } from './capabilities-DHiXCCuB.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { e as expect } from './collections-B8me-ZlQ.js';
-import '@embroider/macros';
-import { a as getInternalHelperManager, b as getInternalModifierManager, g as getInternalComponentManager } from './api-CkUl6KyJ.js';
+import { c as constants } from './fragment-Cc5k9Oy4.js';
+import './debug-to-string-CFb7h0lY.js';
+import { e as expect } from './collections-D_nY_0UJ.js';
+import { g as getInternalHelperManager, d as getInternalModifierManager, e as getInternalComponentManager } from './api-BqXkkT0p.js';
 import '../@glimmer/destroyable/index.js';
 import '../@glimmer/global-context/index.js';
 import { e as enumerate } from './array-utils-CZQxrdD3.js';
 import '../@glimmer/validator/index.js';
-import './reference-B6HMX4y0.js';
-import { g as getComponentTemplate } from './template-CMHIG4cn.js';
-import { I as InternalComponentCapabilities } from './flags-BsZlvEeR.js';
-import { t as templateFactory } from './index-CQkjwqTv.js';
+import './reference-C3TKDRnP.js';
+import { c as capabilityFlagsFrom, m as managerHasCapability } from './capabilities-O_xc7Yqk.js';
+import { g as getComponentTemplate } from './template-kM-7TTcc.js';
+import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { t as templateFactory } from './index-Q7JnrdBn.js';
 import { SexpOpcodes as opcodes } from '../@glimmer/wire-format/index.js';
 
 function unwrapHandle(handle) {

package/dist/{packages/shared-chunks/debug-to-string-BsFOvUtQ.js → dev/packages/shared-chunks/debug-to-string-CFb7h0lY.js}

@@ -1,7 +1,5 @@
-import { isDevelopingApp } from '@embroider/macros';
-
 let debugToString;
-if (isDevelopingApp()) {
+{
   let getFunctionName = fn => {
     let functionName = fn.name;
     if (functionName === '') {