@angular/core 17.0.0-next.2 → 17.0.0-next.4

package/schematics/ng-generate/standalone-migration/bundle.js

@@ -832,98 +832,6 @@ __export(output_ast_exports, {
   variable: () => variable
 });
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/big_integer.mjs
-var BigInteger = class {
-  static zero() {
-    return new BigInteger([0]);
-  }
-  static one() {
-    return new BigInteger([1]);
-  }
-  constructor(digits) {
-    this.digits = digits;
-  }
-  clone() {
-    return new BigInteger(this.digits.slice());
-  }
-  add(other) {
-    const result = this.clone();
-    result.addToSelf(other);
-    return result;
-  }
-  addToSelf(other) {
-    const maxNrOfDigits = Math.max(this.digits.length, other.digits.length);
-    let carry = 0;
-    for (let i = 0; i < maxNrOfDigits; i++) {
-      let digitSum = carry;
-      if (i < this.digits.length) {
-        digitSum += this.digits[i];
-      }
-      if (i < other.digits.length) {
-        digitSum += other.digits[i];
-      }
-      if (digitSum >= 10) {
-        this.digits[i] = digitSum - 10;
-        carry = 1;
-      } else {
-        this.digits[i] = digitSum;
-        carry = 0;
-      }
-    }
-    if (carry > 0) {
-      this.digits[maxNrOfDigits] = 1;
-    }
-  }
-  toString() {
-    let res = "";
-    for (let i = this.digits.length - 1; i >= 0; i--) {
-      res += this.digits[i];
-    }
-    return res;
-  }
-};
-var BigIntForMultiplication = class {
-  constructor(value) {
-    this.powerOfTwos = [value];
-  }
-  getValue() {
-    return this.powerOfTwos[0];
-  }
-  multiplyBy(num) {
-    const product = BigInteger.zero();
-    this.multiplyByAndAddTo(num, product);
-    return product;
-  }
-  multiplyByAndAddTo(num, result) {
-    for (let exponent = 0; num !== 0; num = num >>> 1, exponent++) {
-      if (num & 1) {
-        const value = this.getMultipliedByPowerOfTwo(exponent);
-        result.addToSelf(value);
-      }
-    }
-  }
-  getMultipliedByPowerOfTwo(exponent) {
-    for (let i = this.powerOfTwos.length; i <= exponent; i++) {
-      const previousPower = this.powerOfTwos[i - 1];
-      this.powerOfTwos[i] = previousPower.add(previousPower);
-    }
-    return this.powerOfTwos[exponent];
-  }
-};
-var BigIntExponentiation = class {
-  constructor(base) {
-    this.base = base;
-    this.exponents = [new BigIntForMultiplication(BigInteger.one())];
-  }
-  toThePowerOf(exponent) {
-    for (let i = this.exponents.length; i <= exponent; i++) {
-      const value = this.exponents[i - 1].multiplyBy(this.base);
-      this.exponents[i] = new BigIntForMultiplication(value);
-    }
-    return this.exponents[exponent];
-  }
-};
-
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/digest.mjs
 var textEncoder;
 function digest(message) {
@@ -1031,17 +939,15 @@ function fingerprint(str) {
     hi = hi ^ 319790063;
     lo = lo ^ -1801410264;
   }
-  return [hi, lo];
+  return BigInt.asUintN(32, BigInt(hi)) << BigInt(32) | BigInt.asUintN(32, BigInt(lo));
 }
 function computeMsgId(msg, meaning = "") {
   let msgFingerprint = fingerprint(msg);
   if (meaning) {
-    const meaningFingerprint = fingerprint(meaning);
-    msgFingerprint = add64(rol64(msgFingerprint, 1), meaningFingerprint);
+    msgFingerprint = BigInt.asUintN(64, msgFingerprint << BigInt(1)) | msgFingerprint >> BigInt(63) & BigInt(1);
+    msgFingerprint += fingerprint(meaning);
   }
-  const hi = msgFingerprint[0];
-  const lo = msgFingerprint[1];
-  return wordsToDecimalString(hi & 2147483647, lo);
+  return BigInt.asUintN(63, msgFingerprint).toString();
 }
 function hash32(view, length, c) {
   let a = 2654435769, b = 2654435769;
@@ -1138,24 +1044,9 @@ function add32to64(a, b) {
   const high = (a >>> 16) + (b >>> 16) + (low >>> 16);
   return [high >>> 16, high << 16 | low & 65535];
 }
-function add64(a, b) {
-  const ah = a[0], al = a[1];
-  const bh = b[0], bl = b[1];
-  const result = add32to64(al, bl);
-  const carry = result[0];
-  const l = result[1];
-  const h = add32(add32(ah, bh), carry);
-  return [h, l];
-}
 function rol32(a, count) {
   return a << count | a >>> 32 - count;
 }
-function rol64(num, count) {
-  const hi = num[0], lo = num[1];
-  const h = hi << count | lo >>> 32 - count;
-  const l = lo << count | hi >>> 32 - count;
-  return [h, l];
-}
 function bytesToWords32(bytes, endian) {
   const size = bytes.length + 3 >>> 2;
   const words32 = [];
@@ -1180,12 +1071,6 @@ function wordAt(bytes, index, endian) {
   }
   return word;
 }
-var base256 = new BigIntExponentiation(256);
-function wordsToDecimalString(hi, lo) {
-  const decimal = base256.toThePowerOf(0).multiplyBy(lo);
-  base256.toThePowerOf(4).multiplyByAndAddTo(hi, decimal);
-  return decimal.toString();
-}
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/output/output_ast.mjs
 var TypeModifier;
@@ -1803,7 +1688,7 @@ var FunctionExpr = class extends Expression {
     this.name = name;
   }
   isEquivalent(e) {
-    return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) && areAllEquivalent(this.statements, e.statements);
+    return (e instanceof FunctionExpr || e instanceof DeclareFunctionStmt) && areAllEquivalent(this.params, e.params) && areAllEquivalent(this.statements, e.statements);
   }
   isConstant() {
     return false;
@@ -1845,6 +1730,9 @@ var ArrowFunctionExpr = class extends Expression {
   clone() {
     return new ArrowFunctionExpr(this.params.map((p2) => p2.clone()), Array.isArray(this.body) ? this.body : this.body.clone(), this.type, this.sourceSpan);
   }
+  toDeclStmt(name, modifiers) {
+    return new DeclareVarStmt(name, this, INFERRED_TYPE, modifiers, this.sourceSpan);
+  }
 };
 var UnaryOperatorExpr = class extends Expression {
   constructor(operator, expr, type, sourceSpan, parens = true) {
@@ -2478,13 +2366,28 @@ var ConstantPool = class {
       }))));
     }
   }
+  getSharedFunctionReference(fn2, prefix) {
+    var _a2;
+    const isArrow = fn2 instanceof ArrowFunctionExpr;
+    for (const current of this.statements) {
+      if (isArrow && current instanceof DeclareVarStmt && ((_a2 = current.value) == null ? void 0 : _a2.isEquivalent(fn2))) {
+        return variable(current.name);
+      }
+      if (!isArrow && current instanceof DeclareFunctionStmt && fn2.isEquivalent(current)) {
+        return variable(current.name);
+      }
+    }
+    const name = this.uniqueName(prefix);
+    this.statements.push(fn2.toDeclStmt(name, StmtModifier.Final));
+    return variable(name);
+  }
   _getLiteralFactory(key, values, resultMap) {
     let literalFactory = this.literalFactories.get(key);
     const literalFactoryArguments = values.filter((e) => !e.isConstant());
     if (!literalFactory) {
       const resultExpressions = values.map((e, index) => e.isConstant() ? this.getConstLiteral(e, true) : variable(`a${index}`));
       const parameters = resultExpressions.filter(isVariable).map((e) => new FnParam(e.name, DYNAMIC_TYPE));
-      const pureFunctionDeclaration = fn(parameters, [new ReturnStatement(resultMap(resultExpressions))], INFERRED_TYPE);
+      const pureFunctionDeclaration = arrowFn(parameters, resultMap(resultExpressions), INFERRED_TYPE);
       const name = this.freshName();
       this.statements.push(variable(name).set(pureFunctionDeclaration).toDeclStmt(INFERRED_TYPE, StmtModifier.Final));
       literalFactory = variable(name);
@@ -2788,6 +2691,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.repeaterTrackByIdentity = { name: "\u0275\u0275repeaterTrackByIdentity", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.componentInstance = { name: "\u0275\u0275componentInstance", moduleName: CORE };
+})();
 (() => {
   _Identifiers.text = { name: "\u0275\u0275text", moduleName: CORE };
 })();
@@ -5725,10 +5631,11 @@ var AbstractJsEmitterVisitor = class extends AbstractEmitterVisitor {
 var policy;
 function getPolicy() {
   if (policy === void 0) {
+    const trustedTypes = _global["trustedTypes"];
     policy = null;
-    if (_global.trustedTypes) {
+    if (trustedTypes) {
       try {
-        policy = _global.trustedTypes.createPolicy("angular#unsafe-jit", {
+        policy = trustedTypes.createPolicy("angular#unsafe-jit", {
           createScript: (s) => s
         });
       } catch (e) {
@@ -5742,7 +5649,7 @@ function trustedScriptFromString(script) {
   return ((_a2 = getPolicy()) == null ? void 0 : _a2.createScript(script)) || script;
 }
 function newTrustedFunctionForJIT(...args) {
-  if (!_global.trustedTypes) {
+  if (!_global["trustedTypes"]) {
     return new Function(...args);
   }
   const fnArgs = args.slice(0, -1).join(",");
@@ -6787,6 +6694,25 @@ function convertPropertyBinding(localResolver, implicitReceiver, expressionWitho
   }
   return new ConvertPropertyBindingResult(stmts, outputExpr);
 }
+function convertPureComponentScopeFunction(ast, localResolver, implicitReceiver, bindingId) {
+  const converted = convertPropertyBindingBuiltins({
+    createLiteralArrayConverter: () => (args) => literalArr(args),
+    createLiteralMapConverter: (keys) => (values) => literalMap(keys.map((key, index) => {
+      return {
+        key: key.key,
+        value: values[index],
+        quoted: key.quoted
+      };
+    })),
+    createPipeConverter: () => {
+      throw new Error("Illegal State: Pipes are not allowed in this context");
+    }
+  }, ast);
+  const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, false);
+  const statements = [];
+  flattenStatements(converted.visit(visitor, _Mode.Statement), statements);
+  return statements;
+}
 function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {
   const visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, true);
   const outputExpr = visitor.visitInterpolation(expressionWithArgumentsToExtract, _Mode.Expression);
@@ -9402,6 +9328,7 @@ function phaseAlignPipeVariadicVarOffset(job) {
         }
         expr.varOffset = expr.args.varOffset;
         expr.args.varOffset = expr.varOffset + varsUsedByIrExpression(expr);
+        return void 0;
       });
     }
   }
@@ -15555,7 +15482,7 @@ var _TreeBuilder = class {
       const parent = this._getContainer();
       if (parent instanceof BlockGroup) {
         this.errors.push(TreeError.create(null, startSpan, "Text cannot be placed directly inside of a block group."));
-        return null;
+        return;
       }
       if (parent != null && parent.children.length === 0 && this.getTagDefinition(parent.name).ignoreFirstLf) {
         text2 = text2.substring(1);
@@ -16448,6 +16375,7 @@ function mergeNextContextsInOps(ops) {
             tryToMerge = false;
             break;
         }
+        return;
       });
     }
   }
@@ -19433,7 +19361,10 @@ function validateSwitchBlock(ast) {
   const [primaryBlock, ...secondaryBlocks] = ast.blocks;
   const errors = [];
   let hasDefault = false;
-  if (primaryBlock.children.length > 0) {
+  const hasPrimary = primaryBlock.children.length > 0 && primaryBlock.children.some((child) => {
+    return !(child instanceof Text4) || child.value.trim().length > 0;
+  });
+  if (hasPrimary) {
     errors.push(new ParseError(primaryBlock.sourceSpan, 'Switch block can only contain "case" and "default" blocks'));
   }
   if (primaryBlock.parameters.length !== 1) {
@@ -20505,9 +20436,10 @@ function createComponentDefConsts() {
   };
 }
 var TemplateData = class {
-  constructor(name, index, visitor) {
+  constructor(name, index, scope, visitor) {
     this.name = name;
     this.index = index;
+    this.scope = scope;
     this.visitor = visitor;
   }
   getConstCount() {
@@ -20999,7 +20931,7 @@ var TemplateDefinitionBuilder = class {
         this._ngContentReservedSlots.push(...visitor._ngContentReservedSlots);
       }
     });
-    return new TemplateData(name, index, visitor);
+    return new TemplateData(name, index, visitor._bindingScope, visitor);
   }
   createEmbeddedTemplateFn(tagName, children, contextNameSuffix, sourceSpan, variables = [], attrsExprs, references, i18n2) {
     const data = this.prepareEmbeddedTemplateFn(children, contextNameSuffix, variables, i18n2);
@@ -21194,15 +21126,15 @@ var TemplateDefinitionBuilder = class {
     const dependencyExp = [];
     for (const deferredDep of deferredDeps) {
       if (deferredDep.isDeferrable) {
-        const innerFn = fn([new FnParam("m", DYNAMIC_TYPE)], [new ReturnStatement(variable("m").prop(deferredDep.symbolName))]);
+        const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(deferredDep.symbolName));
         const importExpr2 = new DynamicImportExpr(deferredDep.importPath).prop("then").callFn([innerFn]);
         dependencyExp.push(importExpr2);
       } else {
         dependencyExp.push(deferredDep.type);
       }
     }
-    const depsFnExpr = fn([], [new ReturnStatement(literalArr(dependencyExp))], INFERRED_TYPE, null, name);
-    this.constantPool.statements.push(depsFnExpr.toDeclStmt(name));
+    const depsFnExpr = arrowFn([], literalArr(dependencyExp));
+    this.constantPool.statements.push(depsFnExpr.toDeclStmt(name, StmtModifier.Final));
     return variable(name);
   }
   createDeferTriggerInstructions(deferredIndex, triggers, prefetch) {
@@ -21236,55 +21168,95 @@ var TemplateDefinitionBuilder = class {
   }
   visitForLoopBlock(block) {
     const blockIndex = this.allocateDataSlot();
-    const templateVariables = this.createForLoopVariables(block);
-    const primaryData = this.prepareEmbeddedTemplateFn(block.children, "_For", templateVariables);
+    const primaryData = this.prepareEmbeddedTemplateFn(block.children, "_For", [
+      new Variable(block.itemName, "$implicit", block.sourceSpan, block.sourceSpan),
+      new Variable(getLoopLocalName(block, "$index"), "$index", block.sourceSpan, block.sourceSpan),
+      new Variable(getLoopLocalName(block, "$count"), "$count", block.sourceSpan, block.sourceSpan)
+    ]);
     const emptyData = block.empty === null ? null : this.prepareEmbeddedTemplateFn(block.empty.children, "_ForEmpty");
-    const trackByFn = this.createTrackByFunction(block);
+    const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
     const value = block.expression.visit(this._valueConverter);
     this.allocateBindingSlots(value);
+    this.registerComputedLoopVariables(block, primaryData.scope);
     this.creationInstruction(block.sourceSpan, Identifiers.repeaterCreate, () => {
       const params = [
         literal(blockIndex),
         variable(primaryData.name),
         literal(primaryData.getConstCount()),
         literal(primaryData.getVarCount()),
-        trackByFn
+        trackByExpression
       ];
       if (emptyData !== null) {
-        params.push(variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+        params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+      } else if (trackByUsesComponentInstance) {
+        params.push(literal(trackByUsesComponentInstance));
       }
       return params;
     });
     this.updateInstruction(block.sourceSpan, Identifiers.repeater, () => [literal(blockIndex), this.convertPropertyBinding(value)]);
   }
-  createForLoopVariables(block) {
+  registerComputedLoopVariables(block, bindingScope) {
     const indexLocalName = getLoopLocalName(block, "$index");
     const countLocalName = getLoopLocalName(block, "$count");
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$odd"), (scope) => scope.get(indexLocalName).modulo(literal(2)).notIdentical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$even"), (scope) => scope.get(indexLocalName).modulo(literal(2)).identical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$first"), (scope) => scope.get(indexLocalName).identical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$last"), (scope) => scope.get(indexLocalName).identical(scope.get(countLocalName).minus(literal(1))));
-    return [
-      new Variable(block.itemName, "$implicit", block.sourceSpan, block.sourceSpan),
-      new Variable(indexLocalName, "$index", block.sourceSpan, block.sourceSpan),
-      new Variable(countLocalName, "$count", block.sourceSpan, block.sourceSpan)
-    ];
+    const level = bindingScope.bindingLevel;
+    bindingScope.set(level, getLoopLocalName(block, "$odd"), (scope) => scope.get(indexLocalName).modulo(literal(2)).notIdentical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$even"), (scope) => scope.get(indexLocalName).modulo(literal(2)).identical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$first"), (scope) => scope.get(indexLocalName).identical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$last"), (scope) => scope.get(indexLocalName).identical(scope.get(countLocalName).minus(literal(1))));
   }
-  createTrackByFunction(block) {
+  optimizeTrackByFunction(block) {
     const ast = block.trackBy.ast;
     if (ast instanceof PropertyRead && ast.receiver instanceof ImplicitReceiver && ast.name === getLoopLocalName(block, "$index")) {
-      return importExpr(Identifiers.repeaterTrackByIndex);
+      return { expression: importExpr(Identifiers.repeaterTrackByIndex), usesComponentInstance: false };
     }
     if (ast instanceof PropertyRead && ast.receiver instanceof ImplicitReceiver && ast.name === block.itemName) {
-      return importExpr(Identifiers.repeaterTrackByIdentity);
+      return { expression: importExpr(Identifiers.repeaterTrackByIdentity), usesComponentInstance: false };
+    }
+    if (ast instanceof Call && ast.receiver instanceof PropertyRead && ast.receiver.receiver instanceof ImplicitReceiver && ast.args.length === 2) {
+      const firstIsIndex = ast.args[0] instanceof PropertyRead && ast.args[0].receiver instanceof ImplicitReceiver && ast.args[0].name === getLoopLocalName(block, "$index");
+      const secondIsItem = ast.args[1] instanceof PropertyRead && ast.args[1].receiver instanceof ImplicitReceiver && ast.args[1].name === block.itemName;
+      if (firstIsIndex && secondIsItem) {
+        const receiver = this.level === 0 ? variable(CONTEXT_NAME) : new ExternalExpr(Identifiers.componentInstance).callFn([]);
+        return { expression: receiver.prop(ast.receiver.name), usesComponentInstance: false };
+      }
     }
-    if (ast instanceof PropertyRead && ast.receiver instanceof PropertyRead && ast.receiver.receiver instanceof ImplicitReceiver && ast.receiver.name === block.itemName) {
-      const params = [getLoopLocalName(block, "$index"), block.itemName];
-      const scope = this._bindingScope.nestedScope(this.level + 1, new Set(params));
-      const binding = convertPropertyBinding(scope, variable(CONTEXT_NAME), block.trackBy, "trackBy");
-      return arrowFn(params.map((param) => new FnParam(param)), binding.currValExpr);
+    return null;
+  }
+  createTrackByFunction(block) {
+    const optimizedFn = this.optimizeTrackByFunction(block);
+    if (optimizedFn !== null) {
+      return optimizedFn;
+    }
+    const bannedGlobals = /* @__PURE__ */ new Set([
+      getLoopLocalName(block, "$count"),
+      getLoopLocalName(block, "$first"),
+      getLoopLocalName(block, "$last"),
+      getLoopLocalName(block, "$even"),
+      getLoopLocalName(block, "$odd")
+    ]);
+    const scope = new TrackByBindingScope(this._bindingScope, {
+      [getLoopLocalName(block, "$index")]: "$index",
+      [block.itemName]: "$item"
+    }, bannedGlobals);
+    const params = [new FnParam("$index"), new FnParam("$item")];
+    const stmts = convertPureComponentScopeFunction(block.trackBy.ast, scope, variable(CONTEXT_NAME), "track");
+    const usesComponentInstance = scope.getComponentAccessCount() > 0;
+    let fn2;
+    if (!usesComponentInstance && stmts.length === 1 && stmts[0] instanceof ExpressionStatement) {
+      fn2 = arrowFn(params, stmts[0].expr);
+    } else {
+      if (stmts.length > 0) {
+        const lastStatement = stmts[stmts.length - 1];
+        if (lastStatement instanceof ExpressionStatement) {
+          stmts[stmts.length - 1] = new ReturnStatement(lastStatement.expr);
+        }
+      }
+      fn2 = fn(params, stmts);
     }
-    throw new Error("Unsupported track expression");
+    return {
+      expression: this.constantPool.getSharedFunctionReference(fn2, "_forTrack"),
+      usesComponentInstance
+    };
   }
   getConstCount() {
     return this._dataIndex;
@@ -21645,6 +21617,9 @@ var BindingScope = class {
     }
     return this.bindingLevel === 0 ? null : this.getComponentProperty(name);
   }
+  hasLocal(name) {
+    return this.map.has(name);
+  }
   set(retrievalLevel, name, lhs, priority = 0, declareLocalCallback, localRef) {
     if (this.map.has(name)) {
       if (localRef) {
@@ -21761,6 +21736,37 @@ var BindingScope = class {
     this.usesRestoredViewContext = true;
   }
 };
+var TrackByBindingScope = class extends BindingScope {
+  constructor(parentScope, globalAliases, bannedGlobals) {
+    super(parentScope.bindingLevel + 1, parentScope);
+    this.globalAliases = globalAliases;
+    this.bannedGlobals = bannedGlobals;
+    this.componentAccessCount = 0;
+  }
+  get(name) {
+    let current = this.parent;
+    while (current) {
+      if (current.hasLocal(name)) {
+        this.forbiddenAccessError(name);
+      }
+      current = current.parent;
+    }
+    if (this.bannedGlobals.has(name)) {
+      this.forbiddenAccessError(name);
+    }
+    if (this.globalAliases[name]) {
+      return variable(this.globalAliases[name]);
+    }
+    this.componentAccessCount++;
+    return variable("this").prop(name);
+  }
+  getComponentAccessCount() {
+    return this.componentAccessCount;
+  }
+  forbiddenAccessError(propertyName) {
+    throw new Error(`Accessing ${propertyName} inside of a track expression is not allowed. Tracking expressions can only access the item, $index and properties on the containing component.`);
+  }
+};
 function createCssSelector(elementName, attributes) {
   const cssSelector = new CssSelector();
   const elementNameNoNs = splitNsName(elementName)[1];
@@ -22303,10 +22309,10 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
   const eventBindings = bindingParser.createDirectiveHostEventAsts(hostBindingsMetadata.listeners, typeSourceSpan);
   if (USE_TEMPLATE_PIPELINE) {
     if (hostBindingsMetadata.specialAttributes.styleAttr) {
-      hostBindingsMetadata.attributes.style = literal(hostBindingsMetadata.specialAttributes.styleAttr);
+      hostBindingsMetadata.attributes["style"] = literal(hostBindingsMetadata.specialAttributes.styleAttr);
     }
     if (hostBindingsMetadata.specialAttributes.classAttr) {
-      hostBindingsMetadata.attributes.class = literal(hostBindingsMetadata.specialAttributes.classAttr);
+      hostBindingsMetadata.attributes["class"] = literal(hostBindingsMetadata.specialAttributes.classAttr);
     }
     const hostJob = ingestHostBinding({
       componentName: name,
@@ -23125,7 +23131,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("17.0.0-next.2");
+var VERSION2 = new Version("17.0.0-next.4");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -24662,7 +24668,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -24733,7 +24739,7 @@ function createDirectiveDefinitionMap(meta) {
   const hasTransformFunctions = Object.values(meta.inputs).some((input) => input.transformFunction !== null);
   const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION2 : "14.0.0";
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -24921,7 +24927,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -24944,7 +24950,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -24982,7 +24988,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -25006,7 +25012,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -25041,7 +25047,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.4"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -25058,7 +25064,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("17.0.0-next.2");
+var VERSION3 = new Version("17.0.0-next.4");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -25215,6 +25221,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["HOST_DIRECTIVE_CONFLICTING_ALIAS"] = 2018] = "HOST_DIRECTIVE_CONFLICTING_ALIAS";
   ErrorCode2[ErrorCode2["HOST_DIRECTIVE_MISSING_REQUIRED_BINDING"] = 2019] = "HOST_DIRECTIVE_MISSING_REQUIRED_BINDING";
   ErrorCode2[ErrorCode2["CONFLICTING_INPUT_TRANSFORM"] = 2020] = "CONFLICTING_INPUT_TRANSFORM";
+  ErrorCode2[ErrorCode2["COMPONENT_INVALID_STYLE_URLS"] = 2021] = "COMPONENT_INVALID_STYLE_URLS";
   ErrorCode2[ErrorCode2["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
   ErrorCode2[ErrorCode2["IMPORT_CYCLE_DETECTED"] = 3003] = "IMPORT_CYCLE_DETECTED";
   ErrorCode2[ErrorCode2["IMPORT_GENERATION_FAILURE"] = 3004] = "IMPORT_GENERATION_FAILURE";
@@ -25235,7 +25242,6 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["NGMODULE_DECLARATION_IS_STANDALONE"] = 6008] = "NGMODULE_DECLARATION_IS_STANDALONE";
   ErrorCode2[ErrorCode2["NGMODULE_BOOTSTRAP_IS_STANDALONE"] = 6009] = "NGMODULE_BOOTSTRAP_IS_STANDALONE";
   ErrorCode2[ErrorCode2["WARN_NGMODULE_ID_UNNECESSARY"] = 6100] = "WARN_NGMODULE_ID_UNNECESSARY";
-  ErrorCode2[ErrorCode2["NGMODULE_VE_DEPENDENCY_ON_IVY_LIB"] = 6999] = "NGMODULE_VE_DEPENDENCY_ON_IVY_LIB";
   ErrorCode2[ErrorCode2["SCHEMA_INVALID_ELEMENT"] = 8001] = "SCHEMA_INVALID_ELEMENT";
   ErrorCode2[ErrorCode2["SCHEMA_INVALID_ATTRIBUTE"] = 8002] = "SCHEMA_INVALID_ATTRIBUTE";
   ErrorCode2[ErrorCode2["MISSING_REFERENCE_TARGET"] = 8003] = "MISSING_REFERENCE_TARGET";
@@ -29171,10 +29177,9 @@ function readMapType(type, valueTransform) {
       return;
     }
     const value = valueTransform(member.type);
-    if (value === null) {
-      return null;
+    if (value !== null) {
+      obj[member.name.text] = value;
     }
-    obj[member.name.text] = value;
   });
   return obj;
 }
@@ -32143,13 +32148,14 @@ function parseDirectiveStyles(directive, evaluator, compilationMode) {
   if (!expression) {
     return null;
   }
-  const value = evaluator.evaluate(expression);
+  const evaluated = evaluator.evaluate(expression);
+  const value = typeof evaluated === "string" ? [evaluated] : evaluated;
   if (compilationMode === CompilationMode.LOCAL && Array.isArray(value)) {
     for (const entry of value) {
       if (entry instanceof DynamicValue && entry.isFromUnknownIdentifier()) {
         const relatedInformation = traceDynamicValue(expression, entry);
         const chain = {
-          messageText: `Unknown identifier used as styles string: ${entry.node.getText()} (did you import this string from another file? This is not allowed in local compilation mode. Please either inline it or move it to a separate file and include it using'styleUrls')`,
+          messageText: `Unknown identifier used as styles string: ${entry.node.getText()} (did you import this string from another file? This is not allowed in local compilation mode. Please either inline it or move it to a separate file and include it using 'styleUrl')`,
           category: import_typescript48.default.DiagnosticCategory.Error,
           code: 0
         };
@@ -32158,7 +32164,7 @@ function parseDirectiveStyles(directive, evaluator, compilationMode) {
     }
   }
   if (!isStringArrayOrDie(value, "styles", expression)) {
-    throw createValueHasWrongTypeError(expression, value, `Failed to resolve @Directive.styles to a string array`);
+    throw createValueHasWrongTypeError(expression, value, `Failed to resolve @Component.styles to a string or an array of strings`);
   }
   return value;
 }
@@ -33452,7 +33458,8 @@ function parseExtractedTemplate(template2, sourceStr, sourceParseRange, escapedS
     enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat,
     i18nNormalizeLineEndingsInICUs,
     leadingTriviaChars: [],
-    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData
+    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData,
+    enabledBlockTypes: options.enabledBlockTypes
   });
   return __spreadProps(__spreadValues({}, parsedTemplate), {
     diagNodes,
@@ -33575,7 +33582,7 @@ function transformDecoratorResources(dec, component, styles, template2) {
   if (dec.name !== "Component") {
     return dec;
   }
-  if (!component.has("templateUrl") && !component.has("styleUrls") && !component.has("styles")) {
+  if (!component.has("templateUrl") && !component.has("styleUrls") && !component.has("styleUrl") && !component.has("styles")) {
     return dec;
   }
   const metadata = new Map(component);
@@ -33583,9 +33590,10 @@ function transformDecoratorResources(dec, component, styles, template2) {
     metadata.delete("templateUrl");
     metadata.set("template", import_typescript52.default.factory.createStringLiteral(template2.content));
   }
-  if (metadata.has("styleUrls") || metadata.has("styles")) {
+  if (metadata.has("styleUrls") || metadata.has("styleUrl") || metadata.has("styles")) {
     metadata.delete("styles");
     metadata.delete("styleUrls");
+    metadata.delete("styleUrl");
     if (styles.length > 0) {
       const styleNodes = styles.reduce((result, style) => {
         if (style.trim().length > 0) {
@@ -33605,10 +33613,26 @@ function transformDecoratorResources(dec, component, styles, template2) {
   return __spreadProps(__spreadValues({}, dec), { args: [import_typescript52.default.factory.createObjectLiteralExpression(newMetadataFields)] });
 }
 function extractComponentStyleUrls(evaluator, component) {
-  if (!component.has("styleUrls")) {
-    return [];
+  const styleUrlsExpr = component.get("styleUrls");
+  const styleUrlExpr = component.get("styleUrl");
+  if (styleUrlsExpr !== void 0 && styleUrlExpr !== void 0) {
+    throw new FatalDiagnosticError(ErrorCode.COMPONENT_INVALID_STYLE_URLS, styleUrlExpr, "@Component cannot define both `styleUrl` and `styleUrls`. Use `styleUrl` if the component has one stylesheet, or `styleUrls` if it has multiple");
+  }
+  if (styleUrlsExpr !== void 0) {
+    return extractStyleUrlsFromExpression(evaluator, component.get("styleUrls"));
+  }
+  if (styleUrlExpr !== void 0) {
+    const styleUrl = evaluator.evaluate(styleUrlExpr);
+    if (typeof styleUrl !== "string") {
+      throw createValueHasWrongTypeError(styleUrlExpr, styleUrl, "styleUrl must be a string");
+    }
+    return [{
+      url: styleUrl,
+      source: 2,
+      nodeForError: styleUrlExpr
+    }];
   }
-  return extractStyleUrlsFromExpression(evaluator, component.get("styleUrls"));
+  return [];
 }
 function extractStyleUrlsFromExpression(evaluator, styleUrlsExpr) {
   const styleUrls = [];
@@ -33648,24 +33672,41 @@ function extractStyleResources(resourceLoader, component, containingFile) {
   function stringLiteralElements(array) {
     return array.elements.filter((e) => import_typescript52.default.isStringLiteralLike(e));
   }
+  const styleUrlExpr = component.get("styleUrl");
   const styleUrlsExpr = component.get("styleUrls");
   if (styleUrlsExpr !== void 0 && import_typescript52.default.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const expression of stringLiteralElements(styleUrlsExpr)) {
-      try {
-        const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
-        styles.add({ path: absoluteFrom(resourceUrl), expression });
-      } catch (e) {
+      const resource = stringLiteralUrlToResource(resourceLoader, expression, containingFile);
+      if (resource !== null) {
+        styles.add(resource);
       }
     }
+  } else if (styleUrlExpr !== void 0 && import_typescript52.default.isStringLiteralLike(styleUrlExpr)) {
+    const resource = stringLiteralUrlToResource(resourceLoader, styleUrlExpr, containingFile);
+    if (resource !== null) {
+      styles.add(resource);
+    }
   }
   const stylesExpr = component.get("styles");
-  if (stylesExpr !== void 0 && import_typescript52.default.isArrayLiteralExpression(stylesExpr)) {
-    for (const expression of stringLiteralElements(stylesExpr)) {
-      styles.add({ path: null, expression });
+  if (stylesExpr !== void 0) {
+    if (import_typescript52.default.isArrayLiteralExpression(stylesExpr)) {
+      for (const expression of stringLiteralElements(stylesExpr)) {
+        styles.add({ path: null, expression });
+      }
+    } else if (import_typescript52.default.isStringLiteralLike(stylesExpr)) {
+      styles.add({ path: null, expression: stylesExpr });
     }
   }
   return styles;
 }
+function stringLiteralUrlToResource(resourceLoader, expression, containingFile) {
+  try {
+    const resourceUrl = resourceLoader.resolve(expression.text, containingFile);
+    return { path: absoluteFrom(resourceUrl), expression };
+  } catch (e) {
+    return null;
+  }
+}
 function _extractTemplateStyleUrls(template2) {
   if (template2.styleUrls === null) {
     return [];
@@ -34156,6 +34197,7 @@ var ComponentDecoratorHandler = class {
         file: analysis.template.file
       }
     });
+    return null;
   }
   typeCheck(ctx, node, meta) {
     if (this.typeCheckScopeRegistry === null || !import_typescript53.default.isClassDeclaration(node)) {
@@ -38324,18 +38366,18 @@ var TcbTemplateBodyOp = class extends TcbOp {
     return null;
   }
 };
-var TcbTextInterpolationOp = class extends TcbOp {
-  constructor(tcb, scope, binding) {
+var TcbExpressionOp = class extends TcbOp {
+  constructor(tcb, scope, expression) {
     super();
     this.tcb = tcb;
     this.scope = scope;
-    this.binding = binding;
+    this.expression = expression;
   }
   get optional() {
     return false;
   }
   execute() {
-    const expr = tcbExpression(this.binding.value, this.tcb, this.scope);
+    const expr = tcbExpression(this.expression, this.tcb, this.scope);
     this.scope.addStatement(import_typescript83.default.factory.createExpressionStatement(expr));
     return null;
   }
@@ -38912,9 +38954,7 @@ var Scope2 = class {
       this.elementOpMap.set(node, opIndex);
       this.appendDirectivesAndInputsOfNode(node);
       this.appendOutputsOfNode(node);
-      for (const child of node.children) {
-        this.appendNode(child);
-      }
+      this.appendChildren(node);
       this.checkAndAppendReferencesOfNode(node);
     } else if (node instanceof Template) {
       this.appendDirectivesAndInputsOfNode(node);
@@ -38927,12 +38967,35 @@ var Scope2 = class {
         this.appendDeepSchemaChecks(node.children);
       }
       this.checkAndAppendReferencesOfNode(node);
+    } else if (node instanceof DeferredBlock) {
+      node.triggers.when !== void 0 && this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.triggers.when.value));
+      node.prefetchTriggers.when !== void 0 && this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.prefetchTriggers.when.value));
+      this.appendChildren(node);
+      node.placeholder !== null && this.appendChildren(node.placeholder);
+      node.loading !== null && this.appendChildren(node.loading);
+      node.error !== null && this.appendChildren(node.error);
+    } else if (node instanceof IfBlock) {
+      for (const branch of node.branches) {
+        this.appendChildren(branch);
+      }
+    } else if (node instanceof SwitchBlock) {
+      for (const currentCase of node.cases) {
+        this.appendChildren(currentCase);
+      }
+    } else if (node instanceof ForLoopBlock) {
+      this.appendChildren(node);
+      node.empty && this.appendChildren(node.empty);
     } else if (node instanceof BoundText) {
-      this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, node));
+      this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.value));
     } else if (node instanceof Icu) {
       this.appendIcuExpressions(node);
     }
   }
+  appendChildren(node) {
+    for (const child of node.children) {
+      this.appendNode(child);
+    }
+  }
   checkAndAppendReferencesOfNode(node) {
     for (const ref of node.references) {
       const target = this.tcb.boundTarget.getReferenceTarget(ref);
@@ -39033,11 +39096,11 @@ var Scope2 = class {
   }
   appendIcuExpressions(node) {
     for (const variable2 of Object.values(node.vars)) {
-      this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, variable2));
+      this.opQueue.push(new TcbExpressionOp(this.tcb, this, variable2.value));
     }
     for (const placeholder of Object.values(node.placeholders)) {
       if (placeholder instanceof BoundText) {
-        this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, placeholder));
+        this.opQueue.push(new TcbExpressionOp(this.tcb, this, placeholder.value));
       }
     }
   }
@@ -41315,8 +41378,8 @@ var NgCompiler = class {
     this.constructionDiagnostics = [];
     this.nonTemplateDiagnostics = null;
     this.delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);
-    this.enableTemplateTypeChecker = enableTemplateTypeChecker || ((_a2 = options._enableTemplateTypeChecker) != null ? _a2 : false);
-    this.enabledBlockTypes = new Set((_b2 = options._enabledBlockTypes) != null ? _b2 : []);
+    this.enableTemplateTypeChecker = enableTemplateTypeChecker || ((_a2 = options["_enableTemplateTypeChecker"]) != null ? _a2 : false);
+    this.enabledBlockTypes = new Set((_b2 = options["_enabledBlockTypes"]) != null ? _b2 : []);
     this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics, ...verifyCompatibleTypeCheckOptions(this.options));
     this.currentProgram = inputProgram;
     this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
@@ -41709,7 +41772,7 @@ var NgCompiler = class {
     const reflector = new TypeScriptReflectionHost(checker);
     let refEmitter;
     let aliasingHost = null;
-    if (this.adapter.unifiedModulesHost === null || !this.options._useHostForImportGeneration) {
+    if (this.adapter.unifiedModulesHost === null || !this.options["_useHostForImportGeneration"]) {
       let localImportStrategy;
       if (this.options.rootDir !== void 0 || this.options.rootDirs !== void 0 && this.options.rootDirs.length > 0) {
         localImportStrategy = new LogicalProjectStrategy(reflector, new LogicalFileSystem([...this.adapter.rootDirs], this.adapter));
@@ -41776,8 +41839,8 @@ var NgCompiler = class {
     }
     const cycleHandlingStrategy = compilationMode === CompilationMode.FULL ? 0 : 1;
     const strictCtorDeps = this.options.strictInjectionParameters || false;
-    const supportJitMode = (_a2 = this.options.supportJitMode) != null ? _a2 : true;
-    const supportTestBed = (_b2 = this.options.supportTestBed) != null ? _b2 : true;
+    const supportJitMode = (_a2 = this.options["supportJitMode"]) != null ? _a2 : true;
+    const supportTestBed = (_b2 = this.options["supportTestBed"]) != null ? _b2 : true;
     if (supportTestBed === false && compilationMode === CompilationMode.PARTIAL) {
       throw new Error('TestBed support ("supportTestBed" option) cannot be disabled in partial compilation mode.');
     }