ember-source 6.4.0-alpha.2 → 6.4.0-alpha.4

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

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

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

@@ -18,7 +18,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (name === '@__ARGS__') {
-          (isDevelopingApp() && !(false) && assert(`${assertMessage(name)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (isDevelopingApp() && true && assert(`${assertMessage(name)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       },
       HashPair({
@@ -26,7 +26,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (key === '__ARGS__') {
-          (isDevelopingApp() && !(false) && assert(`${assertMessage(key)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (isDevelopingApp() && true && assert(`${assertMessage(key)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       },
       PathExpression({
@@ -34,7 +34,7 @@ function assertReservedNamedArguments(env) {
         loc
       }) {
         if (isReserved(original)) {
-          (isDevelopingApp() && !(false) && assert(`${assertMessage(original)} ${calculateLocationDisplay(moduleName, loc)}`));
+          (isDevelopingApp() && true && assert(`${assertMessage(original)} ${calculateLocationDisplay(moduleName, loc)}`));
         }
       }
     }

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

@@ -7,7 +7,7 @@ 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 { t as transformResolutions } from '../../../../shared-chunks/transform-resolutions-O6uYv8DS.js';
+import { t as transformResolutions } from '../../../../shared-chunks/transform-resolutions-DckM6u9N.js';
 import transformWrapMountAndOutlet from './transform-wrap-mount-and-outlet.js';
 
 const INTERNAL_PLUGINS = {

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

@@ -1,5 +1,5 @@
 import '../../../debug/index.js';
-import { isPath, trackLocals } from './utils.js';
+import { trackLocals, isPath } from './utils.js';
 import { isDevelopingApp } from '@embroider/macros';
 import { assert } from '../../../debug/lib/assert.js';
 

package/dist/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.js

@@ -1,4 +1,4 @@
-function transformQuotedBindingsIntoJustBindings( /* env */
+function transformQuotedBindingsIntoJustBindings(/* env */
 ) {
   return {
     name: 'transform-quoted-bindings-into-just-bindings',

package/dist/packages/@ember/template-compiler/lib/plugins/transform-resolutions.js

@@ -1,5 +1,5 @@
 import '../../../debug/index.js';
-export { t as default } from '../../../../shared-chunks/transform-resolutions-O6uYv8DS.js';
+export { t as default } from '../../../../shared-chunks/transform-resolutions-DckM6u9N.js';
 import '../system/calculate-location-display.js';
 import './utils.js';
 import '@embroider/macros';

package/dist/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.js

@@ -1,4 +1,4 @@
-import { isPath, trackLocals } from './utils.js';
+import { trackLocals, isPath } from './utils.js';
 
 /**
  @module ember

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

@@ -1,24 +1,23 @@
 import templateOnly from '../../component/template-only.js';
-import { isPresentArray, getLast, mapPresentArray, exhausted, assert as debugAssert, assertPresentArray } from '../../../@glimmer/util/index.js';
-import { WellKnownTagNames, WellKnownAttrNames, SexpOpcodes as opcodes } from '../../../@glimmer/wire-format/index.js';
-import { n as node, a as api$2, g as generateSyntaxError, b as api$1, m as maybeLoc, K as KEYWORDS_TYPES, i as isKeyword, S as SourceSlice, c as normalize, l as loc } from '../../../shared-chunks/transform-resolutions-O6uYv8DS.js';
-import { CurriedType as CurriedTypes } from '../../../@glimmer/vm/index.js';
+import { SexpOpcodes as opcodes, WellKnownTagNames, WellKnownAttrNames } from '../../../@glimmer/wire-format/index.js';
+import { n as node, a as api$1, g as generateSyntaxError, b as api, m as maybeLoc, i as isKeyword, K as KEYWORDS_TYPES, S as SourceSlice, c as normalize, l as loc } from '../../../shared-chunks/transform-resolutions-DckM6u9N.js';
 import { setComponentTemplate } from '../../../@glimmer/manager/index.js';
 import { templateFactory } from '../../../@glimmer/opcode-compiler/index.js';
 import compileOptions from './compile-options.js';
 
-(function (HeadKind) {
-    return HeadKind.Block = "Block", HeadKind.Call = "Call", HeadKind.Element = "Element", HeadKind.AppendPath = "AppendPath", HeadKind.AppendExpr = "AppendExpr", HeadKind.Literal = "Literal", HeadKind.Modifier = "Modifier", HeadKind.DynamicComponent = "DynamicComponent", HeadKind.Comment = "Comment", HeadKind.Splat = "Splat", HeadKind.Keyword = "Keyword", HeadKind;
-  })({});
-  (function (VariableKind) {
-    return VariableKind.Local = "Local", VariableKind.Free = "Free", VariableKind.Arg = "Arg", VariableKind.Block = "Block", VariableKind.This = "This", VariableKind;
-  })({});
-(function (Builder) {
-    return Builder[Builder.Literal = 0] = "Literal", Builder[Builder.Comment = 1] = "Comment", Builder[Builder.Append = 2] = "Append", Builder[Builder.Modifier = 3] = "Modifier", Builder[Builder.DynamicComponent = 4] = "DynamicComponent", Builder[Builder.Get = 5] = "Get", Builder[Builder.Concat = 6] = "Concat", Builder[Builder.HasBlock = 7] = "HasBlock", Builder[Builder.HasBlockParams = 8] = "HasBlockParams", Builder;
-  })({});
-  (function (ExpressionKind) {
-    return ExpressionKind.Literal = "Literal", ExpressionKind.Call = "Call", ExpressionKind.GetPath = "GetPath", ExpressionKind.GetVar = "GetVar", ExpressionKind.Concat = "Concat", ExpressionKind.HasBlock = "HasBlock", ExpressionKind.HasBlockParams = "HasBlockParams", ExpressionKind;
-  })({});
+/// Builder ///
+const CURRIED_COMPONENT = 0,
+  CURRIED_HELPER = 1,
+  CURRIED_MODIFIER = 2;
+function isPresentArray(list) {
+  return !!list && list.length > 0;
+}
+function mapPresentArray(list, mapper) {
+  if (null === list) return null;
+  let out = [];
+  for (let item of list) out.push(mapper(item));
+  return out;
+}
 class Template extends node("Template").fields() {}
 class InElement extends node("InElement").fields() {}
 class Not extends node("Not").fields() {}
@@ -83,7 +82,6 @@ class PresentList {
   }
 }
 class EmptyList {
-  list = [];
   map(_callback) {
     return new EmptyList();
   }
@@ -101,6 +99,9 @@ class EmptyList {
   }) {
     return ifEmpty();
   }
+  constructor() {
+    this.list = [];
+  }
 }
 
 // export type OptionalList<T> = PresentList<T> | EmptyList<T>;
@@ -119,10 +120,8 @@ class ResultImpl {
 }
 const Result = ResultImpl;
 class OkImpl extends ResultImpl {
-  isOk = !0;
-  isErr = !1;
   constructor(value) {
-    super(), this.value = value;
+    super(), this.value = value, this.isOk = true, this.isErr = false;
   }
   expect(_message) {
     return this.value;
@@ -144,10 +143,8 @@ class OkImpl extends ResultImpl {
   }
 }
 class ErrImpl extends ResultImpl {
-  isOk = !1;
-  isErr = !0;
   constructor(reason) {
-    super(), this.reason = reason;
+    super(), this.reason = reason, this.isOk = false, this.isErr = true;
   }
   expect(message) {
     throw new Error(message || "expected an Ok, got Err");
@@ -193,9 +190,9 @@ class ResultArray {
   }
 }
 function convertPathToCallIfKeyword(path) {
-  return "Path" === path.type && "Free" === path.ref.type && path.ref.name in KEYWORDS_TYPES ? new api$1.CallExpression({
+  return "Path" === path.type && "Free" === path.ref.type && path.ref.name in KEYWORDS_TYPES ? new api.CallExpression({
     callee: path,
-    args: api$1.Args.empty(path.loc),
+    args: api.Args.empty(path.loc),
     loc: path.loc
   }) : path;
 }
@@ -232,7 +229,7 @@ const VISIT_EXPRS = new class {
         tail: tail
       } = path;
     if (isPresentArray(tail)) {
-      let tailLoc = tail[0].loc.extend(getLast(tail).loc);
+      let tailLoc = tail[0].loc.extend((list = tail, 0 === list.length ? void 0 : list[list.length - 1]).loc);
       return Ok(new PathExpression({
         loc: path.loc,
         head: ref,
@@ -243,6 +240,7 @@ const VISIT_EXPRS = new class {
       }));
     }
     return Ok(ref);
+    var list;
   }
   VariableReference(ref) {
     return ref;
@@ -301,7 +299,6 @@ const VISIT_EXPRS = new class {
   }
 }();
 class KeywordImpl {
-  types;
   constructor(keyword, type, delegate) {
     this.keyword = keyword, this.delegate = delegate;
     let nodes = new Set();
@@ -309,7 +306,7 @@ class KeywordImpl {
     this.types = nodes;
   }
   match(node) {
-    if (!this.types.has(node.type)) return !1;
+    if (!this.types.has(node.type)) return false;
     let path = getCalleeExpression(node);
     return null !== path && "Path" === path.type && "Free" === path.ref.type && path.ref.name === this.keyword;
   }
@@ -330,11 +327,6 @@ const KEYWORD_NODES = {
   Append: ["AppendContent"],
   Modifier: ["ElementModifier"]
 };
-
-/**
- * A "generic" keyword is something like `has-block`, which makes sense in the context
- * of sub-expression or append
- */
 function getCalleeExpression(node) {
   switch (node.type) {
     // This covers the inside of attributes and expressions, as well as the callee
@@ -352,15 +344,11 @@ function getCalleeExpression(node) {
   }
 }
 class Keywords {
-  _keywords = [];
-  _type;
   constructor(type) {
-    this._type = type;
+    this._keywords = [], this._type = type;
   }
   kw(name, delegate) {
-    return this._keywords.push(function (keyword, type, delegate) {
-      return new KeywordImpl(keyword, type, delegate);
-    }(name, this._type, delegate)), this;
+    return this._keywords.push(new KeywordImpl(name, this._type, delegate)), this;
   }
   translate(node, state) {
     for (let keyword of this._keywords) {
@@ -386,7 +374,7 @@ class Keywords {
             case "Modifier":
               return `- As a modifier, as in: <div {{${name}}}></div>`;
             default:
-              return exhausted(type);
+              return;
           }
         }).join("\n\n");
       }
@@ -503,14 +491,14 @@ function toAppend({
   };
 }
 const CurriedTypeToReadableType = {
-  [CurriedTypes.Component]: "component",
-  [CurriedTypes.Helper]: "helper",
-  [CurriedTypes.Modifier]: "modifier"
+  [CURRIED_COMPONENT]: "component",
+  [CURRIED_HELPER]: "helper",
+  [CURRIED_MODIFIER]: "modifier"
 };
 function assertCurryKeyword(curriedType) {
   return (node, state) => {
     let readableType = CurriedTypeToReadableType[curriedType],
-      stringsAllowed = curriedType === CurriedTypes.Component,
+      stringsAllowed = 0 === curriedType,
       {
         args: args
       } = node,
@@ -520,8 +508,8 @@ function assertCurryKeyword(curriedType) {
       if (stringsAllowed && state.isStrict) return Err(generateSyntaxError(`(${readableType}) cannot resolve string values in strict mode templates`, node.loc));
       if (!stringsAllowed) return Err(generateSyntaxError(`(${readableType}) cannot resolve string values, you must pass a ${readableType} definition directly`, node.loc));
     }
-    return args = new api$1.Args({
-      positional: new api$1.PositionalArguments({
+    return args = new api.Args({
+      positional: new api.PositionalArguments({
         exprs: args.positional.exprs.slice(1),
         loc: args.positional.loc
       }),
@@ -585,7 +573,7 @@ function assertHasBlockKeyword(type) {
     if (!positionals || positionals.isEmpty()) return Ok(SourceSlice.synthetic("default"));
     if (1 === positionals.exprs.length) {
       let positional = positionals.exprs[0];
-      return api$1.isLiteral(positional, "string") ? Ok(positional.toSlice()) : Err(generateSyntaxError(`(${type}) can only receive a string literal as its first argument`, call.loc));
+      return api.isLiteral(positional, "string") ? Ok(positional.toSlice()) : Err(generateSyntaxError(`(${type}) can only receive a string literal as its first argument`, call.loc));
     }
     return Err(generateSyntaxError(`(${type}) only takes a single positional argument`, call.loc));
   };
@@ -623,7 +611,7 @@ function assertIfUnlessInlineKeyword(type) {
     if (!positional || !condition) return Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Did not receive any parameters`, originalNode.loc));
     let truthy = positional.nth(1),
       falsy = positional.nth(2);
-    return null === truthy ? Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Received only one parameter, the condition`, originalNode.loc)) : positional.size > 3 ? Err(generateSyntaxError(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${inverted ? "false" : "true"}, and 3. the value to return if the condition is ${inverted ? "true" : "false"}. Received ${positional?.size ?? 0} parameters`, originalNode.loc)) : Ok({
+    return null === truthy ? Err(generateSyntaxError(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${inverted ? "false" : "true"}. Received only one parameter, the condition`, originalNode.loc)) : positional.size > 3 ? Err(generateSyntaxError(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${inverted ? "false" : "true"}, and 3. the value to return if the condition is ${inverted ? "true" : "false"}. Received ${positional.size} parameters`, originalNode.loc)) : Ok({
       condition: condition,
       truthy: truthy,
       falsy: falsy
@@ -668,7 +656,7 @@ const logKeyword = {
           positional: positional
         }
       } = node;
-      return named && !named.isEmpty() ? Err(generateSyntaxError("(log) does not take any named arguments", node.loc)) : Ok(positional);
+      return named.isEmpty() ? Ok(positional) : Err(generateSyntaxError("(log) does not take any named arguments", node.loc));
     },
     translate: function ({
       node: node,
@@ -686,12 +674,12 @@ const logKeyword = {
         args: args
       } = node;
       if (args.named.isEmpty()) return Ok({
-        target: api$2.SourceSpan.synthetic("default").toSlice(),
+        target: api$1.SourceSpan.synthetic("default").toSlice(),
         positional: args.positional
       });
       {
         let target = args.named.get("to");
-        return args.named.size > 1 || null === target ? Err(generateSyntaxError("yield only takes a single named argument: 'to'", args.named.loc)) : api$1.isLiteral(target, "string") ? Ok({
+        return args.named.size > 1 || null === target ? Err(generateSyntaxError("yield only takes a single named argument: 'to'", args.named.loc)) : api.isLiteral(target, "string") ? Ok({
           target: target.toSlice(),
           positional: args.positional
         }) : Err(generateSyntaxError("you can only yield to a literal string value", target.loc));
@@ -724,12 +712,12 @@ const logKeyword = {
       state: {
         scope: scope
       }
-    }) => (scope.setHasDebugger(), Ok(new Debugger({
+    }) => Ok(new Debugger({
       loc: node.loc,
       scope: scope
-    })))
+    }))
   }).kw("component", {
-    assert: assertCurryKeyword(CurriedTypes.Component),
+    assert: assertCurryKeyword(0),
     translate({
       node: node,
       state: state
@@ -747,7 +735,7 @@ const logKeyword = {
       }));
     }
   }).kw("helper", {
-    assert: assertCurryKeyword(CurriedTypes.Helper),
+    assert: assertCurryKeyword(1),
     translate({
       node: node,
       state: state
@@ -959,7 +947,7 @@ const logKeyword = {
       }));
     }
   }).kw("component", {
-    assert: assertCurryKeyword(CurriedTypes.Component),
+    assert: assertCurryKeyword(0),
     translate({
       node: node,
       state: state
@@ -978,7 +966,7 @@ const logKeyword = {
       }));
     }
   }),
-  CALL_KEYWORDS = keywords("Call").kw("has-block", hasBlockKeyword("has-block")).kw("has-block-params", hasBlockKeyword("has-block-params")).kw("-get-dynamic-var", getDynamicVarKeyword).kw("log", logKeyword).kw("if", ifUnlessInlineKeyword("if")).kw("unless", ifUnlessInlineKeyword("unless")).kw("component", curryKeyword(CurriedTypes.Component)).kw("helper", curryKeyword(CurriedTypes.Helper)).kw("modifier", curryKeyword(CurriedTypes.Modifier)),
+  CALL_KEYWORDS = keywords("Call").kw("has-block", hasBlockKeyword("has-block")).kw("has-block-params", hasBlockKeyword("has-block-params")).kw("-get-dynamic-var", getDynamicVarKeyword).kw("log", logKeyword).kw("if", ifUnlessInlineKeyword("if")).kw("unless", ifUnlessInlineKeyword("unless")).kw("component", curryKeyword(0)).kw("helper", curryKeyword(1)).kw("modifier", curryKeyword(2)),
   MODIFIER_KEYWORDS = keywords("Modifier"),
   XLINK = "http://www.w3.org/1999/xlink",
   XML = "http://www.w3.org/XML/1998/namespace",
@@ -1016,7 +1004,6 @@ function deflateAttrName(attrName) {
   return DEFLATE_ATTR_TABLE[attrName] ?? attrName;
 }
 class ClassifiedElement {
-  delegate;
   constructor(element, delegate, state) {
     this.element = element, this.state = state, this.delegate = delegate;
   }
@@ -1028,7 +1015,7 @@ class ClassifiedElement {
       rawValue = attr.value,
       namespace = (attrName = name.chars, WHITELIST[attrName] || void 0);
     var attrName;
-    return api$1.isLiteral(rawValue, "string") ? Ok(new StaticAttr({
+    return api.isLiteral(rawValue, "string") ? Ok(new StaticAttr({
       loc: attr.loc,
       name: name,
       value: rawValue.toSlice(),
@@ -1074,7 +1061,7 @@ class ClassifiedElement {
     return typeAttr && attrs.add(this.attr(typeAttr)), Result.all(args.toArray(), attrs.toArray()).mapOk(([args, attrs]) => ({
       attrs: attrs,
       args: new NamedArguments({
-        loc: maybeLoc(args, api$2.SourceSpan.NON_EXISTENT),
+        loc: maybeLoc(args, api$1.SourceSpan.NON_EXISTENT),
         entries: OptionalList(args)
       })
     }));
@@ -1091,7 +1078,7 @@ class ClassifiedElement {
       return {
         args: args,
         params: new ElementParameters({
-          loc: maybeLoc(elementParams, api$2.SourceSpan.NON_EXISTENT),
+          loc: maybeLoc(elementParams, api$1.SourceSpan.NON_EXISTENT),
           body: OptionalList(elementParams)
         })
       };
@@ -1099,9 +1086,8 @@ class ClassifiedElement {
   }
 }
 class ClassifiedComponent {
-  dynamicFeatures = !0;
   constructor(tag, element) {
-    this.tag = tag, this.element = element;
+    this.tag = tag, this.element = element, this.dynamicFeatures = true;
   }
   arg(attr, {
     state: state
@@ -1135,9 +1121,8 @@ class ClassifiedComponent {
 }
 class ClassifiedSimpleElement {
   constructor(tag, element, dynamicFeatures) {
-    this.tag = tag, this.element = element, this.dynamicFeatures = dynamicFeatures;
+    this.tag = tag, this.element = element, this.dynamicFeatures = dynamicFeatures, this.isComponent = false;
   }
-  isComponent = !1;
   arg(attr) {
     return Err(generateSyntaxError(`${attr.name.chars} is not a valid attribute name. @arguments are only allowed on components, but the tag for this element (\`${this.tag.chars}\`) is a regular, non-component HTML element.`, attr.loc));
   }
@@ -1231,7 +1216,7 @@ const VISIT_STMTS = new class {
   TextNode(text) {
     return new AppendTextNode({
       loc: text.loc,
-      text: new api$1.LiteralExpression({
+      text: new api.LiteralExpression({
         loc: text.loc,
         value: text.chars
       })
@@ -1249,10 +1234,8 @@ const VISIT_STMTS = new class {
  * This is the mutable state for this compiler pass.
  */
 class NormalizationState {
-  _currentScope;
-  _cursorCount = 0;
   constructor(block, isStrict) {
-    this.isStrict = isStrict, this._currentScope = block;
+    this.isStrict = isStrict, this._cursorCount = 0, this._currentScope = block;
   }
   generateUniqueCursor() {
     return `%cursor:${this._cursorCount++}%`;
@@ -1270,9 +1253,8 @@ class NormalizationState {
     }
   }
 }
-var ResolutionType = function (ResolutionType) {
-  return ResolutionType.Value = "value", ResolutionType.Component = "component", ResolutionType.Helper = "helper", ResolutionType.Modifier = "modifier", ResolutionType.ComponentOrHelper = "component or helper", ResolutionType;
-}(ResolutionType || {});
+
+/// ResolutionType ///
 class StrictModeValidationPass {
   // This is done at the end of all the keyword normalizations
   // At this point any free variables that isn't a valid keyword
@@ -1360,7 +1342,7 @@ class StrictModeValidationPass {
       case "InterpolateExpression":
         return this.InterpolateExpression(expression, span, resolution);
       case "CallExpression":
-        return this.CallExpression(expression, span, resolution ?? ResolutionType.Helper);
+        return this.CallExpression(expression, span, resolution ?? "helper");
       case "Not":
         return this.Expression(expression.value, span, resolution);
       case "IfInline":
@@ -1380,6 +1362,7 @@ class StrictModeValidationPass {
     // For cases like {{yield foo}}, when there is only a single argument, it
     // makes for a slightly better error to report that entire span. However,
     // when there are more than one, we need to be specific.
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme PresentArray
     return result = 1 === expressions.length ? this.Expression(expressions[0], span) : this.Expressions(expressions), result;
   }
   NamedArguments({
@@ -1390,7 +1373,7 @@ class StrictModeValidationPass {
     return result;
   }
   NamedArgument(arg) {
-    return "CallExpression" === arg.value.type ? this.Expression(arg.value, arg, ResolutionType.Helper) : this.Expression(arg.value, arg);
+    return "CallExpression" === arg.value.type ? this.Expression(arg.value, arg, "helper") : this.Expression(arg.value, arg);
   }
   ElementParameters({
     body: body
@@ -1411,10 +1394,10 @@ class StrictModeValidationPass {
     }
   }
   DynamicAttr(attr) {
-    return "CallExpression" === attr.value.type ? this.Expression(attr.value, attr, ResolutionType.Helper) : this.Expression(attr.value, attr);
+    return "CallExpression" === attr.value.type ? this.Expression(attr.value, attr, "helper") : this.Expression(attr.value, attr);
   }
   Modifier(modifier) {
-    return this.Expression(modifier.callee, modifier, ResolutionType.Modifier).andThen(() => this.Args(modifier.args));
+    return this.Expression(modifier.callee, modifier, "modifier").andThen(() => this.Args(modifier.args));
   }
   InElement(inElement) {
     return this.Expression(inElement.destination).andThen(() => this.Expression(inElement.insertBefore)).andThen(() => this.NamedBlock(inElement.block));
@@ -1426,16 +1409,16 @@ class StrictModeValidationPass {
     return this.Expression(statement.html, statement);
   }
   AppendTextNode(statement) {
-    return "CallExpression" === statement.text.type ? this.Expression(statement.text, statement, ResolutionType.ComponentOrHelper) : this.Expression(statement.text, statement);
+    return "CallExpression" === statement.text.type ? this.Expression(statement.text, statement, "component or helper") : this.Expression(statement.text, statement);
   }
   Component(statement) {
-    return this.Expression(statement.tag, statement, ResolutionType.Component).andThen(() => this.ElementParameters(statement.params)).andThen(() => this.NamedArguments(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
+    return this.Expression(statement.tag, statement, "component").andThen(() => this.ElementParameters(statement.params)).andThen(() => this.NamedArguments(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
   }
   SimpleElement(statement) {
     return this.ElementParameters(statement.params).andThen(() => this.Statements(statement.body));
   }
   InvokeBlock(statement) {
-    return this.Expression(statement.head, statement.head, ResolutionType.Component).andThen(() => this.Args(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
+    return this.Expression(statement.head, statement.head, "component").andThen(() => this.Args(statement.args)).andThen(() => this.NamedBlocks(statement.blocks));
   }
   If(statement) {
     return this.Expression(statement.condition, statement).andThen(() => this.NamedBlock(statement.block)).andThen(() => statement.inverse ? this.NamedBlock(statement.inverse) : Ok(null));
@@ -1450,7 +1433,7 @@ class StrictModeValidationPass {
     return this.NamedArguments(statement.named).andThen(() => this.NamedBlock(statement.block));
   }
   InvokeComponent(statement) {
-    return this.Expression(statement.definition, statement, ResolutionType.Component).andThen(() => this.Args(statement.args)).andThen(() => statement.blocks ? this.NamedBlocks(statement.blocks) : Ok(null));
+    return this.Expression(statement.definition, statement, "component").andThen(() => this.Args(statement.args)).andThen(() => statement.blocks ? this.NamedBlocks(statement.blocks) : Ok(null));
   }
   InterpolateExpression(expression, span, resolution) {
     let expressions = expression.parts.toArray();
@@ -1464,12 +1447,12 @@ class StrictModeValidationPass {
   }
   Curry(expression) {
     let resolution;
-    return resolution = expression.curriedType === CurriedTypes.Component ? ResolutionType.Component : expression.curriedType === CurriedTypes.Helper ? ResolutionType.Helper : ResolutionType.Modifier, this.Expression(expression.definition, expression, resolution).andThen(() => this.Args(expression.args));
+    return resolution = 0 === expression.curriedType ? "component" : 1 === expression.curriedType ? "helper" : "modifier", this.Expression(expression.definition, expression, resolution).andThen(() => this.Args(expression.args));
   }
   Log(expression) {
     return this.Positional(expression.positional, expression);
   }
-  errorFor(name, span, type = ResolutionType.Value) {
+  errorFor(name, span, type = "value") {
     return Err(generateSyntaxError(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${name}`, loc(span)));
   }
 }
@@ -1551,7 +1534,7 @@ const EXPR = new class {
     tail: tail
   }) {
     let getOp = EXPR.expr(head);
-    return debugAssert(getOp[0] !== opcodes.GetStrictKeyword, "[BUG] keyword in a PathExpression"), [...getOp, EXPR.Tail(tail)];
+    return getOp[0], opcodes.GetStrictKeyword, [...getOp, EXPR.Tail(tail)];
   }
   InterpolateExpression({
     parts: parts
@@ -1597,7 +1580,7 @@ const EXPR = new class {
         let [name, value] = EXPR.NamedArgument(pair);
         names.push(name), values.push(value);
       }
-      return assertPresentArray(names), assertPresentArray(values), [names, values];
+      return [names, values];
     }
     return null;
   }
@@ -1638,7 +1621,7 @@ const CONTENT = new class {
     let out = [];
     for (let statement of statements) {
       let result = CONTENT.content(statement);
-      result && result instanceof WireStatements ? out.push(...result.toArray()) : out.push(result);
+      result instanceof WireStatements ? out.push(...result.toArray()) : out.push(result);
     }
     return out;
   }
@@ -1648,7 +1631,7 @@ const CONTENT = new class {
   visitContent(stmt) {
     switch (stmt.type) {
       case "Debugger":
-        return [opcodes.Debugger, stmt.scope.getDebugInfo()];
+        return [opcodes.Debugger, ...stmt.scope.getDebugInfo(), {}];
       case "AppendComment":
         return this.AppendComment(stmt);
       case "AppendTextNode":
@@ -1676,7 +1659,7 @@ const CONTENT = new class {
       case "InvokeComponent":
         return this.InvokeComponent(stmt);
       default:
-        return exhausted(stmt);
+        return;
     }
   }
   Yield({
@@ -1868,9 +1851,9 @@ const defaultId = (() => {
  * @return {string} a template javascript string
  */
 function precompileJSON(string, options = defaultOptions) {
-  const source = new api$2.Source(string ?? "", options.meta?.moduleName),
+  const source = new api$1.Source(string ?? "", options.meta?.moduleName),
     [ast, locals] = normalize(source, {
-      lexicalScope: () => !1,
+      lexicalScope: () => false,
       ...options
     }),
     block = function (source, root, isStrict) {
@@ -1882,10 +1865,10 @@ function precompileJSON(string, options = defaultOptions) {
           body: body.toArray()
         }));
       return isStrict && (template = template.andThen(template => StrictModeValidationPass.validate(template))), template;
-    }(0, ast, options.strictMode ?? !1).mapOk(pass2In => function (template) {
+    }(0, ast, options.strictMode ?? false).mapOk(pass2In => function (template) {
       let statements = CONTENT.list(template.body),
         scope = template.scope;
-      return [statements, scope.symbols, scope.hasEval, scope.upvars];
+      return [statements, scope.symbols, scope.upvars];
     }(pass2In));
   if (block.isOk) return [block.value, locals];
   throw block.reason;
@@ -1908,8 +1891,9 @@ function precompileJSON(string, options = defaultOptions) {
  * @return {string} a template javascript string
  */
 function precompile(source, options = defaultOptions) {
-  const [block, usedLocals] = precompileJSON(source, options),
-    moduleName = options.meta?.moduleName,
+  const [block, usedLocals] = precompileJSON(source, options);
+  "emit" in options && options.emit?.debugSymbols && usedLocals.length > 0 && block.push(usedLocals);
+  const moduleName = options.meta?.moduleName,
     idFn = options.id || defaultId,
     blockJSON = JSON.stringify(block),
     templateJSONObject = {
@@ -1919,7 +1903,7 @@ function precompile(source, options = defaultOptions) {
       // lying to the type checker here because we're going to
       // replace it just below, after stringification
       scope: "796d24e6-2450-4fb0-8cdf-b65638b5ef70",
-      isStrictMode: options.strictMode ?? !1
+      isStrictMode: options.strictMode ?? false
     };
   0 === usedLocals.length && delete templateJSONObject.scope;
   // JSON is javascript

package/dist/packages/@ember/utils/lib/is_empty.js

@@ -1,12 +1,12 @@
 import '../../object/index.js';
 import '../../-internals/meta/lib/meta.js';
-import '../../../shared-chunks/mandatory-setter-BiXq-dpN.js';
+import '../../../shared-chunks/mandatory-setter-DzWEWEXy.js';
 import '@embroider/macros';
 import '../../debug/index.js';
 import '../../../@glimmer/destroyable/index.js';
 import '../../../@glimmer/validator/index.js';
 import '../../../@glimmer/manager/index.js';
-import { h as hasUnknownProperty, g as get } from '../../../shared-chunks/cache-Djf2I3Za.js';
+import { h as hasUnknownProperty, g as get } from '../../../shared-chunks/cache-DNQMcXNz.js';
 import '../../../shared-chunks/env-CwR5CFCu.js';
 
 /**