@angular/core 19.0.0-next.8 → 19.0.0-next.9

package/schematics/bundles/{group_replacements-472b2387.js → group_replacements-e1b5cbf8.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.8
+ * @license Angular v19.0.0-next.9
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,12 +8,12 @@
 
 var os = require('os');
 var ts = require('typescript');
-var checker = require('./checker-e68dd7ce.js');
-var program = require('./program-105283c5.js');
+var checker = require('./checker-3b2ea20f.js');
+var program = require('./program-6534a30a.js');
 require('path');
 var assert = require('assert');
 var core = require('@angular-devkit/core');
-var path = require('node:path');
+var posixPath = require('node:path/posix');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -38,7 +38,7 @@ function _interopNamespace(e) {
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var posixPath__namespace = /*#__PURE__*/_interopNamespace(posixPath);
 
 /// <reference types="node" />
 class NgtscCompilerHost {
@@ -252,40 +252,40 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
 }
 
 /**
- * Reasons why an input cannot be migrated.
+ * Reasons why a field cannot be migrated.
  *
  * Higher values of incompatibility reasons indicate a more significant
  * incompatibility reason. Lower ones may be overridden by higher ones.
  * */
-exports.InputIncompatibilityReason = void 0;
-(function (InputIncompatibilityReason) {
-    InputIncompatibilityReason[InputIncompatibilityReason["OverriddenByDerivedClass"] = 1] = "OverriddenByDerivedClass";
-    InputIncompatibilityReason[InputIncompatibilityReason["RedeclaredViaDerivedClassInputsArray"] = 2] = "RedeclaredViaDerivedClassInputsArray";
-    InputIncompatibilityReason[InputIncompatibilityReason["TypeConflictWithBaseClass"] = 3] = "TypeConflictWithBaseClass";
-    InputIncompatibilityReason[InputIncompatibilityReason["ParentIsIncompatible"] = 4] = "ParentIsIncompatible";
-    InputIncompatibilityReason[InputIncompatibilityReason["SpyOnThatOverwritesField"] = 5] = "SpyOnThatOverwritesField";
-    InputIncompatibilityReason[InputIncompatibilityReason["PotentiallyNarrowedInTemplateButNoSupportYet"] = 6] = "PotentiallyNarrowedInTemplateButNoSupportYet";
-    InputIncompatibilityReason[InputIncompatibilityReason["RequiredInputButNoGoodExplicitTypeExtractable"] = 7] = "RequiredInputButNoGoodExplicitTypeExtractable";
-    InputIncompatibilityReason[InputIncompatibilityReason["InputWithQuestionMarkButNoGoodExplicitTypeExtractable"] = 8] = "InputWithQuestionMarkButNoGoodExplicitTypeExtractable";
-    InputIncompatibilityReason[InputIncompatibilityReason["WriteAssignment"] = 9] = "WriteAssignment";
-    InputIncompatibilityReason[InputIncompatibilityReason["Accessor"] = 10] = "Accessor";
-    InputIncompatibilityReason[InputIncompatibilityReason["OutsideOfMigrationScope"] = 11] = "OutsideOfMigrationScope";
-    InputIncompatibilityReason[InputIncompatibilityReason["SkippedViaConfigFilter"] = 12] = "SkippedViaConfigFilter";
-})(exports.InputIncompatibilityReason || (exports.InputIncompatibilityReason = {}));
-/** Reasons why a whole class and its inputs cannot be migrated. */
+exports.FieldIncompatibilityReason = void 0;
+(function (FieldIncompatibilityReason) {
+    FieldIncompatibilityReason[FieldIncompatibilityReason["OverriddenByDerivedClass"] = 1] = "OverriddenByDerivedClass";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["RedeclaredViaDerivedClassInputsArray"] = 2] = "RedeclaredViaDerivedClassInputsArray";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["TypeConflictWithBaseClass"] = 3] = "TypeConflictWithBaseClass";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["ParentIsIncompatible"] = 4] = "ParentIsIncompatible";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["SpyOnThatOverwritesField"] = 5] = "SpyOnThatOverwritesField";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["PotentiallyNarrowedInTemplateButNoSupportYet"] = 6] = "PotentiallyNarrowedInTemplateButNoSupportYet";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalInput__RequiredButNoGoodExplicitTypeExtractable"] = 7] = "SignalInput__RequiredButNoGoodExplicitTypeExtractable";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable"] = 8] = "SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["WriteAssignment"] = 9] = "WriteAssignment";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["Accessor"] = 10] = "Accessor";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["OutsideOfMigrationScope"] = 11] = "OutsideOfMigrationScope";
+    FieldIncompatibilityReason[FieldIncompatibilityReason["SkippedViaConfigFilter"] = 12] = "SkippedViaConfigFilter";
+})(exports.FieldIncompatibilityReason || (exports.FieldIncompatibilityReason = {}));
+/** Reasons why a whole class and its fields cannot be migrated. */
 exports.ClassIncompatibilityReason = void 0;
 (function (ClassIncompatibilityReason) {
     ClassIncompatibilityReason[ClassIncompatibilityReason["ClassManuallyInstantiated"] = 0] = "ClassManuallyInstantiated";
-    ClassIncompatibilityReason[ClassIncompatibilityReason["InputOwningClassReferencedInClassProperty"] = 1] = "InputOwningClassReferencedInClassProperty";
+    ClassIncompatibilityReason[ClassIncompatibilityReason["OwningClassReferencedInClassProperty"] = 1] = "OwningClassReferencedInClassProperty";
 })(exports.ClassIncompatibilityReason || (exports.ClassIncompatibilityReason = {}));
-/** Whether the given value refers to an input member incompatibility. */
-function isInputMemberIncompatibility(value) {
+/** Whether the given value refers to an field incompatibility. */
+function isFieldIncompatibility(value) {
     return (value.reason !== undefined &&
         value.context !== undefined &&
-        exports.InputIncompatibilityReason.hasOwnProperty(value.reason));
+        exports.FieldIncompatibilityReason.hasOwnProperty(value.reason));
 }
-/** Picks the more significant input compatibility. */
-function pickInputIncompatibility(a, b) {
+/** Picks the more significant field compatibility. */
+function pickFieldIncompatibility(a, b) {
     if (b === null) {
         return a;
     }
@@ -484,7 +484,7 @@ class SpyOnFieldPattern {
                 return;
             }
             this.fields.markFieldIncompatible(fieldTarget, {
-                reason: exports.InputIncompatibilityReason.SpyOnThatOverwritesField,
+                reason: exports.FieldIncompatibilityReason.SpyOnThatOverwritesField,
                 context: node,
             });
         }
@@ -551,7 +551,7 @@ function checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedTsAstVisi
                 if (derivedMembers.length === 0 && inherited === undefined) {
                     break problematicReferencesCheck;
                 }
-                fields.markClassIncompatible(inputClassSymbolsToClass.get(newTarget), exports.ClassIncompatibilityReason.InputOwningClassReferencedInClassProperty);
+                fields.markClassIncompatible(inputClassSymbolsToClass.get(newTarget), exports.ClassIncompatibilityReason.OwningClassReferencedInClassProperty);
             }
         }
     };
@@ -3232,6 +3232,10 @@ class Identifiers {
         name: 'ɵɵInputTransformsFeature',
         moduleName: CORE,
     }; }
+    static { this.ExternalStylesFeature = {
+        name: 'ɵɵExternalStylesFeature',
+        moduleName: CORE,
+    }; }
     static { this.listener = { name: 'ɵɵlistener', moduleName: CORE }; }
     static { this.getInheritedFactory = {
         name: 'ɵɵgetInheritedFactory',
@@ -6905,7 +6909,7 @@ class ShadowCss {
          *    captures how many (if any) leading whitespaces are present or a comma
          *  - (?:(?:(['"])((?:\\\\|\\\2|(?!\2).)+)\2)|(-?[A-Za-z][\w\-]*))
          *    captures two different possible keyframes, ones which are quoted or ones which are valid css
-         * idents (custom properties excluded)
+         * indents (custom properties excluded)
          *  - (?=[,\s;]|$)
          *    simply matches the end of the possible keyframe, valid endings are: a comma, a space, a
          * semicolon or the end of the string
@@ -7134,7 +7138,7 @@ class ShadowCss {
      */
     _scopeCssText(cssText, scopeSelector, hostSelector) {
         const unscopedRules = this._extractUnscopedRulesFromCssText(cssText);
-        // replace :host and :host-context -shadowcsshost and -shadowcsshost respectively
+        // replace :host and :host-context with -shadowcsshost and -shadowcsshostcontext respectively
         cssText = this._insertPolyfillHostInCssText(cssText);
         cssText = this._convertColonHost(cssText);
         cssText = this._convertColonHostContext(cssText);
@@ -7212,7 +7216,7 @@ class ShadowCss {
      * .foo<scopeName> .bar { ... }
      */
     _convertColonHostContext(cssText) {
-        return cssText.replace(_cssColonHostContextReGlobal, (selectorText) => {
+        return cssText.replace(_cssColonHostContextReGlobal, (selectorText, pseudoPrefix) => {
             // We have captured a selector that contains a `:host-context` rule.
             // For backward compatibility `:host-context` may contain a comma separated list of selectors.
             // Each context selector group will contain a list of host-context selectors that must match
@@ -7261,10 +7265,10 @@ class ShadowCss {
                 selectorText = match[2];
             }
             // The context selectors now must be combined with each other to capture all the possible
-            // selectors that `:host-context` can match. See `combineHostContextSelectors()` for more
+            // selectors that `:host-context` can match. See `_combineHostContextSelectors()` for more
             // info about how this is done.
             return contextSelectorGroups
-                .map((contextSelectors) => combineHostContextSelectors(contextSelectors, selectorText))
+                .map((contextSelectors) => _combineHostContextSelectors(contextSelectors, selectorText, pseudoPrefix))
                 .join(', ');
         });
     }
@@ -7281,7 +7285,12 @@ class ShadowCss {
             let selector = rule.selector;
             let content = rule.content;
             if (rule.selector[0] !== '@') {
-                selector = this._scopeSelector(rule.selector, scopeSelector, hostSelector);
+                selector = this._scopeSelector({
+                    selector,
+                    scopeSelector,
+                    hostSelector,
+                    isParentSelector: true,
+                });
             }
             else if (scopedAtRuleIdentifiers.some((atRule) => rule.selector.startsWith(atRule))) {
                 content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
@@ -7321,15 +7330,29 @@ class ShadowCss {
             return new CssRule(selector, rule.content);
         });
     }
-    _scopeSelector(selector, scopeSelector, hostSelector) {
+    // `isParentSelector` is used to distinguish the selectors which are coming from
+    // the initial selector string and any nested selectors, parsed recursively,
+    // for example `selector = 'a:where(.one)'` could be the parent, while recursive call
+    // would have `selector = '.one'`.
+    _scopeSelector({ selector, scopeSelector, hostSelector, isParentSelector = false, }) {
+        // Split the selector into independent parts by `,` (comma) unless
+        // comma is within parenthesis, for example `:is(.one, two)`.
+        // Negative lookup after comma allows not splitting inside nested parenthesis,
+        // up to three levels (((,))).
+        const selectorSplitRe = / ?,(?!(?:[^)(]*(?:\([^)(]*(?:\([^)(]*(?:\([^)(]*\)[^)(]*)*\)[^)(]*)*\)[^)(]*)*\))) ?/;
         return selector
-            .split(/ ?, ?/)
+            .split(selectorSplitRe)
             .map((part) => part.split(_shadowDeepSelectors))
             .map((deepParts) => {
             const [shallowPart, ...otherParts] = deepParts;
             const applyScope = (shallowPart) => {
                 if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
-                    return this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
+                    return this._applySelectorScope({
+                        selector: shallowPart,
+                        scopeSelector,
+                        hostSelector,
+                        isParentSelector,
+                    });
                 }
                 else {
                     return shallowPart;
@@ -7356,8 +7379,8 @@ class ShadowCss {
         if (_polyfillHostRe.test(selector)) {
             const replaceBy = `[${hostSelector}]`;
             return selector
-                .replace(_polyfillHostNoCombinatorRe, (hnc, selector) => {
-                return selector.replace(/([^:]*)(:*)(.*)/, (_, before, colon, after) => {
+                .replace(_polyfillHostNoCombinatorReGlobal, (_hnc, selector) => {
+                return selector.replace(/([^:\)]*)(:*)(.*)/, (_, before, colon, after) => {
                     return before + replaceBy + colon + after;
                 });
             })
@@ -7367,7 +7390,7 @@ class ShadowCss {
     }
     // return a selector with [name] suffix on each simple selector
     // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]  /** @internal */
-    _applySelectorScope(selector, scopeSelector, hostSelector) {
+    _applySelectorScope({ selector, scopeSelector, hostSelector, isParentSelector, }) {
         const isRe = /\[is=([^\]]*)\]/g;
         scopeSelector = scopeSelector.replace(isRe, (_, ...parts) => parts[0]);
         const attrName = '[' + scopeSelector + ']';
@@ -7378,6 +7401,10 @@ class ShadowCss {
             }
             if (p.includes(_polyfillHostNoCombinator)) {
                 scopedP = this._applySimpleSelectorScope(p, scopeSelector, hostSelector);
+                if (_polyfillHostNoCombinatorWithinPseudoFunction.test(p)) {
+                    const [_, before, colon, after] = scopedP.match(/([^:]*)(:*)(.*)/);
+                    scopedP = before + attrName + colon + after;
+                }
             }
             else {
                 // remove :host since it should be unnecessary
@@ -7391,12 +7418,50 @@ class ShadowCss {
             }
             return scopedP;
         };
-        const safeContent = new SafeSelector(selector);
-        selector = safeContent.content();
+        // Wraps `_scopeSelectorPart()` to not use it directly on selectors with
+        // pseudo selector functions like `:where()`. Selectors within pseudo selector
+        // functions are recursively sent to `_scopeSelector()`.
+        const _pseudoFunctionAwareScopeSelectorPart = (selectorPart) => {
+            let scopedPart = '';
+            const cssPrefixWithPseudoSelectorFunctionMatch = selectorPart.match(_cssPrefixWithPseudoSelectorFunction);
+            if (cssPrefixWithPseudoSelectorFunctionMatch) {
+                const [cssPseudoSelectorFunction] = cssPrefixWithPseudoSelectorFunctionMatch;
+                // Unwrap the pseudo selector to scope its contents.
+                // For example,
+                // - `:where(selectorToScope)` -> `selectorToScope`;
+                // - `:is(.foo, .bar)` -> `.foo, .bar`.
+                const selectorToScope = selectorPart.slice(cssPseudoSelectorFunction.length, -1);
+                if (selectorToScope.includes(_polyfillHostNoCombinator)) {
+                    this._shouldScopeIndicator = true;
+                }
+                const scopedInnerPart = this._scopeSelector({
+                    selector: selectorToScope,
+                    scopeSelector,
+                    hostSelector,
+                });
+                // Put the result back into the pseudo selector function.
+                scopedPart = `${cssPseudoSelectorFunction}${scopedInnerPart})`;
+            }
+            else {
+                this._shouldScopeIndicator =
+                    this._shouldScopeIndicator || selectorPart.includes(_polyfillHostNoCombinator);
+                scopedPart = this._shouldScopeIndicator ? _scopeSelectorPart(selectorPart) : selectorPart;
+            }
+            return scopedPart;
+        };
+        if (isParentSelector) {
+            this._safeSelector = new SafeSelector(selector);
+            selector = this._safeSelector.content();
+        }
         let scopedSelector = '';
         let startIndex = 0;
         let res;
-        const sep = /( |>|\+|~(?!=))\s*/g;
+        // Combinators aren't used as a delimiter if they are within parenthesis,
+        // for example `:where(.one .two)` stays intact.
+        // Similarly to selector separation by comma initially, negative lookahead
+        // is used here to not break selectors within nested parenthesis up to three
+        // nested layers.
+        const sep = /( |>|\+|~(?!=))(?!([^)(]*(?:\([^)(]*(?:\([^)(]*(?:\([^)(]*\)[^)(]*)*\)[^)(]*)*\)[^)(]*)*\)))\s*/g;
         // If a selector appears before :host it should not be shimmed as it
         // matches on ancestor elements and not on elements in the host's shadow
         // `:host-context(div)` is transformed to
@@ -7409,8 +7474,13 @@ class ShadowCss {
         // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
         //   `:host-context(tag)`)
         const hasHost = selector.includes(_polyfillHostNoCombinator);
-        // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
-        let shouldScope = !hasHost;
+        // Only scope parts after or on the same level as the first `-shadowcsshost-no-combinator`
+        // when it is present. The selector has the same level when it is a part of a pseudo
+        // selector, like `:where()`, for example `:where(:host, .foo)` would result in `.foo`
+        // being scoped.
+        if (isParentSelector || this._shouldScopeIndicator) {
+            this._shouldScopeIndicator = !hasHost;
+        }
         while ((res = sep.exec(selector)) !== null) {
             const separator = res[1];
             // Do not trim the selector, as otherwise this will break sourcemaps
@@ -7426,16 +7496,15 @@ class ShadowCss {
             if (part.match(/__esc-ph-(\d+)__/) && selector[res.index + 1]?.match(/[a-fA-F\d]/)) {
                 continue;
             }
-            shouldScope = shouldScope || part.includes(_polyfillHostNoCombinator);
-            const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
+            const scopedPart = _pseudoFunctionAwareScopeSelectorPart(part);
             scopedSelector += `${scopedPart} ${separator} `;
             startIndex = sep.lastIndex;
         }
         const part = selector.substring(startIndex);
-        shouldScope = shouldScope || part.includes(_polyfillHostNoCombinator);
-        scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
+        scopedSelector += _pseudoFunctionAwareScopeSelectorPart(part);
         // replace the placeholders with their original values
-        return safeContent.restore(scopedSelector);
+        // using values stored inside the `safeSelector` instance.
+        return this._safeSelector.restore(scopedSelector);
     }
     _insertPolyfillHostInCssText(selector) {
         return selector
@@ -7490,6 +7559,8 @@ class SafeSelector {
         });
     }
 }
+const _cssScopedPseudoFunctionPrefix = '(:(where|is)\\()?';
+const _cssPrefixWithPseudoSelectorFunction = /^:(where|is)\(/i;
 const _cssContentNextSelectorRe = /polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim;
 const _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
 const _cssContentUnscopedRuleRe = /(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
@@ -7498,10 +7569,12 @@ const _polyfillHost = '-shadowcsshost';
 const _polyfillHostContext = '-shadowcsscontext';
 const _parenSuffix = '(?:\\((' + '(?:\\([^)(]*\\)|[^)(]*)+?' + ')\\))?([^,{]*)';
 const _cssColonHostRe = new RegExp(_polyfillHost + _parenSuffix, 'gim');
-const _cssColonHostContextReGlobal = new RegExp(_polyfillHostContext + _parenSuffix, 'gim');
+const _cssColonHostContextReGlobal = new RegExp(_cssScopedPseudoFunctionPrefix + '(' + _polyfillHostContext + _parenSuffix + ')', 'gim');
 const _cssColonHostContextRe = new RegExp(_polyfillHostContext + _parenSuffix, 'im');
 const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
+const _polyfillHostNoCombinatorWithinPseudoFunction = new RegExp(`:.*\\(.*${_polyfillHostNoCombinator}.*\\)`);
 const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
+const _polyfillHostNoCombinatorReGlobal = new RegExp(_polyfillHostNoCombinatorRe, 'g');
 const _shadowDOMSelectorsRe = [
     /::shadow/g,
     /::content/g,
@@ -7735,7 +7808,7 @@ function unescapeQuotes(str, isQuoted) {
  * @param contextSelectors an array of context selectors that will be combined.
  * @param otherSelectors the rest of the selectors that are not context selectors.
  */
-function combineHostContextSelectors(contextSelectors, otherSelectors) {
+function _combineHostContextSelectors(contextSelectors, otherSelectors, pseudoPrefix = '') {
     const hostMarker = _polyfillHostNoCombinator;
     _polyfillHostRe.lastIndex = 0; // reset the regex to ensure we get an accurate test
     const otherSelectorsHasHost = _polyfillHostRe.test(otherSelectors);
@@ -7761,8 +7834,8 @@ function combineHostContextSelectors(contextSelectors, otherSelectors) {
     // (A<hostMarker>) or as an ancestor (A <hostMarker>).
     return combined
         .map((s) => otherSelectorsHasHost
-        ? `${s}${otherSelectors}`
-        : `${s}${hostMarker}${otherSelectors}, ${s} ${hostMarker}${otherSelectors}`)
+        ? `${pseudoPrefix}${s}${otherSelectors}`
+        : `${pseudoPrefix}${s}${hostMarker}${otherSelectors}, ${pseudoPrefix}${s} ${hostMarker}${otherSelectors}`)
         .join(',');
 }
 /**
@@ -24613,29 +24686,9 @@ function convertAst(ast, job, baseSourceSpan) {
         return convertAst(ast.ast, job, baseSourceSpan);
     }
     else if (ast instanceof PropertyRead) {
-        const isThisReceiver = ast.receiver instanceof ThisReceiver;
         // Whether this is an implicit receiver, *excluding* explicit reads of `this`.
         const isImplicitReceiver = ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver);
-        // Whether the  name of the read is a node that should be never retain its explicit this
-        // receiver.
-        const isSpecialNode = ast.name === '$any' || ast.name === '$event';
-        // TODO: The most sensible condition here would be simply `isImplicitReceiver`, to convert only
-        // actual implicit `this` reads, and not explicit ones. However, TemplateDefinitionBuilder (and
-        // the Typecheck block!) both have the same bug, in which they also consider explicit `this`
-        // reads to be implicit. This causes problems when the explicit `this` read is inside a
-        // template with a context that also provides the variable name being read:
-        // ```
-        // <ng-template let-a>{{this.a}}</ng-template>
-        // ```
-        // The whole point of the explicit `this` was to access the class property, but TDB and the
-        // current TCB treat the read as implicit, and give you the context property instead!
-        //
-        // For now, we emulate this old behavior by aggressively converting explicit reads to to
-        // implicit reads, except for the special cases that TDB and the current TCB protect. However,
-        // it would be an improvement to fix this.
-        //
-        // See also the corresponding comment for the TCB, in `type_check_block.ts`.
-        if (isImplicitReceiver || (isThisReceiver && !isSpecialNode)) {
+        if (isImplicitReceiver) {
             return new LexicalReadExpr(ast.name);
         }
         else {
@@ -27484,6 +27537,10 @@ function addFeatures(definitionMap, meta) {
     if (meta.hasOwnProperty('template') && meta.isStandalone) {
         features.push(importExpr(Identifiers.StandaloneFeature));
     }
+    if ('externalStyles' in meta && meta.externalStyles?.length) {
+        const externalStyleNodes = meta.externalStyles.map((externalStyle) => literal(externalStyle));
+        features.push(importExpr(Identifiers.ExternalStylesFeature).callFn([literalArr(externalStyleNodes)]));
+    }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
     }
@@ -27559,6 +27616,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     if (meta.encapsulation === null) {
         meta.encapsulation = ViewEncapsulation.Emulated;
     }
+    let hasStyles = !!meta.externalStyles?.length;
     // e.g. `styles: [str1, str2]`
     if (meta.styles && meta.styles.length) {
         const styleValues = meta.encapsulation == ViewEncapsulation.Emulated
@@ -27571,10 +27629,11 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
             return result;
         }, []);
         if (styleNodes.length > 0) {
+            hasStyles = true;
             definitionMap.set('styles', literalArr(styleNodes));
         }
     }
-    else if (meta.encapsulation === ViewEncapsulation.Emulated) {
+    if (!hasStyles && meta.encapsulation === ViewEncapsulation.Emulated) {
         // If there is no style, don't generate css selectors on elements
         meta.encapsulation = ViewEncapsulation.None;
     }
@@ -28500,18 +28559,12 @@ class TemplateBinder extends RecursiveAstVisitor {
     maybeMap(ast, name) {
         // If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an
         // `AST` expression that maps to a `Variable` or `Reference`.
-        if (!(ast.receiver instanceof ImplicitReceiver)) {
+        if (!(ast.receiver instanceof ImplicitReceiver) || ast.receiver instanceof ThisReceiver) {
             return;
         }
         // Check whether the name exists in the current scope. If so, map it. Otherwise, the name is
         // probably a property on the top-level component context.
         const target = this.scope.lookup(name);
-        // It's not allowed to read template entities via `this`, however it previously worked by
-        // accident (see #55115). Since `@let` declarations are new, we can fix it from the beginning,
-        // whereas pre-existing template entities will be fixed in #55115.
-        if (target instanceof LetDeclaration$1 && ast.receiver instanceof ThisReceiver) {
-            return;
-        }
         if (target !== null) {
             this.bindings.set(ast, target);
         }
@@ -29368,7 +29421,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.0.0-next.8');
+new Version('19.0.0-next.9');
 
 var _VisitorMode;
 (function (_VisitorMode) {
@@ -29432,7 +29485,7 @@ function lookupPropertyAccess(checker, type, path, options = {}) {
  * that will be migrated to signal inputs.
  */
 class TemplateReferenceVisitor extends RecursiveVisitor {
-    constructor(typeChecker, templateTypeChecker, componentClass, knownFields) {
+    constructor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup) {
         super();
         this.result = [];
         /**
@@ -29443,7 +29496,7 @@ class TemplateReferenceVisitor extends RecursiveVisitor {
          */
         this.templateAttributeReferencedFields = null;
         this.seenKnownFieldsCount = new Map();
-        this.expressionVisitor = new TemplateExpressionReferenceVisitor(typeChecker, templateTypeChecker, componentClass, knownFields);
+        this.expressionVisitor = new TemplateExpressionReferenceVisitor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup);
     }
     checkExpressionForReferencedFields(activeNode, expressionNode) {
         const referencedFields = this.expressionVisitor.checkTemplateExpression(activeNode, expressionNode);
@@ -29559,15 +29612,17 @@ class TemplateReferenceVisitor extends RecursiveVisitor {
  * that will be migrated to signal inputs.
  */
 class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
-    constructor(typeChecker, templateTypeChecker, componentClass, knownFields) {
+    constructor(typeChecker, templateTypeChecker, componentClass, knownFields, fieldNamesToConsiderForReferenceLookup) {
         super();
         this.typeChecker = typeChecker;
         this.templateTypeChecker = templateTypeChecker;
         this.componentClass = componentClass;
         this.knownFields = knownFields;
+        this.fieldNamesToConsiderForReferenceLookup = fieldNamesToConsiderForReferenceLookup;
         this.activeTmplAstNode = null;
         this.detectedInputReferences = [];
         this.isInsideObjectShorthandExpression = false;
+        this.insideConditionalExpressionsWithReads = [];
     }
     /** Checks the given AST expression. */
     checkTemplateExpression(activeNode, expressionNode) {
@@ -29601,11 +29656,22 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
         this._inspectPropertyAccess(ast, context);
         super.visitPropertyWrite(ast, context);
     }
+    visitConditional(ast, context) {
+        this.visit(ast.condition, context);
+        this.insideConditionalExpressionsWithReads.push(ast.condition);
+        this.visit(ast.trueExp, context);
+        this.visit(ast.falseExp, context);
+        this.insideConditionalExpressionsWithReads.pop();
+    }
     /**
      * Inspects the property access and attempts to resolve whether they access
      * a known field. If so, the result is captured.
      */
     _inspectPropertyAccess(ast, astPath) {
+        if (this.fieldNamesToConsiderForReferenceLookup !== null &&
+            !this.fieldNamesToConsiderForReferenceLookup.has(ast.name)) {
+            return;
+        }
         const isWrite = !!(ast instanceof PropertyWrite ||
             (this.activeTmplAstNode && isTwoWayBindingNode(this.activeTmplAstNode)));
         this._checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) ||
@@ -29637,7 +29703,7 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
             read: ast,
             readAstPath: astPath,
             context: this.activeTmplAstNode,
-            isLikelyNarrowed: false,
+            isLikelyNarrowed: this._isPartOfNarrowingTernary(ast),
             isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
             isWrite,
         });
@@ -29675,11 +29741,19 @@ class TemplateExpressionReferenceVisitor extends RecursiveAstVisitor {
             read: ast,
             readAstPath: astPath,
             context: this.activeTmplAstNode,
-            isLikelyNarrowed: false,
+            isLikelyNarrowed: this._isPartOfNarrowingTernary(ast),
             isObjectShorthandExpression: this.isInsideObjectShorthandExpression,
             isWrite,
         });
     }
+    _isPartOfNarrowingTernary(read) {
+        // Note: We do not safe check that the reads are fully matching 1:1. This is acceptable
+        // as worst case we just skip an input from being migrated. This is very unlikely too.
+        return this.insideConditionalExpressionsWithReads.some((r) => (r instanceof PropertyRead ||
+            r instanceof PropertyWrite ||
+            r instanceof SafePropertyRead) &&
+            r.name === read.name);
+    }
 }
 /**
  * Emulates an access to a given field using the TypeScript `ts.Type`
@@ -29740,7 +29814,7 @@ function isTsClassTypeReference(ref) {
  * Checks host bindings of the given class and tracks all
  * references to inputs within bindings.
  */
-function identifyHostBindingReferences(node, programInfo, checker$1, reflector, result, knownFields) {
+function identifyHostBindingReferences(node, programInfo, checker$1, reflector, result, knownFields, fieldNamesToConsiderForReferenceLookup) {
     if (node.name === undefined) {
         return;
     }
@@ -29786,7 +29860,7 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
     }
     const hostMap = checker.reflectObjectLiteral(hostField);
     const expressionResult = [];
-    const expressionVisitor = new TemplateExpressionReferenceVisitor(checker$1, null, node, knownFields);
+    const expressionVisitor = new TemplateExpressionReferenceVisitor(checker$1, null, node, knownFields, fieldNamesToConsiderForReferenceLookup);
     for (const [rawName, expression] of hostMap.entries()) {
         if (!ts__default["default"].isStringLiteralLike(expression)) {
             continue;
@@ -29898,14 +29972,14 @@ function attemptExtractTemplateDefinition(node, checker$1, reflector, resourceLo
  * Checks whether the given class has an Angular template, and resolves
  * all of the references to inputs.
  */
-function identifyTemplateReferences(programInfo, node, reflector, checker$1, evaluator, templateTypeChecker, resourceLoader, options, result, knownFields) {
-    const template = templateTypeChecker.getTemplate(node) ??
+function identifyTemplateReferences(programInfo, node, reflector, checker$1, evaluator, templateTypeChecker, resourceLoader, options, result, knownFields, fieldNamesToConsiderForReferenceLookup) {
+    const template = templateTypeChecker.getTemplate(node, checker.OptimizeFor.WholeProgram) ??
         // If there is no template registered in the TCB or compiler, the template may
         // be skipped due to an explicit `jit: true` setting. We try to detect this case
         // and parse the template manually.
         extractTemplateWithoutCompilerAnalysis(node, checker$1, reflector, resourceLoader, evaluator, options);
     if (template !== null) {
-        const visitor = new TemplateReferenceVisitor(checker$1, templateTypeChecker, node, knownFields);
+        const visitor = new TemplateReferenceVisitor(checker$1, templateTypeChecker, node, knownFields, fieldNamesToConsiderForReferenceLookup);
         template.forEach((node) => node.visit(visitor));
         for (const res of visitor.result) {
             const templateFilePath = res.context.sourceSpan.start.file.url;
@@ -29915,7 +29989,7 @@ function identifyTemplateReferences(programInfo, node, reflector, checker$1, eva
             // as those cannot be migrated, but print an error for now.
             if (templateFilePath === '') {
                 // TODO: Incorporate a TODO potentially.
-                console.error(`Found reference to input ${res.targetField.key} that cannot be ` +
+                console.error(`Found reference to field ${res.targetField.key} that cannot be ` +
                     `migrated because the template cannot be parsed with source map information ` +
                     `(in file: ${node.getSourceFile().fileName}).`);
                 continue;
@@ -30100,8 +30174,10 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
     if (targetInput === null) {
         return;
     }
-    const accessParent = unwrapParent(traverseAccess(node).parent);
+    const access = unwrapParent(traverseAccess(node));
+    const accessParent = access.parent;
     const isWriteReference = ts__default["default"].isBinaryExpression(accessParent) &&
+        accessParent.left === access &&
         writeBinaryOperators.includes(accessParent.operatorToken.kind);
     // track accesses from source files to known fields.
     result.references.push({
@@ -30144,10 +30220,10 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
     const visitor = (node) => {
         let lastTime = currentTimeInMs();
         if (ts__default["default"].isClassDeclaration(node)) {
-            identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, programInfo.userOptions, result, knownFields);
+            identifyTemplateReferences(programInfo, node, reflector, checker, evaluator, templateTypeChecker, resourceLoader, programInfo.userOptions, result, knownFields, fieldNamesToConsiderForReferenceLookup);
             perfCounters.template += (currentTimeInMs() - lastTime) / 1000;
             lastTime = currentTimeInMs();
-            identifyHostBindingReferences(node, programInfo, checker, reflector, result, knownFields);
+            identifyHostBindingReferences(node, programInfo, checker, reflector, result, knownFields, fieldNamesToConsiderForReferenceLookup);
             perfCounters.hostBindings += (currentTimeInMs() - lastTime) / 1000;
             lastTime = currentTimeInMs();
         }
@@ -30351,6 +30427,7 @@ class GroupedTsAstVisitor {
         for (const doneFn of this.doneFns) {
             doneFn();
         }
+        this.visitors = [];
     }
 }
 
@@ -30509,6 +30586,8 @@ function isNodeDescendantOf(node, ancestor) {
     return false;
 }
 
+/** Symbol that can be used to mark a variable as reserved, synthetically. */
+const ReservedMarker = Symbol();
 /**
  * Gets whether the given identifier name is free for use in the
  * given location, avoiding shadowed variable names.
@@ -30554,8 +30633,8 @@ function isIdentifierFreeInContainer(name, container) {
     // Note: This check is similar to the check by the TypeScript emitter.
     // typescript/stable/src/compiler/emitter.ts;l=5436;rcl=651008033
     const local = container.locals.get(name);
-    return !(local.flags &
-        (ts__default["default"].SymbolFlags.Value | ts__default["default"].SymbolFlags.ExportValue | ts__default["default"].SymbolFlags.Alias));
+    return (local !== ReservedMarker &&
+        !(local.flags & (ts__default["default"].SymbolFlags.Value | ts__default["default"].SymbolFlags.ExportValue | ts__default["default"].SymbolFlags.Alias)));
 }
 /**
  * Whether the given node can contain local variables.
@@ -30619,7 +30698,8 @@ class UniqueNamesGenerator {
                 return false;
             }
             // Claim the locals to avoid conflicts with future generations.
-            freeInfo.container.locals?.set(name, null);
+            freeInfo.container.locals ??= new Map();
+            freeInfo.container.locals.set(name, ReservedMarker);
             return true;
         };
         // Check the base name. Ideally, we'd use this one.
@@ -31261,6 +31341,52 @@ function migrateTypeScriptReferences(host, references, checker, info) {
     migrateStandardTsReference(tsReferencesWithNarrowing, checker, info, host.replacements);
 }
 
+/**
+ * Migrates TypeScript "ts.Type" references. E.g.
+
+ *  - `Partial<MyComp>` will be converted to `UnwrapSignalInputs<Partial<MyComp>>`.
+      in Catalyst test files.
+ */
+function migrateTypeScriptTypeReferences(host, references, importManager, info) {
+    const seenTypeNodes = new WeakSet();
+    for (const reference of references) {
+        // This pass only deals with TS input class type references.
+        if (!isTsClassTypeReference(reference)) {
+            continue;
+        }
+        // Skip references to classes that are not fully migrated.
+        if (!host.shouldMigrateReferencesToClass(reference.target)) {
+            continue;
+        }
+        // Skip duplicate references. E.g. in batching.
+        if (seenTypeNodes.has(reference.from.node)) {
+            continue;
+        }
+        seenTypeNodes.add(reference.from.node);
+        if (reference.isPartialReference && reference.isPartOfCatalystFile) {
+            assert__default["default"](reference.from.node.typeArguments, 'Expected type arguments for partial reference.');
+            assert__default["default"](reference.from.node.typeArguments.length === 1, 'Expected an argument for reference.');
+            const firstArg = reference.from.node.typeArguments[0];
+            const sf = firstArg.getSourceFile();
+            // Naive detection of the import. Sufficient for this test file migration.
+            const catalystImport = sf.text.includes('google3/javascript/angular2/testing/catalyst/fake_async')
+                ? 'google3/javascript/angular2/testing/catalyst/fake_async'
+                : 'google3/javascript/angular2/testing/catalyst/async';
+            const unwrapImportExpr = importManager.addImport({
+                exportModuleSpecifier: catalystImport,
+                exportSymbolName: 'UnwrapSignalInputs',
+                requestedFile: sf,
+            });
+            host.replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
+                position: firstArg.getStart(),
+                end: firstArg.getStart(),
+                toInsert: `${host.printer.printNode(ts__default["default"].EmitHint.Unspecified, unwrapImportExpr, sf)}<`,
+            })));
+            host.replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({ position: firstArg.getEnd(), end: firstArg.getEnd(), toInsert: '>' })));
+        }
+    }
+}
+
 /**
  * Angular compiler file system implementation that leverages an
  * CLI schematic virtual file tree.
@@ -31288,7 +31414,7 @@ class DevkitMigrationFilesystem {
         return this.normalize(core.relative(from, to));
     }
     basename(filePath, extension) {
-        return path__namespace.basename(filePath, extension);
+        return posixPath__namespace.basename(filePath, extension);
     }
     normalize(path) {
         return core.normalize(path);
@@ -31297,7 +31423,7 @@ class DevkitMigrationFilesystem {
         const normalizedPaths = paths.map((p) => core.normalize(p));
         // In dev-kit, the NodeJS working directory should never be
         // considered, so `/` is the last resort over `cwd`.
-        return this.normalize(path__namespace.resolve(core.normalize('/'), ...normalizedPaths));
+        return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
     }
     pwd() {
         return '/';
@@ -31432,14 +31558,14 @@ exports.confirmAsSerializable = confirmAsSerializable;
 exports.createFindAllSourceFileReferencesVisitor = createFindAllSourceFileReferencesVisitor;
 exports.createNgtscProgram = createNgtscProgram;
 exports.groupReplacementsByFile = groupReplacementsByFile;
+exports.isFieldIncompatibility = isFieldIncompatibility;
 exports.isHostBindingReference = isHostBindingReference;
 exports.isInputContainerNode = isInputContainerNode;
-exports.isInputMemberIncompatibility = isInputMemberIncompatibility;
 exports.isTemplateReference = isTemplateReference;
-exports.isTsClassTypeReference = isTsClassTypeReference;
 exports.isTsReference = isTsReference;
 exports.migrateTypeScriptReferences = migrateTypeScriptReferences;
-exports.pickInputIncompatibility = pickInputIncompatibility;
+exports.migrateTypeScriptTypeReferences = migrateTypeScriptTypeReferences;
+exports.pickFieldIncompatibility = pickFieldIncompatibility;
 exports.projectFile = projectFile;
 exports.removeFromUnionIfPossible = removeFromUnionIfPossible;
 exports.traverseAccess = traverseAccess;