@angular/core 20.1.0-rc.0 → 20.2.0-next.0

package/schematics/bundles/{index-CmuNlSML.cjs → index-BmuUS1AB.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 /**
- * @license Angular v20.1.0-rc.0
+ * @license Angular v20.2.0-next.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var checker = require('./checker-CwuJOWZI.cjs');
+var checker = require('./checker-DLInMAS3.cjs');
 var ts = require('typescript');
 var p = require('path');
 require('os');
@@ -891,7 +891,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -909,7 +909,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
     callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? checker.literal(null));
     callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? checker.literal(null));
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -1004,7 +1004,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', checker.literal(minVersion));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -1420,7 +1420,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -1455,7 +1455,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -1506,7 +1506,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -1539,7 +1539,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -1590,7 +1590,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new checker.DefinitionMap();
     definitionMap.set('minVersion', checker.literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', checker.literal('20.1.0-rc.0'));
+    definitionMap.set('version', checker.literal('20.2.0-next.0'));
     definitionMap.set('ngImport', checker.importExpr(checker.Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -2996,6 +2996,790 @@ function resolveOutput(bindingName) {
     return bindingName;
 }
 
+class ArraySliceBuiltinFn extends checker.KnownFn {
+    lhs;
+    constructor(lhs) {
+        super();
+        this.lhs = lhs;
+    }
+    evaluate(node, args) {
+        if (args.length === 0) {
+            return this.lhs;
+        }
+        else {
+            return checker.DynamicValue.fromUnknown(node);
+        }
+    }
+}
+class ArrayConcatBuiltinFn extends checker.KnownFn {
+    lhs;
+    constructor(lhs) {
+        super();
+        this.lhs = lhs;
+    }
+    evaluate(node, args) {
+        const result = [...this.lhs];
+        for (const arg of args) {
+            if (arg instanceof checker.DynamicValue) {
+                result.push(checker.DynamicValue.fromDynamicInput(node, arg));
+            }
+            else if (Array.isArray(arg)) {
+                result.push(...arg);
+            }
+            else {
+                result.push(arg);
+            }
+        }
+        return result;
+    }
+}
+class StringConcatBuiltinFn extends checker.KnownFn {
+    lhs;
+    constructor(lhs) {
+        super();
+        this.lhs = lhs;
+    }
+    evaluate(node, args) {
+        let result = this.lhs;
+        for (const arg of args) {
+            const resolved = arg instanceof checker.EnumValue ? arg.resolved : arg;
+            if (typeof resolved === 'string' ||
+                typeof resolved === 'number' ||
+                typeof resolved === 'boolean' ||
+                resolved == null) {
+                // Cast to `any`, because `concat` will convert
+                // anything to a string, but TS only allows strings.
+                result = result.concat(resolved);
+            }
+            else {
+                return checker.DynamicValue.fromUnknown(node);
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * A value produced which originated in a `ForeignFunctionResolver` and doesn't come from the
+ * template itself.
+ *
+ * Synthetic values cannot be further evaluated, and attempts to do so produce `DynamicValue`s
+ * instead.
+ */
+class SyntheticValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+
+function literalBinaryOp(op) {
+    return { op, literal: true };
+}
+function referenceBinaryOp(op) {
+    return { op, literal: false };
+}
+class StaticInterpreter {
+    host;
+    checker;
+    dependencyTracker;
+    BINARY_OPERATORS = new Map([
+        [ts.SyntaxKind.PlusToken, literalBinaryOp((a, b) => a + b)],
+        [ts.SyntaxKind.MinusToken, literalBinaryOp((a, b) => a - b)],
+        [ts.SyntaxKind.AsteriskToken, literalBinaryOp((a, b) => a * b)],
+        [ts.SyntaxKind.SlashToken, literalBinaryOp((a, b) => a / b)],
+        [ts.SyntaxKind.PercentToken, literalBinaryOp((a, b) => a % b)],
+        [ts.SyntaxKind.AmpersandToken, literalBinaryOp((a, b) => a & b)],
+        [ts.SyntaxKind.BarToken, literalBinaryOp((a, b) => a | b)],
+        [ts.SyntaxKind.CaretToken, literalBinaryOp((a, b) => a ^ b)],
+        [ts.SyntaxKind.LessThanToken, literalBinaryOp((a, b) => a < b)],
+        [ts.SyntaxKind.LessThanEqualsToken, literalBinaryOp((a, b) => a <= b)],
+        [ts.SyntaxKind.GreaterThanToken, literalBinaryOp((a, b) => a > b)],
+        [ts.SyntaxKind.GreaterThanEqualsToken, literalBinaryOp((a, b) => a >= b)],
+        [ts.SyntaxKind.EqualsEqualsToken, literalBinaryOp((a, b) => a == b)],
+        [ts.SyntaxKind.EqualsEqualsEqualsToken, literalBinaryOp((a, b) => a === b)],
+        [ts.SyntaxKind.ExclamationEqualsToken, literalBinaryOp((a, b) => a != b)],
+        [ts.SyntaxKind.ExclamationEqualsEqualsToken, literalBinaryOp((a, b) => a !== b)],
+        [ts.SyntaxKind.LessThanLessThanToken, literalBinaryOp((a, b) => a << b)],
+        [ts.SyntaxKind.GreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >> b)],
+        [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, literalBinaryOp((a, b) => a >>> b)],
+        [ts.SyntaxKind.AsteriskAsteriskToken, literalBinaryOp((a, b) => Math.pow(a, b))],
+        [ts.SyntaxKind.AmpersandAmpersandToken, referenceBinaryOp((a, b) => a && b)],
+        [ts.SyntaxKind.BarBarToken, referenceBinaryOp((a, b) => a || b)],
+    ]);
+    UNARY_OPERATORS = new Map([
+        [ts.SyntaxKind.TildeToken, (a) => ~a],
+        [ts.SyntaxKind.MinusToken, (a) => -a],
+        [ts.SyntaxKind.PlusToken, (a) => +a],
+        [ts.SyntaxKind.ExclamationToken, (a) => !a],
+    ]);
+    constructor(host, checker, dependencyTracker) {
+        this.host = host;
+        this.checker = checker;
+        this.dependencyTracker = dependencyTracker;
+    }
+    visit(node, context) {
+        return this.visitExpression(node, context);
+    }
+    visitExpression(node, context) {
+        let result;
+        if (node.kind === ts.SyntaxKind.TrueKeyword) {
+            return true;
+        }
+        else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+            return false;
+        }
+        else if (node.kind === ts.SyntaxKind.NullKeyword) {
+            return null;
+        }
+        else if (ts.isStringLiteral(node)) {
+            return node.text;
+        }
+        else if (ts.isNoSubstitutionTemplateLiteral(node)) {
+            return node.text;
+        }
+        else if (ts.isTemplateExpression(node)) {
+            result = this.visitTemplateExpression(node, context);
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return parseFloat(node.text);
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            result = this.visitObjectLiteralExpression(node, context);
+        }
+        else if (ts.isIdentifier(node)) {
+            result = this.visitIdentifier(node, context);
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            result = this.visitPropertyAccessExpression(node, context);
+        }
+        else if (ts.isCallExpression(node)) {
+            result = this.visitCallExpression(node, context);
+        }
+        else if (ts.isConditionalExpression(node)) {
+            result = this.visitConditionalExpression(node, context);
+        }
+        else if (ts.isPrefixUnaryExpression(node)) {
+            result = this.visitPrefixUnaryExpression(node, context);
+        }
+        else if (ts.isBinaryExpression(node)) {
+            result = this.visitBinaryExpression(node, context);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            result = this.visitArrayLiteralExpression(node, context);
+        }
+        else if (ts.isParenthesizedExpression(node)) {
+            result = this.visitParenthesizedExpression(node, context);
+        }
+        else if (ts.isElementAccessExpression(node)) {
+            result = this.visitElementAccessExpression(node, context);
+        }
+        else if (ts.isAsExpression(node)) {
+            result = this.visitExpression(node.expression, context);
+        }
+        else if (ts.isNonNullExpression(node)) {
+            result = this.visitExpression(node.expression, context);
+        }
+        else if (this.host.isClass(node)) {
+            result = this.visitDeclaration(node, context);
+        }
+        else {
+            return checker.DynamicValue.fromUnsupportedSyntax(node);
+        }
+        if (result instanceof checker.DynamicValue && result.node !== node) {
+            return checker.DynamicValue.fromDynamicInput(node, result);
+        }
+        return result;
+    }
+    visitArrayLiteralExpression(node, context) {
+        const array = [];
+        for (let i = 0; i < node.elements.length; i++) {
+            const element = node.elements[i];
+            if (ts.isSpreadElement(element)) {
+                array.push(...this.visitSpreadElement(element, context));
+            }
+            else {
+                array.push(this.visitExpression(element, context));
+            }
+        }
+        return array;
+    }
+    visitObjectLiteralExpression(node, context) {
+        const map = new Map();
+        for (let i = 0; i < node.properties.length; i++) {
+            const property = node.properties[i];
+            if (ts.isPropertyAssignment(property)) {
+                const name = this.stringNameFromPropertyName(property.name, context);
+                // Check whether the name can be determined statically.
+                if (name === undefined) {
+                    return checker.DynamicValue.fromDynamicInput(node, checker.DynamicValue.fromDynamicString(property.name));
+                }
+                map.set(name, this.visitExpression(property.initializer, context));
+            }
+            else if (ts.isShorthandPropertyAssignment(property)) {
+                const symbol = this.checker.getShorthandAssignmentValueSymbol(property);
+                if (symbol === undefined || symbol.valueDeclaration === undefined) {
+                    map.set(property.name.text, checker.DynamicValue.fromUnknown(property));
+                }
+                else {
+                    map.set(property.name.text, this.visitDeclaration(symbol.valueDeclaration, context));
+                }
+            }
+            else if (ts.isSpreadAssignment(property)) {
+                const spread = this.visitExpression(property.expression, context);
+                if (spread instanceof checker.DynamicValue) {
+                    return checker.DynamicValue.fromDynamicInput(node, spread);
+                }
+                else if (spread instanceof Map) {
+                    spread.forEach((value, key) => map.set(key, value));
+                }
+                else if (spread instanceof checker.ResolvedModule) {
+                    spread.getExports().forEach((value, key) => map.set(key, value));
+                }
+                else {
+                    return checker.DynamicValue.fromDynamicInput(node, checker.DynamicValue.fromInvalidExpressionType(property, spread));
+                }
+            }
+            else {
+                return checker.DynamicValue.fromUnknown(node);
+            }
+        }
+        return map;
+    }
+    visitTemplateExpression(node, context) {
+        const pieces = [node.head.text];
+        for (let i = 0; i < node.templateSpans.length; i++) {
+            const span = node.templateSpans[i];
+            const value = literal(this.visit(span.expression, context), () => checker.DynamicValue.fromDynamicString(span.expression));
+            if (value instanceof checker.DynamicValue) {
+                return checker.DynamicValue.fromDynamicInput(node, value);
+            }
+            pieces.push(`${value}`, span.literal.text);
+        }
+        return pieces.join('');
+    }
+    visitIdentifier(node, context) {
+        const decl = this.host.getDeclarationOfIdentifier(node);
+        if (decl === null) {
+            if (ts.identifierToKeywordKind(node) === ts.SyntaxKind.UndefinedKeyword) {
+                return undefined;
+            }
+            else {
+                // Check if the symbol here is imported.
+                if (this.dependencyTracker !== null && this.host.getImportOfIdentifier(node) !== null) {
+                    // It was, but no declaration for the node could be found. This means that the dependency
+                    // graph for the current file cannot be properly updated to account for this (broken)
+                    // import. Instead, the originating file is reported as failing dependency analysis,
+                    // ensuring that future compilations will always attempt to re-resolve the previously
+                    // broken identifier.
+                    this.dependencyTracker.recordDependencyAnalysisFailure(context.originatingFile);
+                }
+                return checker.DynamicValue.fromUnknownIdentifier(node);
+            }
+        }
+        const declContext = { ...context, ...joinModuleContext(context, node, decl) };
+        const result = this.visitDeclaration(decl.node, declContext);
+        if (result instanceof checker.Reference) {
+            // Only record identifiers to non-synthetic references. Synthetic references may not have the
+            // same value at runtime as they do at compile time, so it's not legal to refer to them by the
+            // identifier here.
+            if (!result.synthetic) {
+                result.addIdentifier(node);
+            }
+        }
+        else if (result instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, result);
+        }
+        return result;
+    }
+    visitDeclaration(node, context) {
+        if (this.dependencyTracker !== null) {
+            this.dependencyTracker.addDependency(context.originatingFile, node.getSourceFile());
+        }
+        if (this.host.isClass(node)) {
+            return this.getReference(node, context);
+        }
+        else if (ts.isVariableDeclaration(node)) {
+            return this.visitVariableDeclaration(node, context);
+        }
+        else if (ts.isParameter(node) && context.scope.has(node)) {
+            return context.scope.get(node);
+        }
+        else if (ts.isExportAssignment(node)) {
+            return this.visitExpression(node.expression, context);
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            return this.visitEnumDeclaration(node, context);
+        }
+        else if (ts.isSourceFile(node)) {
+            return this.visitSourceFile(node, context);
+        }
+        else if (ts.isBindingElement(node)) {
+            return this.visitBindingElement(node, context);
+        }
+        else {
+            return this.getReference(node, context);
+        }
+    }
+    visitVariableDeclaration(node, context) {
+        const value = this.host.getVariableValue(node);
+        if (value !== null) {
+            return this.visitExpression(value, context);
+        }
+        else if (isVariableDeclarationDeclared(node)) {
+            // If the declaration has a literal type that can be statically reduced to a value, resolve to
+            // that value. If not, the historical behavior for variable declarations is to return a
+            // `Reference` to the variable, as the consumer could use it in a context where knowing its
+            // static value is not necessary.
+            //
+            // Arguably, since the value cannot be statically determined, we should return a
+            // `DynamicValue`. This returns a `Reference` because it's the same behavior as before
+            // `visitType` was introduced.
+            //
+            // TODO(zarend): investigate switching to a `DynamicValue` and verify this won't break any
+            // use cases, especially in ngcc
+            if (node.type !== undefined) {
+                const evaluatedType = this.visitType(node.type, context);
+                if (!(evaluatedType instanceof checker.DynamicValue)) {
+                    return evaluatedType;
+                }
+            }
+            return this.getReference(node, context);
+        }
+        else {
+            return undefined;
+        }
+    }
+    visitEnumDeclaration(node, context) {
+        const enumRef = this.getReference(node, context);
+        const map = new Map();
+        node.members.forEach((member, index) => {
+            const name = this.stringNameFromPropertyName(member.name, context);
+            if (name !== undefined) {
+                const resolved = member.initializer ? this.visit(member.initializer, context) : index;
+                map.set(name, new checker.EnumValue(enumRef, name, resolved));
+            }
+        });
+        return map;
+    }
+    visitElementAccessExpression(node, context) {
+        const lhs = this.visitExpression(node.expression, context);
+        if (lhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, lhs);
+        }
+        const rhs = this.visitExpression(node.argumentExpression, context);
+        if (rhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, rhs);
+        }
+        if (typeof rhs !== 'string' && typeof rhs !== 'number') {
+            return checker.DynamicValue.fromInvalidExpressionType(node, rhs);
+        }
+        return this.accessHelper(node, lhs, rhs, context);
+    }
+    visitPropertyAccessExpression(node, context) {
+        const lhs = this.visitExpression(node.expression, context);
+        const rhs = node.name.text;
+        // TODO: handle reference to class declaration.
+        if (lhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, lhs);
+        }
+        return this.accessHelper(node, lhs, rhs, context);
+    }
+    visitSourceFile(node, context) {
+        const declarations = this.host.getExportsOfModule(node);
+        if (declarations === null) {
+            return checker.DynamicValue.fromUnknown(node);
+        }
+        return new checker.ResolvedModule(declarations, (decl) => {
+            const declContext = {
+                ...context,
+                ...joinModuleContext(context, node, decl),
+            };
+            // Visit both concrete and inline declarations.
+            return this.visitDeclaration(decl.node, declContext);
+        });
+    }
+    accessHelper(node, lhs, rhs, context) {
+        const strIndex = `${rhs}`;
+        if (lhs instanceof Map) {
+            if (lhs.has(strIndex)) {
+                return lhs.get(strIndex);
+            }
+            else {
+                return undefined;
+            }
+        }
+        else if (lhs instanceof checker.ResolvedModule) {
+            return lhs.getExport(strIndex);
+        }
+        else if (Array.isArray(lhs)) {
+            if (rhs === 'length') {
+                return lhs.length;
+            }
+            else if (rhs === 'slice') {
+                return new ArraySliceBuiltinFn(lhs);
+            }
+            else if (rhs === 'concat') {
+                return new ArrayConcatBuiltinFn(lhs);
+            }
+            if (typeof rhs !== 'number' || !Number.isInteger(rhs)) {
+                return checker.DynamicValue.fromInvalidExpressionType(node, rhs);
+            }
+            return lhs[rhs];
+        }
+        else if (typeof lhs === 'string' && rhs === 'concat') {
+            return new StringConcatBuiltinFn(lhs);
+        }
+        else if (lhs instanceof checker.Reference) {
+            const ref = lhs.node;
+            if (this.host.isClass(ref)) {
+                const module = owningModule(context, lhs.bestGuessOwningModule);
+                let value = undefined;
+                const member = this.host
+                    .getMembersOfClass(ref)
+                    .find((member) => member.isStatic && member.name === strIndex);
+                if (member !== undefined) {
+                    if (member.value !== null) {
+                        value = this.visitExpression(member.value, context);
+                    }
+                    else if (member.implementation !== null) {
+                        value = new checker.Reference(member.implementation, module);
+                    }
+                    else if (member.node) {
+                        value = new checker.Reference(member.node, module);
+                    }
+                }
+                return value;
+            }
+            else if (checker.isDeclaration(ref)) {
+                return checker.DynamicValue.fromDynamicInput(node, checker.DynamicValue.fromExternalReference(ref, lhs));
+            }
+        }
+        else if (lhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, lhs);
+        }
+        else if (lhs instanceof SyntheticValue) {
+            return checker.DynamicValue.fromSyntheticInput(node, lhs);
+        }
+        return checker.DynamicValue.fromUnknown(node);
+    }
+    visitCallExpression(node, context) {
+        const lhs = this.visitExpression(node.expression, context);
+        if (lhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, lhs);
+        }
+        // If the call refers to a builtin function, attempt to evaluate the function.
+        if (lhs instanceof checker.KnownFn) {
+            return lhs.evaluate(node, this.evaluateFunctionArguments(node, context));
+        }
+        if (!(lhs instanceof checker.Reference)) {
+            return checker.DynamicValue.fromInvalidExpressionType(node.expression, lhs);
+        }
+        const fn = this.host.getDefinitionOfFunction(lhs.node);
+        if (fn === null) {
+            return checker.DynamicValue.fromInvalidExpressionType(node.expression, lhs);
+        }
+        if (!isFunctionOrMethodReference(lhs)) {
+            return checker.DynamicValue.fromInvalidExpressionType(node.expression, lhs);
+        }
+        const resolveFfrExpr = (expr) => {
+            let contextExtension = {};
+            // TODO(alxhub): the condition `fn.body === null` here is vestigial - we probably _do_ want to
+            // change the context like this even for non-null function bodies. But, this is being
+            // redesigned as a refactoring with no behavior changes so that should be done as a follow-up.
+            if (fn.body === null &&
+                expr.getSourceFile() !== node.expression.getSourceFile() &&
+                lhs.bestGuessOwningModule !== null) {
+                contextExtension = {
+                    absoluteModuleName: lhs.bestGuessOwningModule.specifier,
+                    resolutionContext: lhs.bestGuessOwningModule.resolutionContext,
+                };
+            }
+            return this.visitFfrExpression(expr, { ...context, ...contextExtension });
+        };
+        // If the function is foreign (declared through a d.ts file), attempt to resolve it with the
+        // foreignFunctionResolver, if one is specified.
+        if (fn.body === null && context.foreignFunctionResolver !== undefined) {
+            const unresolvable = checker.DynamicValue.fromDynamicInput(node, checker.DynamicValue.fromExternalReference(node.expression, lhs));
+            return context.foreignFunctionResolver(lhs, node, resolveFfrExpr, unresolvable);
+        }
+        const res = this.visitFunctionBody(node, fn, context);
+        // If the result of attempting to resolve the function body was a DynamicValue, attempt to use
+        // the foreignFunctionResolver if one is present. This could still potentially yield a usable
+        // value.
+        if (res instanceof checker.DynamicValue && context.foreignFunctionResolver !== undefined) {
+            const unresolvable = checker.DynamicValue.fromComplexFunctionCall(node, fn);
+            return context.foreignFunctionResolver(lhs, node, resolveFfrExpr, unresolvable);
+        }
+        return res;
+    }
+    /**
+     * Visit an expression which was extracted from a foreign-function resolver.
+     *
+     * This will process the result and ensure it's correct for FFR-resolved values, including marking
+     * `Reference`s as synthetic.
+     */
+    visitFfrExpression(expr, context) {
+        const res = this.visitExpression(expr, context);
+        if (res instanceof checker.Reference) {
+            // This Reference was created synthetically, via a foreign function resolver. The real
+            // runtime value of the function expression may be different than the foreign function
+            // resolved value, so mark the Reference as synthetic to avoid it being misinterpreted.
+            res.synthetic = true;
+        }
+        return res;
+    }
+    visitFunctionBody(node, fn, context) {
+        if (fn.body === null) {
+            return checker.DynamicValue.fromUnknown(node);
+        }
+        else if (fn.body.length !== 1 || !ts.isReturnStatement(fn.body[0])) {
+            return checker.DynamicValue.fromComplexFunctionCall(node, fn);
+        }
+        const ret = fn.body[0];
+        const args = this.evaluateFunctionArguments(node, context);
+        const newScope = new Map();
+        const calleeContext = { ...context, scope: newScope };
+        fn.parameters.forEach((param, index) => {
+            let arg = args[index];
+            if (param.node.dotDotDotToken !== undefined) {
+                arg = args.slice(index);
+            }
+            if (arg === undefined && param.initializer !== null) {
+                arg = this.visitExpression(param.initializer, calleeContext);
+            }
+            newScope.set(param.node, arg);
+        });
+        return ret.expression !== undefined
+            ? this.visitExpression(ret.expression, calleeContext)
+            : undefined;
+    }
+    visitConditionalExpression(node, context) {
+        const condition = this.visitExpression(node.condition, context);
+        if (condition instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, condition);
+        }
+        if (condition) {
+            return this.visitExpression(node.whenTrue, context);
+        }
+        else {
+            return this.visitExpression(node.whenFalse, context);
+        }
+    }
+    visitPrefixUnaryExpression(node, context) {
+        const operatorKind = node.operator;
+        if (!this.UNARY_OPERATORS.has(operatorKind)) {
+            return checker.DynamicValue.fromUnsupportedSyntax(node);
+        }
+        const op = this.UNARY_OPERATORS.get(operatorKind);
+        const value = this.visitExpression(node.operand, context);
+        if (value instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, value);
+        }
+        else {
+            return op(value);
+        }
+    }
+    visitBinaryExpression(node, context) {
+        const tokenKind = node.operatorToken.kind;
+        if (!this.BINARY_OPERATORS.has(tokenKind)) {
+            return checker.DynamicValue.fromUnsupportedSyntax(node);
+        }
+        const opRecord = this.BINARY_OPERATORS.get(tokenKind);
+        let lhs, rhs;
+        if (opRecord.literal) {
+            lhs = literal(this.visitExpression(node.left, context), (value) => checker.DynamicValue.fromInvalidExpressionType(node.left, value));
+            rhs = literal(this.visitExpression(node.right, context), (value) => checker.DynamicValue.fromInvalidExpressionType(node.right, value));
+        }
+        else {
+            lhs = this.visitExpression(node.left, context);
+            rhs = this.visitExpression(node.right, context);
+        }
+        if (lhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, lhs);
+        }
+        else if (rhs instanceof checker.DynamicValue) {
+            return checker.DynamicValue.fromDynamicInput(node, rhs);
+        }
+        else {
+            return opRecord.op(lhs, rhs);
+        }
+    }
+    visitParenthesizedExpression(node, context) {
+        return this.visitExpression(node.expression, context);
+    }
+    evaluateFunctionArguments(node, context) {
+        const args = [];
+        for (const arg of node.arguments) {
+            if (ts.isSpreadElement(arg)) {
+                args.push(...this.visitSpreadElement(arg, context));
+            }
+            else {
+                args.push(this.visitExpression(arg, context));
+            }
+        }
+        return args;
+    }
+    visitSpreadElement(node, context) {
+        const spread = this.visitExpression(node.expression, context);
+        if (spread instanceof checker.DynamicValue) {
+            return [checker.DynamicValue.fromDynamicInput(node, spread)];
+        }
+        else if (!Array.isArray(spread)) {
+            return [checker.DynamicValue.fromInvalidExpressionType(node, spread)];
+        }
+        else {
+            return spread;
+        }
+    }
+    visitBindingElement(node, context) {
+        const path = [];
+        let closestDeclaration = node;
+        while (ts.isBindingElement(closestDeclaration) ||
+            ts.isArrayBindingPattern(closestDeclaration) ||
+            ts.isObjectBindingPattern(closestDeclaration)) {
+            if (ts.isBindingElement(closestDeclaration)) {
+                path.unshift(closestDeclaration);
+            }
+            closestDeclaration = closestDeclaration.parent;
+        }
+        if (!ts.isVariableDeclaration(closestDeclaration) ||
+            closestDeclaration.initializer === undefined) {
+            return checker.DynamicValue.fromUnknown(node);
+        }
+        let value = this.visit(closestDeclaration.initializer, context);
+        for (const element of path) {
+            let key;
+            if (ts.isArrayBindingPattern(element.parent)) {
+                key = element.parent.elements.indexOf(element);
+            }
+            else {
+                const name = element.propertyName || element.name;
+                if (ts.isIdentifier(name)) {
+                    key = name.text;
+                }
+                else {
+                    return checker.DynamicValue.fromUnknown(element);
+                }
+            }
+            value = this.accessHelper(element, value, key, context);
+            if (value instanceof checker.DynamicValue) {
+                return value;
+            }
+        }
+        return value;
+    }
+    stringNameFromPropertyName(node, context) {
+        if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) {
+            return node.text;
+        }
+        else if (ts.isComputedPropertyName(node)) {
+            const literal = this.visitExpression(node.expression, context);
+            return typeof literal === 'string' ? literal : undefined;
+        }
+        else {
+            return undefined;
+        }
+    }
+    getReference(node, context) {
+        return new checker.Reference(node, owningModule(context));
+    }
+    visitType(node, context) {
+        if (ts.isLiteralTypeNode(node)) {
+            return this.visitExpression(node.literal, context);
+        }
+        else if (ts.isTupleTypeNode(node)) {
+            return this.visitTupleType(node, context);
+        }
+        else if (ts.isNamedTupleMember(node)) {
+            return this.visitType(node.type, context);
+        }
+        else if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+            return this.visitType(node.type, context);
+        }
+        else if (ts.isTypeQueryNode(node)) {
+            return this.visitTypeQuery(node, context);
+        }
+        return checker.DynamicValue.fromDynamicType(node);
+    }
+    visitTupleType(node, context) {
+        const res = [];
+        for (const elem of node.elements) {
+            res.push(this.visitType(elem, context));
+        }
+        return res;
+    }
+    visitTypeQuery(node, context) {
+        if (!ts.isIdentifier(node.exprName)) {
+            return checker.DynamicValue.fromUnknown(node);
+        }
+        const decl = this.host.getDeclarationOfIdentifier(node.exprName);
+        if (decl === null) {
+            return checker.DynamicValue.fromUnknownIdentifier(node.exprName);
+        }
+        const declContext = { ...context, ...joinModuleContext(context, node, decl) };
+        return this.visitDeclaration(decl.node, declContext);
+    }
+}
+function isFunctionOrMethodReference(ref) {
+    return (ts.isFunctionDeclaration(ref.node) ||
+        ts.isMethodDeclaration(ref.node) ||
+        ts.isFunctionExpression(ref.node));
+}
+function literal(value, reject) {
+    if (value instanceof checker.EnumValue) {
+        value = value.resolved;
+    }
+    if (value instanceof checker.DynamicValue ||
+        value === null ||
+        value === undefined ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    return reject(value);
+}
+function isVariableDeclarationDeclared(node) {
+    if (node.parent === undefined || !ts.isVariableDeclarationList(node.parent)) {
+        return false;
+    }
+    const declList = node.parent;
+    if (declList.parent === undefined || !ts.isVariableStatement(declList.parent)) {
+        return false;
+    }
+    const varStmt = declList.parent;
+    const modifiers = ts.getModifiers(varStmt);
+    return (modifiers !== undefined && modifiers.some((mod) => mod.kind === ts.SyntaxKind.DeclareKeyword));
+}
+const EMPTY = {};
+function joinModuleContext(existing, node, decl) {
+    if (typeof decl.viaModule === 'string' && decl.viaModule !== existing.absoluteModuleName) {
+        return {
+            absoluteModuleName: decl.viaModule,
+            resolutionContext: node.getSourceFile().fileName,
+        };
+    }
+    else {
+        return EMPTY;
+    }
+}
+function owningModule(context, override = null) {
+    let specifier = context.absoluteModuleName;
+    if (override !== null) {
+        specifier = override.specifier;
+    }
+    if (specifier !== null) {
+        return {
+            specifier,
+            resolutionContext: context.resolutionContext,
+        };
+    }
+    else {
+        return null;
+    }
+}
+
 class PartialEvaluator {
     host;
     checker;
@@ -3006,7 +3790,7 @@ class PartialEvaluator {
         this.dependencyTracker = dependencyTracker;
     }
     evaluate(expr, foreignFunctionResolver) {
-        const interpreter = new checker.StaticInterpreter(this.host, this.checker, this.dependencyTracker);
+        const interpreter = new StaticInterpreter(this.host, this.checker, this.dependencyTracker);
         const sourceFile = expr.getSourceFile();
         return interpreter.visit(expr, {
             originatingFile: sourceFile,
@@ -7413,7 +8197,7 @@ function createModuleWithProvidersResolver(reflector, isCore) {
         if (!(ngModule instanceof checker.Reference) || !checker.isNamedClassDeclaration(ngModule.node)) {
             return unresolvable;
         }
-        return new checker.SyntheticValue({
+        return new SyntheticValue({
             ngModule: ngModule,
             mwpCall: callExpr,
         });
@@ -8168,7 +8952,7 @@ class NgModuleDecoratorHandler {
             let entry = resolvedList[idx];
             // Unwrap ModuleWithProviders for modules that are locally declared (and thus static
             // resolution was able to descend into the function and return an object literal, a Map).
-            if (entry instanceof checker.SyntheticValue && isResolvedModuleWithProviders(entry)) {
+            if (entry instanceof SyntheticValue && isResolvedModuleWithProviders(entry)) {
                 entry = entry.value.ngModule;
                 hasModuleWithProviders = true;
             }
@@ -8858,7 +9642,7 @@ function validateAndFlattenComponentImports(imports, expr, isDeferred) {
         }
         else if (isLikelyModuleWithProviders(ref)) {
             let origin = expr;
-            if (ref instanceof checker.SyntheticValue) {
+            if (ref instanceof SyntheticValue) {
                 // The `ModuleWithProviders` type originated from a foreign function declaration, in which
                 // case the original foreign call is available which is used to get a more accurate origin
                 // node that points at the specific call expression.
@@ -8901,7 +9685,7 @@ function validateAndFlattenComponentImports(imports, expr, isDeferred) {
  * key is considered a `ModuleWithProviders`.
  */
 function isLikelyModuleWithProviders(value) {
-    if (value instanceof checker.SyntheticValue && isResolvedModuleWithProviders(value)) {
+    if (value instanceof SyntheticValue && isResolvedModuleWithProviders(value)) {
         // This is a `ModuleWithProviders` as extracted from a foreign function call.
         return true;
     }
@@ -11537,7 +12321,7 @@ class PipeDecoratorHandler {
  * @description
  * Entry point for all public APIs of the compiler-cli package.
  */
-new checker.Version('20.1.0-rc.0');
+new checker.Version('20.2.0-next.0');
 
 /**
  * Whether a given decorator should be treated as an Angular decorator.
@@ -13444,11 +14228,18 @@ function extractLiteralPropertiesAsEnumMembers(declaration) {
 
 /** Extracts an API documentation entry for an Angular decorator. */
 function extractorDecorator(declaration, typeChecker) {
-    const documentedNode = getDecoratorJsDocNode(declaration);
+    const documentedNode = getDecoratorJsDocNode(declaration, typeChecker);
     const decoratorType = getDecoratorType(declaration);
     if (!decoratorType) {
         throw new Error(`"${declaration.name.getText()} is not a decorator."`);
     }
+    const members = getDecoratorProperties(declaration, typeChecker);
+    let signatures = [];
+    if (!members) {
+        const decoratorInterface = getDecoratorDeclaration(declaration, typeChecker);
+        const callSignatures = decoratorInterface.members.filter(ts.isCallSignatureDeclaration);
+        signatures = getDecoratorSignatures(callSignatures, typeChecker);
+    }
     return {
         name: declaration.name.getText(),
         decoratorType: decoratorType,
@@ -13456,7 +14247,8 @@ function extractorDecorator(declaration, typeChecker) {
         rawComment: extractRawJsDoc(documentedNode),
         description: extractJsDocDescription(documentedNode),
         jsdocTags: extractJsDocTags(documentedNode),
-        members: getDecoratorOptions(declaration, typeChecker),
+        members,
+        signatures,
     };
 }
 /** Gets whether the given variable declaration is an Angular decorator declaration. */
@@ -13483,35 +14275,77 @@ function getDecoratorType(declaration) {
         return DecoratorType.Parameter;
     return undefined;
 }
-/** Gets the doc entry for the options object for an Angular decorator */
-function getDecoratorOptions(declaration, typeChecker) {
-    const name = declaration.name.getText();
-    // Every decorator has an interface with its options in the same SourceFile.
-    // Queries, however, are defined as a type alias pointing to an interface.
-    const optionsDeclaration = declaration.getSourceFile().statements.find((node) => {
-        return ((ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) &&
-            node.name.getText() === name);
-    });
-    if (!optionsDeclaration) {
-        throw new Error(`Decorator "${name}" has no corresponding options interface.`);
+function getDecoratorDeclaration(declaration, typeChecker) {
+    const decoratorName = declaration.name.getText();
+    const decoratorDeclaration = declaration;
+    const decoratorType = typeChecker.getTypeAtLocation(decoratorDeclaration);
+    const aliasDeclaration = decoratorType.getSymbol().getDeclarations()[0];
+    const decoratorInterface = aliasDeclaration;
+    if (!decoratorInterface || !ts.isInterfaceDeclaration(decoratorInterface)) {
+        throw new Error(`No decorator interface found for "${decoratorName}".`);
     }
-    let optionsInterface;
-    if (ts.isTypeAliasDeclaration(optionsDeclaration)) {
-        // We hard-code the assumption that if the decorator's option type is a type alias,
-        // it resolves to a single interface (this is true for all query decorators at time of
-        // this writing).
-        const aliasedType = typeChecker.getTypeAtLocation(optionsDeclaration.type);
-        optionsInterface = (aliasedType.getSymbol()?.getDeclarations() ?? []).find((d) => ts.isInterfaceDeclaration(d));
+    return decoratorInterface;
+}
+/**
+ * @returns Interface properties for decorators that are akin to interfaces eg. @Component
+ * else return null for decorators that are akin to functions eg. @Inject
+ */
+function getDecoratorProperties(declaration, typeChecker) {
+    // Some decorators like Component, Directive are basically interchangeable with a interface declaration.
+    // We want to acount for that and treat them a such.
+    // To determine which type of decorator we have, we check the type of the first parameter of its call signature
+    const decoratorCallSig = getDecoratorJsDocNode(declaration, typeChecker);
+    const decoratorFirstParam = decoratorCallSig.parameters[0];
+    const firstParamType = typeChecker.getTypeAtLocation(decoratorFirstParam);
+    let firstParamTypeDecl;
+    if (firstParamType.isUnion()) {
+        // If the first param is a union, we need to get the first type
+        // This happens for example when the decorator param is optional (eg @Directive())
+        const firstParamTypeUnion = firstParamType.types.find((t) => (t.flags & ts.TypeFlags.Undefined) === 0);
+        firstParamTypeDecl = firstParamTypeUnion?.getSymbol()?.getDeclarations()[0];
     }
     else {
-        optionsInterface = optionsDeclaration;
+        firstParamTypeDecl = firstParamType.getSymbol()?.getDeclarations()[0];
     }
-    if (!optionsInterface || !ts.isInterfaceDeclaration(optionsInterface)) {
-        throw new Error(`Options for decorator "${name}" is not an interface.`);
+    if (!firstParamTypeDecl || !ts.isInterfaceDeclaration(firstParamTypeDecl)) {
+        // At this point we either have on first param, eg for decorators without parameters
+        // or we have a decorator that isn't akin to an interface
+        // We will threat them as functions (in another function) and return null here
+        return null;
     }
-    // Take advantage of the interface extractor to pull the appropriate member info.
-    // Hard code the knowledge that decorator options only have properties, never methods.
-    return extractInterface(optionsInterface, typeChecker).members;
+    const interfaceDeclaration = firstParamTypeDecl;
+    return extractInterface(interfaceDeclaration, typeChecker).members;
+}
+function getDecoratorSignatures(callSignatures, typeChecker) {
+    return callSignatures.map((signatureDecl) => {
+        return {
+            parameters: extractParams(signatureDecl.parameters, typeChecker),
+            jsdocTags: extractJsDocTags(signatureDecl),
+        };
+    });
+}
+function extractParams(params, typeChecker) {
+    return params.map((param) => ({
+        name: param.name.getText(),
+        description: extractJsDocDescription(param),
+        type: getParamTypeString(param, typeChecker),
+        isOptional: !!(param.questionToken || param.initializer),
+        isRestParam: !!param.dotDotDotToken,
+    }));
+}
+/**
+ * Find the the interface usually suffixed with "Decorator" that describes the decorator.
+ */
+function getDecoratorInterface(declaration, typeChecker) {
+    const name = declaration.name.getText();
+    const symbol = typeChecker.getSymbolAtLocation(declaration.name);
+    const decoratorType = typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+    // This is the interface xxxxDecorator
+    const decoratorInterface = decoratorType.getSymbol()?.getDeclarations()[0];
+    if (!decoratorInterface || !ts.isInterfaceDeclaration(decoratorInterface)) {
+        throw new Error(`No decorator interface found for "${name}".`);
+    }
+    return decoratorInterface;
 }
 /**
  * Gets the call signature node that has the decorator's public JsDoc block.
@@ -13523,26 +14357,68 @@ function getDecoratorOptions(declaration, typeChecker) {
  *
  * For the description and JsDoc tags, we need the interface suffixed with "Decorator".
  */
-function getDecoratorJsDocNode(declaration) {
+function getDecoratorJsDocNode(declaration, typeChecker) {
     const name = declaration.name.getText();
-    // Assume the existence of an interface in the same file with the same name
-    // suffixed with "Decorator".
-    const decoratorInterface = declaration.getSourceFile().statements.find((s) => {
-        return ts.isInterfaceDeclaration(s) && s.name.getText() === `${name}Decorator`;
-    });
-    if (!decoratorInterface || !ts.isInterfaceDeclaration(decoratorInterface)) {
-        throw new Error(`No interface "${name}Decorator" found.`);
-    }
+    const decoratorInterface = getDecoratorInterface(declaration, typeChecker);
     // The public-facing JsDoc for each decorator is on one of its interface's call signatures.
-    const callSignature = decoratorInterface.members.find((node) => {
+    const callSignature = decoratorInterface.members
+        .filter((node) => {
         // The description block lives on one of the call signatures for this interface.
         return ts.isCallSignatureDeclaration(node) && extractRawJsDoc(node);
-    });
+    })
+        .at(-1); // Get the last one, as it is the most complete
     if (!callSignature || !ts.isCallSignatureDeclaration(callSignature)) {
         throw new Error(`No call signature with JsDoc on "${name}Decorator"`);
     }
     return callSignature;
 }
+/**
+ * Advanced function to generate the type string (as single line) for a parameter.
+ * Interfaces in unions are expanded.
+ */
+function getParamTypeString(paramNode, typeChecker) {
+    const type = typeChecker.getTypeAtLocation(paramNode);
+    const printer = ts.createPrinter({ removeComments: true });
+    const sourceFile = paramNode.getSourceFile();
+    const replace = [];
+    if (type.isUnion()) {
+        // The parameter can be a union, this includes optional parameters whiceh are a union of the type and undefined.
+        for (const subType of type.types) {
+            const decl = subType.getSymbol()?.getDeclarations()?.[0];
+            // We only care to expand interfaces
+            if (decl && ts.isInterfaceDeclaration(decl) && decl.name.text !== 'Function') {
+                // the Function type is actually an interface but we don't want to expand it
+                replace.push({
+                    initial: subType.symbol.name,
+                    replacedWith: expandType(decl, sourceFile, printer),
+                });
+            }
+        }
+    }
+    // Using a print here instead of typeToString as it doesn't return optional props as a union of undefined
+    let result = printer
+        .printNode(ts.EmitHint.Unspecified, paramNode, sourceFile)
+        // Removing the parameter name, the conditional question mark and the colon (e.g. opts?: {foo: string})
+        .replace(new RegExp(`${paramNode.name.getText()}\\??\: `), '')
+        // Remove extra spaces/line breaks
+        .replaceAll(/\s+/g, ' ');
+    // Replace the types we expanded
+    for (const { initial, replacedWith } of replace) {
+        result = result.replace(initial, replacedWith);
+    }
+    return result;
+}
+/**
+ * @return a given interface declaration as single line string
+ */
+function expandType(decl, sourceFile, printer) {
+    const props = decl.members
+        // printer will return each member with a semicolon at the end
+        .map((member) => printer.printNode(ts.EmitHint.Unspecified, member, sourceFile))
+        .join(' ')
+        .replaceAll(/\s+/g, ' '); // Remove extra spaces/line breaks
+    return `{${props}}`;
+}
 
 /** Extracts documentation entry for an enum. */
 function extractEnum(declaration, typeChecker) {
@@ -19402,7 +20278,7 @@ var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
  * @param minVersion Minimum required version for the feature.
  */
 function coreVersionSupportsFeature(coreVersion, minVersion) {
-    // A version of `20.1.0-rc.0` usually means that core is at head so it supports
+    // A version of `20.2.0-next.0` usually means that core is at head so it supports
     // all features. Use string interpolation prevent the placeholder from being replaced
     // with the current version during build time.
     if (coreVersion === `0.0.0-${'PLACEHOLDER'}`) {