@angular/core 22.0.0-next.10 → 22.0.0-next.11

package/schematics/migrations.json

@@ -34,6 +34,11 @@
       "version": "22.0.0",
       "description": "Migrate broken duplicate outputs",
       "factory": "./bundles/model-output.cjs#migrate"
+    },
+    "safe-optional-chaining": {
+      "version": "22.0.0",
+      "description": "Wraps optional chaining expressions in $safeNavigationMigration().",
+      "factory": "./bundles/safe-optional-chaining.cjs#migrate"
     }
   }
 }

package/third_party/@mcp-b/webmcp-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mcp-b contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/third_party/@mcp-b/webmcp-types/dist/common.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Primitive JSON value.
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * Object-shaped JSON value.
+ */
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+/**
+ * Any valid JSON value.
+ */
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+/**
+ * JSON Schema property definition.
+ *
+ * @see {@link https://json-schema.org/}
+ */
+export interface InputSchemaProperty {
+    /**
+     * JSON Schema type for this property.
+     */
+    type?: string;
+    /**
+     * Human-readable description of the property.
+     */
+    description?: string;
+    /**
+     * Additional JSON Schema keywords.
+     */
+    [key: string]: unknown;
+}
+/**
+ * JSON Schema definition for tool input parameters.
+ *
+ * @see {@link https://json-schema.org/}
+ */
+export interface InputSchema {
+    /**
+     * JSON Schema type for the root value (usually `'object'` for tool args).
+     */
+    type?: string;
+    /**
+     * Property definitions for object schemas.
+     */
+    properties?: Record<string, InputSchemaProperty>;
+    /**
+     * List of required property names.
+     */
+    required?: readonly string[];
+    /**
+     * Additional JSON Schema keywords.
+     */
+    [key: string]: unknown;
+}
+/**
+ * Plain text content.
+ */
+export interface TextContent {
+    /**
+     * Discriminator for text content.
+     */
+    type: 'text';
+    /**
+     * UTF-8 text value.
+     */
+    text: string;
+}
+/**
+ * Base64-encoded image content.
+ */
+export interface ImageContent {
+    /**
+     * Discriminator for image content.
+     */
+    type: 'image';
+    /**
+     * Base64 payload.
+     */
+    data: string;
+    /**
+     * MIME type for the encoded image.
+     */
+    mimeType: string;
+}
+/**
+ * Base64-encoded audio content.
+ */
+export interface AudioContent {
+    /**
+     * Discriminator for audio content.
+     */
+    type: 'audio';
+    /**
+     * Base64 payload.
+     */
+    data: string;
+    /**
+     * MIME type for the encoded audio.
+     */
+    mimeType: string;
+}
+/**
+ * Text resource contents.
+ */
+export interface TextResourceContents {
+    /**
+     * Canonical resource URI.
+     */
+    uri: string;
+    /**
+     * Optional MIME type.
+     */
+    mimeType?: string;
+    /**
+     * UTF-8 resource payload.
+     */
+    text: string;
+}
+/**
+ * Binary resource contents encoded as base64.
+ */
+export interface BlobResourceContents {
+    /**
+     * Canonical resource URI.
+     */
+    uri: string;
+    /**
+     * Optional MIME type.
+     */
+    mimeType?: string;
+    /**
+     * Base64-encoded binary payload.
+     */
+    blob: string;
+}
+/**
+ * Resource contents returned by resource reads.
+ */
+export type ResourceContents = TextResourceContents | BlobResourceContents;
+/**
+ * Embedded resource content block.
+ */
+export interface EmbeddedResource {
+    /**
+     * Discriminator for embedded resources.
+     */
+    type: 'resource';
+    /**
+     * Inlined resource contents.
+     */
+    resource: ResourceContents;
+}
+/**
+ * Link to an externally retrievable resource.
+ */
+export interface ResourceLink {
+    /**
+     * Discriminator for resource links.
+     */
+    type: 'resource_link';
+    /**
+     * Resource URI.
+     */
+    uri: string;
+    /**
+     * Optional display name.
+     */
+    name?: string;
+    /**
+     * Optional human-readable description.
+     */
+    description?: string;
+    /**
+     * Optional MIME type hint.
+     */
+    mimeType?: string;
+}
+/**
+ * Any content block allowed in tool responses.
+ */
+export type ContentBlock = TextContent | ImageContent | AudioContent | ResourceLink | EmbeddedResource;
+/**
+ * Looser content block shape accepted by many MCP tool implementations.
+ *
+ * This keeps tool return typing practical while preserving strict content
+ * unions via {@link ContentBlock} for consumers that want discriminated checks.
+ */
+export type LooseContentBlock = Record<string, unknown> & {
+    type?: string;
+};
+/**
+ * The result returned from tool execution.
+ *
+ * @see {@link https://spec.modelcontextprotocol.io/specification/server/tools/}
+ */
+export interface CallToolResult {
+    /**
+     * Ordered content blocks to return to the model.
+     */
+    content: Array<ContentBlock | LooseContentBlock>;
+    /**
+     * Optional machine-readable payload.
+     */
+    structuredContent?: JsonObject;
+    /**
+     * Marks the result as an error response.
+     */
+    isError?: boolean;
+}
+/**
+ * Alias for {@link CallToolResult} for API consistency.
+ */
+export type ToolResponse = CallToolResult;
+/**
+ * Form-based elicitation request parameters.
+ */
+export interface ElicitationFormParams {
+    /**
+     * Elicitation mode. Omit or set to `'form'` for form input.
+     */
+    mode?: 'form';
+    /**
+     * User-facing message.
+     */
+    message: string;
+    /**
+     * Requested form schema.
+     */
+    requestedSchema: {
+        /**
+         * Root schema type.
+         */
+        type: 'object';
+        /**
+         * Field definitions.
+         */
+        properties: Record<string, InputSchema>;
+        /**
+         * Required field names.
+         */
+        required?: readonly string[];
+        /**
+         * Additional schema keywords.
+         */
+        [key: string]: unknown;
+    };
+}
+/**
+ * URL-based elicitation request parameters.
+ */
+export interface ElicitationUrlParams {
+    /**
+     * Elicitation mode.
+     */
+    mode: 'url';
+    /**
+     * User-facing message.
+     */
+    message: string;
+    /**
+     * Unique elicitation identifier.
+     */
+    elicitationId: string;
+    /**
+     * URL to open.
+     */
+    url: string;
+}
+/**
+ * Elicitation request parameters.
+ */
+export type ElicitationParams = ElicitationFormParams | ElicitationUrlParams;
+/**
+ * Result returned by an elicitation request.
+ */
+export interface ElicitationResult {
+    /**
+     * User decision.
+     */
+    action: 'accept' | 'decline' | 'cancel';
+    /**
+     * Submitted values when `action` is `'accept'`.
+     */
+    content?: Record<string, string | number | boolean | string[]>;
+}
+/**
+ * Registration handle returned by registration methods.
+ */
+export interface RegistrationHandle {
+    /**
+     * Unregisters the associated item.
+     */
+    unregister: () => void;
+}
+//# sourceMappingURL=common.d.ts.map

package/third_party/@mcp-b/webmcp-types/dist/json-schema.d.ts

@@ -0,0 +1,196 @@
+import type { JsonPrimitive, JsonValue } from './common.js';
+/**
+ * Primitive JSON Schema `type` values supported by the MVP inference layer.
+ */
+export type JsonSchemaPrimitiveType = 'string' | 'number' | 'integer' | 'boolean' | 'null';
+/**
+ * JSON Schema `type` values supported by the MVP inference layer.
+ */
+export type JsonSchemaType = JsonSchemaPrimitiveType | 'object' | 'array';
+/**
+ * JSON Schema multi-type tuple (for example `["string", "null"]`).
+ */
+export type JsonSchemaTypeArray = readonly [JsonSchemaType, ...JsonSchemaType[]];
+/**
+ * Literal values supported in JSON Schema `enum`/`const`.
+ */
+export type JsonSchemaEnumValue = JsonPrimitive | JsonValue;
+/**
+ * Extra JSON Schema keywords tolerated by the inference layer.
+ *
+ * These keys are intentionally accepted as opaque metadata. Inference only uses
+ * the core MVP keywords and ignores these fields.
+ */
+interface SupplementalJsonSchemaKeywords {
+    $defs?: unknown;
+    $ref?: unknown;
+    additionalItems?: unknown;
+    allOf?: unknown;
+    anyOf?: unknown;
+    contains?: unknown;
+    definitions?: unknown;
+    dependentRequired?: unknown;
+    dependentSchemas?: unknown;
+    format?: unknown;
+    if?: unknown;
+    maxContains?: unknown;
+    minContains?: unknown;
+    not?: unknown;
+    oneOf?: unknown;
+    patternProperties?: unknown;
+    prefixItems?: unknown;
+    propertyNames?: unknown;
+    then?: unknown;
+    unevaluatedItems?: unknown;
+    unevaluatedProperties?: unknown;
+}
+/**
+ * Non-validation metadata accepted by the MVP inference subset.
+ */
+interface JsonSchemaMetadata extends SupplementalJsonSchemaKeywords {
+    default?: JsonValue;
+    description?: string;
+    examples?: readonly JsonValue[];
+    /**
+     * OpenAPI-compatible nullability marker.
+     */
+    nullable?: boolean;
+    title?: string;
+}
+/**
+ * JSON Schema for `type: "string"`.
+ */
+export interface JsonSchemaString extends JsonSchemaMetadata {
+    const?: string;
+    enum?: readonly string[];
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    type: 'string';
+}
+/**
+ * JSON Schema for `type: "number"` and `type: "integer"`.
+ */
+export interface JsonSchemaNumber extends JsonSchemaMetadata {
+    const?: number;
+    enum?: readonly number[];
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+    type: 'number' | 'integer';
+}
+/**
+ * JSON Schema for `type: "boolean"`.
+ */
+export interface JsonSchemaBoolean extends JsonSchemaMetadata {
+    const?: boolean;
+    enum?: readonly boolean[];
+    type: 'boolean';
+}
+/**
+ * JSON Schema for `type: "null"`.
+ */
+export interface JsonSchemaNull extends JsonSchemaMetadata {
+    const?: null;
+    enum?: readonly null[];
+    type: 'null';
+}
+/**
+ * JSON Schema for `type: "array"`.
+ */
+export interface JsonSchemaArray extends JsonSchemaMetadata {
+    items: JsonSchemaForInference;
+    maxItems?: number;
+    minItems?: number;
+    type: 'array';
+    uniqueItems?: boolean;
+}
+/**
+ * JSON Schema for `type: "object"`.
+ */
+export interface JsonSchemaObject extends JsonSchemaMetadata {
+    additionalProperties?: boolean | JsonSchemaForInference;
+    maxProperties?: number;
+    minProperties?: number;
+    properties?: Readonly<Record<string, JsonSchemaForInference>>;
+    required?: readonly string[];
+    type: 'object';
+}
+/**
+ * JSON Schema for multi-type unions via `type: [...]`.
+ */
+export interface JsonSchemaMultiType extends JsonSchemaMetadata {
+    additionalProperties?: boolean | JsonSchemaForInference;
+    const?: JsonSchemaEnumValue;
+    enum?: readonly JsonSchemaEnumValue[];
+    items?: JsonSchemaForInference;
+    properties?: Readonly<Record<string, JsonSchemaForInference>>;
+    required?: readonly string[];
+    type: JsonSchemaTypeArray;
+}
+/**
+ * JSON Schema subset supported by the MVP type inference layer.
+ */
+export type JsonSchemaForInference = JsonSchemaArray | JsonSchemaBoolean | JsonSchemaMultiType | JsonSchemaNull | JsonSchemaNumber | JsonSchemaObject | JsonSchemaString;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type EmptyObject = Record<never, never>;
+type EnumLiteral<TSchema> = TSchema extends {
+    enum: infer TEnum extends readonly unknown[];
+} ? Extract<TEnum[number], JsonSchemaEnumValue> : never;
+type ConstLiteral<TSchema> = TSchema extends {
+    const: infer TConst;
+} ? Extract<TConst, JsonSchemaEnumValue> : never;
+type PropertiesOf<TSchema> = TSchema extends {
+    properties: infer TProperties extends Readonly<Record<string, JsonSchemaForInference>>;
+} ? TProperties : EmptyObject;
+type RequiredKeysOf<TSchema, TProperties extends Record<string, unknown>> = TSchema extends {
+    required: readonly (infer TRequired)[];
+} ? string extends TRequired ? never : Extract<TRequired, keyof TProperties & string> : never;
+type RequiredProps<TProperties extends Record<string, JsonSchemaForInference>, TRequiredKeys extends string> = {
+    [K in keyof TProperties as K extends TRequiredKeys ? K : never]-?: InferJsonSchema<TProperties[K]>;
+};
+type OptionalProps<TProperties extends Record<string, JsonSchemaForInference>, TRequiredKeys extends string> = {
+    [K in keyof TProperties as K extends TRequiredKeys ? never : K]?: InferJsonSchema<TProperties[K]>;
+};
+type PropertyKeysOf<TSchema> = keyof PropertiesOf<TSchema> & string;
+type AdditionalSchemaOf<TSchema> = TSchema extends {
+    additionalProperties: infer TAdditional;
+} ? TAdditional : undefined;
+type AdditionalPropsValue<TSchema> = AdditionalSchemaOf<TSchema> extends JsonSchemaForInference ? InferJsonSchema<AdditionalSchemaOf<TSchema>> : unknown;
+type AdditionalPropsOf<TSchema> = TSchema extends {
+    additionalProperties: false;
+} ? EmptyObject : AdditionalSchemaOf<TSchema> extends JsonSchemaForInference ? PropertyKeysOf<TSchema> extends never ? Record<string, AdditionalPropsValue<TSchema>> : Record<string, unknown> : Record<string, unknown>;
+type InferObject<TSchema> = Simplify<RequiredProps<PropertiesOf<TSchema>, RequiredKeysOf<TSchema, PropertiesOf<TSchema>>> & OptionalProps<PropertiesOf<TSchema>, RequiredKeysOf<TSchema, PropertiesOf<TSchema>>> & AdditionalPropsOf<TSchema>>;
+type TypeKeywordOf<TSchema> = TSchema extends {
+    type?: infer TType;
+} ? 'type' extends keyof TSchema ? TType : undefined : undefined;
+type TypeOptionsOf<TSchema> = [TypeKeywordOf<TSchema>] extends [undefined] ? 'object' : TypeKeywordOf<TSchema> extends readonly unknown[] ? Extract<TypeKeywordOf<TSchema>[number], JsonSchemaType> : Extract<TypeKeywordOf<TSchema>, JsonSchemaType>;
+type InferFromTypeOption<TSchema, TType extends JsonSchemaType> = TType extends 'object' ? InferObject<TSchema> : TType extends 'array' ? TSchema extends {
+    items: infer TItems;
+} ? InferJsonSchema<TItems>[] : unknown[] : TType extends 'string' ? string : TType extends 'number' | 'integer' ? number : TType extends 'boolean' ? boolean : TType extends 'null' ? null : unknown;
+type InferFromTypeKeyword<TSchema> = TypeOptionsOf<TSchema> extends never ? unknown : InferFromTypeOption<TSchema, TypeOptionsOf<TSchema>>;
+type ApplyNullable<TSchema, TValue> = TSchema extends {
+    nullable: true;
+} ? TValue | null : TValue;
+/**
+ * Infers a TypeScript type from the supported JSON Schema subset.
+ *
+ * `const` and `enum` take precedence when present.
+ */
+export type InferJsonSchema<TSchema> = [ConstLiteral<TSchema>] extends [never] ? [EnumLiteral<TSchema>] extends [never] ? ApplyNullable<TSchema, InferFromTypeKeyword<TSchema>> : ApplyNullable<TSchema, EnumLiteral<TSchema>> : ApplyNullable<TSchema, ConstLiteral<TSchema>>;
+type IsWidenedTypeKeyword<TTypeKeyword> = string extends TTypeKeyword ? true : TTypeKeyword extends readonly unknown[] ? string extends TTypeKeyword[number] ? true : false : false;
+type IncludesObjectType<TSchema> = TypeOptionsOf<TSchema> extends never ? false : 'object' extends TypeOptionsOf<TSchema> ? true : false;
+/**
+ * Infers tool argument types from a root `InputSchema`.
+ *
+ * If the schema is not a literal object schema (for example a widened
+ * `InputSchema` loaded at runtime), this intentionally falls back to
+ * `Record<string, unknown>`.
+ */
+export type InferArgsFromInputSchema<TSchema> = IsWidenedTypeKeyword<TypeKeywordOf<TSchema>> extends true ? Record<string, unknown> : IncludesObjectType<TSchema> extends true ? InferObject<TSchema> : Record<string, unknown>;
+export {};
+//# sourceMappingURL=json-schema.d.ts.map

package/third_party/@mcp-b/webmcp-types/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+export {InferArgsFromInputSchema, JsonSchemaForInference} from './dist/json-schema.js';

package/types/_api-chunk.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v22.0.0-next.10
+ * @license Angular v22.0.0-next.11
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -138,7 +138,7 @@ interface ResourceParamsContext {
  *
  * `local` - The resource's value was set locally via `.set()` or `.update()`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' | 'local';
 /**
@@ -148,7 +148,7 @@ type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' |
  * The usual way of creating a `Resource` is through the `resource` function, but various other APIs
  * may present `Resource` instances to describe their own concepts.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface Resource<T> {
     /**
@@ -185,7 +185,7 @@ interface Resource<T> {
  *
  * Overwriting the value of a resource sets it to the 'local' state.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface WritableResource<T> extends Resource<T> {
     readonly value: WritableSignal<T>;
@@ -213,7 +213,7 @@ interface WritableResource<T> extends Resource<T> {
 /**
  * A `WritableResource` created through the `resource` function.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface ResourceRef<T> extends WritableResource<T> {
     hasValue(this: T extends undefined ? this : never): this is ResourceRef<Exclude<T, undefined>>;
@@ -227,7 +227,7 @@ interface ResourceRef<T> extends WritableResource<T> {
  * Parameter to a `ResourceLoader` which gives the request and other options for the current loading
  * operation.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface ResourceLoaderParams<R> {
     params: NoInfer<Exclude<R, undefined>>;
@@ -239,19 +239,19 @@ interface ResourceLoaderParams<R> {
 /**
  * Loading function for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
 /**
  * Streaming loader for a `Resource`.
  *
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => Signal<ResourceStreamItem<T>> | PromiseLike<Signal<ResourceStreamItem<T>>> | undefined;
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface BaseResourceOptions<T, R> {
     /**
@@ -274,11 +274,16 @@ interface BaseResourceOptions<T, R> {
      * Overrides the `Injector` used by `resource`.
      */
     injector?: Injector;
+    /**
+     * Identifier used to cache the resource data in the `TransferState` during server-side rendering and to retrieve it on the client side.
+     * This value value needs to be identical for both the client and server.
+     */
+    id?: string;
 }
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -293,7 +298,7 @@ interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
 /**
  * Options to the `resource` function, for creating a resource.
  *
- * @experimental
+ * @publicApi 22.0
  */
 interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     /**
@@ -307,7 +312,7 @@ interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
     loader?: never;
 }
 /**
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>) & {
     /**
@@ -316,7 +321,7 @@ type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOp
     debugName?: string;
 };
 /**
- * @experimental
+ * @publicApi 22.0
  */
 type ResourceStreamItem<T> = {
     value: T;
@@ -326,7 +331,7 @@ type ResourceStreamItem<T> = {
 /**
  * An explicit representation of a resource's state.
  *
- * @experimental
+ * @publicApi 22.0
  * @see [Resource composition with snapshots](guide/signals/resource#resource-composition-with-snapshots)
  */
 type ResourceSnapshot<T> = {
@@ -346,6 +351,8 @@ type ResourceSnapshot<T> = {
  * Options for `debounced`.
  *
  * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
  */
 interface DebouncedOptions<T> {
     /** The `Injector` to use for the debounced resource. */
@@ -358,6 +365,8 @@ interface DebouncedOptions<T> {
  * Can be a number of milliseconds or a function that returns a Promise.
  *
  * @see [Debouncing signals with `debounced`](guide/signals/debounced)
+ *
+ * @experimental 22.0
  */
 type DebounceTimer<T> = number | ((value: T, lastValue: ResourceSnapshot<T>) => Promise<void> | void);
 

package/types/_chrome_dev_tools_performance-chunk.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v22.0.0-next.10
+ * @license Angular v22.0.0-next.11
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */

package/types/_debug_node-chunk.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v22.0.0-next.10
+ * @license Angular v22.0.0-next.11
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */