@angular/cdk 19.2.11 → 19.2.12

package/overlay-prebuilt.css

@@ -1 +1 @@
-.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;display:flex;max-width:100%;max-height:100%;z-index:1000}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);opacity:0;z-index:1000;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}@media(prefers-reduced-motion){.cdk-overlay-backdrop{transition-duration:1ms}}.cdk-overlay-backdrop-showing{opacity:1}@media(forced-colors: active){.cdk-overlay-backdrop-showing{opacity:.6}}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing,.cdk-high-contrast-active .cdk-overlay-transparent-backdrop{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;display:flex;flex-direction:column;min-width:1px;min-height:1px;z-index:1000}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}
+.cdk-overlay-container,.cdk-global-overlay-wrapper{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;display:flex;max-width:100%;max-height:100%;z-index:1000}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;pointer-events:auto;-webkit-tap-highlight-color:rgba(0,0,0,0);opacity:0;touch-action:manipulation;z-index:1000;transition:opacity 400ms cubic-bezier(0.25, 0.8, 0.25, 1)}@media(prefers-reduced-motion){.cdk-overlay-backdrop{transition-duration:1ms}}.cdk-overlay-backdrop-showing{opacity:1}@media(forced-colors: active){.cdk-overlay-backdrop-showing{opacity:.6}}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.32)}.cdk-overlay-transparent-backdrop{transition:visibility 1ms linear,opacity 1ms linear;visibility:hidden;opacity:1}.cdk-overlay-transparent-backdrop.cdk-overlay-backdrop-showing,.cdk-high-contrast-active .cdk-overlay-transparent-backdrop{opacity:0;visibility:visible}.cdk-overlay-backdrop-noop-animation{transition:none}.cdk-overlay-connected-position-bounding-box{position:absolute;display:flex;flex-direction:column;min-width:1px;min-height:1px;z-index:1000}.cdk-global-scrollblock{position:fixed;width:100%;overflow-y:scroll}

package/overlay.d-BdoMy0hX.d.ts

@@ -0,0 +1,296 @@
+import { n as ScrollStrategy, b as OverlayRef, P as PositionStrategy, e as FlexibleConnectedPositionStrategyOrigin, F as FlexibleConnectedPositionStrategy, g as OverlayConfig } from './overlay-module.d-B3qEQtts.js';
+import * as i0 from '@angular/core';
+import { NgZone } from '@angular/core';
+import { ViewportRuler } from './scrolling/index.js';
+import { S as ScrollDispatcher } from './scrolling-module.d-ud2XrbF8.js';
+
+/**
+ * Strategy that will prevent the user from scrolling while the overlay is visible.
+ */
+declare class BlockScrollStrategy implements ScrollStrategy {
+    private _viewportRuler;
+    private _previousHTMLStyles;
+    private _previousScrollPosition;
+    private _isEnabled;
+    private _document;
+    constructor(_viewportRuler: ViewportRuler, document: any);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(): void;
+    /** Blocks page-level scroll while the attached overlay is open. */
+    enable(): void;
+    /** Unblocks page-level scroll while the attached overlay is open. */
+    disable(): void;
+    private _canBeEnabled;
+}
+
+/**
+ * Config options for the CloseScrollStrategy.
+ */
+interface CloseScrollStrategyConfig {
+    /** Amount of pixels the user has to scroll before the overlay is closed. */
+    threshold?: number;
+}
+/**
+ * Strategy that will close the overlay as soon as the user starts scrolling.
+ */
+declare class CloseScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _ngZone;
+    private _viewportRuler;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    private _initialScrollPosition;
+    constructor(_scrollDispatcher: ScrollDispatcher, _ngZone: NgZone, _viewportRuler: ViewportRuler, _config?: CloseScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayRef): void;
+    /** Enables the closing of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables the closing the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+    /** Detaches the overlay ref and disables the scroll strategy. */
+    private _detach;
+}
+
+/** Scroll strategy that doesn't do anything. */
+declare class NoopScrollStrategy implements ScrollStrategy {
+    /** Does nothing, as this scroll strategy is a no-op. */
+    enable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    disable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    attach(): void;
+}
+
+/**
+ * Config options for the RepositionScrollStrategy.
+ */
+interface RepositionScrollStrategyConfig {
+    /** Time in milliseconds to throttle the scroll events. */
+    scrollThrottle?: number;
+    /** Whether to close the overlay once the user has scrolled away completely. */
+    autoClose?: boolean;
+}
+/**
+ * Strategy that will update the element position as the user is scrolling.
+ */
+declare class RepositionScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _viewportRuler;
+    private _ngZone;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, _config?: RepositionScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayRef): void;
+    /** Enables repositioning of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables repositioning of the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+}
+
+/**
+ * Options for how an overlay will handle scrolling.
+ *
+ * Users can provide a custom value for `ScrollStrategyOptions` to replace the default
+ * behaviors. This class primarily acts as a factory for ScrollStrategy instances.
+ */
+declare class ScrollStrategyOptions {
+    private _scrollDispatcher;
+    private _viewportRuler;
+    private _ngZone;
+    private _document;
+    constructor(...args: unknown[]);
+    /** Do nothing on scroll. */
+    noop: () => NoopScrollStrategy;
+    /**
+     * Close the overlay as soon as the user scrolls.
+     * @param config Configuration to be used inside the scroll strategy.
+     */
+    close: (config?: CloseScrollStrategyConfig) => CloseScrollStrategy;
+    /** Block scrolling. */
+    block: () => BlockScrollStrategy;
+    /**
+     * Update the overlay's position on scroll.
+     * @param config Configuration to be used inside the scroll strategy.
+     * Allows debouncing the reposition calls.
+     */
+    reposition: (config?: RepositionScrollStrategyConfig) => RepositionScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollStrategyOptions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollStrategyOptions>;
+}
+
+/**
+ * A strategy for positioning overlays. Using this strategy, an overlay is given an
+ * explicit position relative to the browser's viewport. We use flexbox, instead of
+ * transforms, in order to avoid issues with subpixel rendering which can cause the
+ * element to become blurry.
+ */
+declare class GlobalPositionStrategy implements PositionStrategy {
+    /** The overlay to which this strategy is attached. */
+    private _overlayRef;
+    private _cssPosition;
+    private _topOffset;
+    private _bottomOffset;
+    private _alignItems;
+    private _xPosition;
+    private _xOffset;
+    private _width;
+    private _height;
+    private _isDisposed;
+    attach(overlayRef: OverlayRef): void;
+    /**
+     * Sets the top position of the overlay. Clears any previously set vertical position.
+     * @param value New top offset.
+     */
+    top(value?: string): this;
+    /**
+     * Sets the left position of the overlay. Clears any previously set horizontal position.
+     * @param value New left offset.
+     */
+    left(value?: string): this;
+    /**
+     * Sets the bottom position of the overlay. Clears any previously set vertical position.
+     * @param value New bottom offset.
+     */
+    bottom(value?: string): this;
+    /**
+     * Sets the right position of the overlay. Clears any previously set horizontal position.
+     * @param value New right offset.
+     */
+    right(value?: string): this;
+    /**
+     * Sets the overlay to the start of the viewport, depending on the overlay direction.
+     * This will be to the left in LTR layouts and to the right in RTL.
+     * @param offset Offset from the edge of the screen.
+     */
+    start(value?: string): this;
+    /**
+     * Sets the overlay to the end of the viewport, depending on the overlay direction.
+     * This will be to the right in LTR layouts and to the left in RTL.
+     * @param offset Offset from the edge of the screen.
+     */
+    end(value?: string): this;
+    /**
+     * Sets the overlay width and clears any previously set width.
+     * @param value New width for the overlay
+     * @deprecated Pass the `width` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    width(value?: string): this;
+    /**
+     * Sets the overlay height and clears any previously set height.
+     * @param value New height for the overlay
+     * @deprecated Pass the `height` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    height(value?: string): this;
+    /**
+     * Centers the overlay horizontally with an optional offset.
+     * Clears any previously set horizontal position.
+     *
+     * @param offset Overlay offset from the horizontal center.
+     */
+    centerHorizontally(offset?: string): this;
+    /**
+     * Centers the overlay vertically with an optional offset.
+     * Clears any previously set vertical position.
+     *
+     * @param offset Overlay offset from the vertical center.
+     */
+    centerVertically(offset?: string): this;
+    /**
+     * Apply the position to the element.
+     * @docs-private
+     */
+    apply(): void;
+    /**
+     * Cleans up the DOM changes from the position strategy.
+     * @docs-private
+     */
+    dispose(): void;
+}
+
+/** Builder for overlay position strategy. */
+declare class OverlayPositionBuilder {
+    private _viewportRuler;
+    private _document;
+    private _platform;
+    private _overlayContainer;
+    constructor(...args: unknown[]);
+    /**
+     * Creates a global position strategy.
+     */
+    global(): GlobalPositionStrategy;
+    /**
+     * Creates a flexible position strategy.
+     * @param origin Origin relative to which to position the overlay.
+     */
+    flexibleConnectedTo(origin: FlexibleConnectedPositionStrategyOrigin): FlexibleConnectedPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayPositionBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayPositionBuilder>;
+}
+
+/**
+ * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
+ * used as a low-level building block for other components. Dialogs, tooltips, menus,
+ * selects, etc. can all be built using overlays. The service should primarily be used by authors
+ * of re-usable components rather than developers building end-user applications.
+ *
+ * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.
+ */
+declare class Overlay {
+    scrollStrategies: ScrollStrategyOptions;
+    private _overlayContainer;
+    private _positionBuilder;
+    private _keyboardDispatcher;
+    private _injector;
+    private _ngZone;
+    private _document;
+    private _directionality;
+    private _location;
+    private _outsideClickDispatcher;
+    private _animationsModuleType;
+    private _idGenerator;
+    private _renderer;
+    private _appRef;
+    private _styleLoader;
+    constructor(...args: unknown[]);
+    /**
+     * Creates an overlay.
+     * @param config Configuration applied to the overlay.
+     * @returns Reference to the created overlay.
+     */
+    create(config?: OverlayConfig): OverlayRef;
+    /**
+     * Gets a position builder that can be used, via fluent API,
+     * to construct and configure a position strategy.
+     * @returns An overlay position builder.
+     */
+    position(): OverlayPositionBuilder;
+    /**
+     * Creates the DOM element for an overlay and appends it to the overlay container.
+     * @returns Newly-created pane element
+     */
+    private _createPaneElement;
+    /**
+     * Creates the host element that wraps around an overlay
+     * and can be used for advanced positioning.
+     * @returns Newly-create host element.
+     */
+    private _createHostElement;
+    /**
+     * Create a DomPortalOutlet into which the overlay content can be loaded.
+     * @param pane The DOM element to turn into a portal outlet.
+     * @returns A portal outlet for the given DOM element.
+     */
+    private _createPortalOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Overlay, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Overlay>;
+}
+
+export { BlockScrollStrategy as B, CloseScrollStrategy as C, GlobalPositionStrategy as G, NoopScrollStrategy as N, Overlay as O, RepositionScrollStrategy as R, ScrollStrategyOptions as S, OverlayPositionBuilder as a };
+export type { RepositionScrollStrategyConfig as b };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cdk",
-  "version": "19.2.11",
+  "version": "19.2.12",
   "description": "Angular Material Component Development Kit",
   "repository": {
     "type": "git",

package/platform/index.d.ts

@@ -1,4 +1,4 @@
-export { Platform } from '../platform.d-cnFZCLss.js';
+export { P as Platform } from '../platform.d-B3vREl3q.js';
 import * as i0 from '@angular/core';
 import { Renderer2 } from '@angular/core';
 

package/platform.d-B3vREl3q.d.ts

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+
+/**
+ * Service to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ */
+declare class Platform {
+    private _platformId;
+    /** Whether the Angular application is being rendered in the browser. */
+    isBrowser: boolean;
+    /** Whether the current browser is Microsoft Edge. */
+    EDGE: boolean;
+    /** Whether the current rendering engine is Microsoft Trident. */
+    TRIDENT: boolean;
+    /** Whether the current rendering engine is Blink. */
+    BLINK: boolean;
+    /** Whether the current rendering engine is WebKit. */
+    WEBKIT: boolean;
+    /** Whether the current platform is Apple iOS. */
+    IOS: boolean;
+    /** Whether the current browser is Firefox. */
+    FIREFOX: boolean;
+    /** Whether the current platform is Android. */
+    ANDROID: boolean;
+    /** Whether the current browser is Safari. */
+    SAFARI: boolean;
+    /** Backwards-compatible constructor. */
+    constructor(..._args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<Platform, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Platform>;
+}
+
+export { Platform as P };

package/portal/index.d.ts

@@ -1,5 +1,5 @@
-import { BasePortalOutlet, ComponentPortal, TemplatePortal, DomPortal } from '../portal-directives.d-C698lRc2.js';
-export { BasePortalHost, CdkPortal, CdkPortalOutlet, CdkPortalOutletAttachedRef, ComponentType, Portal, PortalHost, PortalHostDirective, PortalModule, PortalOutlet, TemplatePortalDirective } from '../portal-directives.d-C698lRc2.js';
+import { B as BasePortalOutlet, a as ComponentPortal, T as TemplatePortal, D as DomPortal } from '../portal-directives.d-BoG39gYN.js';
+export { d as BasePortalHost, e as CdkPortal, h as CdkPortalOutlet, g as CdkPortalOutletAttachedRef, C as ComponentType, P as Portal, c as PortalHost, i as PortalHostDirective, j as PortalModule, b as PortalOutlet, f as TemplatePortalDirective } from '../portal-directives.d-BoG39gYN.js';
 import { ApplicationRef, Injector, ComponentRef, EmbeddedViewRef } from '@angular/core';
 
 /**

package/portal-directives.d-BoG39gYN.d.ts

@@ -0,0 +1,232 @@
+import * as i0 from '@angular/core';
+import { ComponentRef, ViewContainerRef, Injector, EmbeddedViewRef, TemplateRef, ElementRef, OnInit, OnDestroy, EventEmitter } from '@angular/core';
+
+/** Interface that can be used to generically type a class. */
+interface ComponentType<T> {
+    new (...args: any[]): T;
+}
+/**
+ * A `Portal` is something that you want to render somewhere else.
+ * It can be attach to / detached from a `PortalOutlet`.
+ */
+declare abstract class Portal<T> {
+    private _attachedHost;
+    /** Attach this portal to a host. */
+    attach(host: PortalOutlet): T;
+    /** Detach this portal from its host */
+    detach(): void;
+    /** Whether this portal is attached to a host. */
+    get isAttached(): boolean;
+    /**
+     * Sets the PortalOutlet reference without performing `attach()`. This is used directly by
+     * the PortalOutlet when it is performing an `attach()` or `detach()`.
+     */
+    setAttachedHost(host: PortalOutlet | null): void;
+}
+/**
+ * A `ComponentPortal` is a portal that instantiates some Component upon attachment.
+ */
+declare class ComponentPortal<T> extends Portal<ComponentRef<T>> {
+    /** The type of the component that will be instantiated for attachment. */
+    component: ComponentType<T>;
+    /**
+     * Where the attached component should live in Angular's *logical* component tree.
+     * This is different from where the component *renders*, which is determined by the PortalOutlet.
+     * The origin is necessary when the host is outside of the Angular application context.
+     */
+    viewContainerRef?: ViewContainerRef | null;
+    /** Injector used for the instantiation of the component. */
+    injector?: Injector | null;
+    /**
+     * @deprecated No longer in use. To be removed.
+     * @breaking-change 18.0.0
+     */
+    componentFactoryResolver?: any;
+    /**
+     * List of DOM nodes that should be projected through `<ng-content>` of the attached component.
+     */
+    projectableNodes?: Node[][] | null;
+    constructor(component: ComponentType<T>, viewContainerRef?: ViewContainerRef | null, injector?: Injector | null, 
+    /**
+     * @deprecated No longer in use. To be removed.
+     * @breaking-change 18.0.0
+     */
+    _componentFactoryResolver?: any, projectableNodes?: Node[][] | null);
+}
+/**
+ * A `TemplatePortal` is a portal that represents some embedded template (TemplateRef).
+ */
+declare class TemplatePortal<C = any> extends Portal<EmbeddedViewRef<C>> {
+    /** The embedded template that will be used to instantiate an embedded View in the host. */
+    templateRef: TemplateRef<C>;
+    /** Reference to the ViewContainer into which the template will be stamped out. */
+    viewContainerRef: ViewContainerRef;
+    /** Contextual data to be passed in to the embedded view. */
+    context?: C | undefined;
+    /** The injector to use for the embedded view. */
+    injector?: Injector | undefined;
+    constructor(
+    /** The embedded template that will be used to instantiate an embedded View in the host. */
+    templateRef: TemplateRef<C>, 
+    /** Reference to the ViewContainer into which the template will be stamped out. */
+    viewContainerRef: ViewContainerRef, 
+    /** Contextual data to be passed in to the embedded view. */
+    context?: C | undefined, 
+    /** The injector to use for the embedded view. */
+    injector?: Injector | undefined);
+    get origin(): ElementRef;
+    /**
+     * Attach the portal to the provided `PortalOutlet`.
+     * When a context is provided it will override the `context` property of the `TemplatePortal`
+     * instance.
+     */
+    attach(host: PortalOutlet, context?: C | undefined): EmbeddedViewRef<C>;
+    detach(): void;
+}
+/**
+ * A `DomPortal` is a portal whose DOM element will be taken from its current position
+ * in the DOM and moved into a portal outlet, when it is attached. On detach, the content
+ * will be restored to its original position.
+ */
+declare class DomPortal<T = HTMLElement> extends Portal<T> {
+    /** DOM node hosting the portal's content. */
+    readonly element: T;
+    constructor(element: T | ElementRef<T>);
+}
+/** A `PortalOutlet` is a space that can contain a single `Portal`. */
+interface PortalOutlet {
+    /** Attaches a portal to this outlet. */
+    attach(portal: Portal<any>): any;
+    /** Detaches the currently attached portal from this outlet. */
+    detach(): any;
+    /** Performs cleanup before the outlet is destroyed. */
+    dispose(): void;
+    /** Whether there is currently a portal attached to this outlet. */
+    hasAttached(): boolean;
+}
+/**
+ * @deprecated Use `PortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+type PortalHost = PortalOutlet;
+/**
+ * Partial implementation of PortalOutlet that handles attaching
+ * ComponentPortal and TemplatePortal.
+ */
+declare abstract class BasePortalOutlet implements PortalOutlet {
+    /** The portal currently attached to the host. */
+    protected _attachedPortal: Portal<any> | null;
+    /** A function that will permanently dispose this host. */
+    private _disposeFn;
+    /** Whether this host has already been permanently disposed. */
+    private _isDisposed;
+    /** Whether this host has an attached portal. */
+    hasAttached(): boolean;
+    attach<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attach<T>(portal: TemplatePortal<T>): EmbeddedViewRef<T>;
+    attach(portal: any): any;
+    abstract attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    abstract attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    readonly attachDomPortal: null | ((portal: DomPortal) => any);
+    /** Detaches a previously attached portal. */
+    detach(): void;
+    /** Permanently dispose of this portal host. */
+    dispose(): void;
+    /** @docs-private */
+    setDisposeFn(fn: () => void): void;
+    private _invokeDisposeFn;
+}
+/**
+ * @deprecated Use `BasePortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+declare abstract class BasePortalHost extends BasePortalOutlet {
+}
+
+/**
+ * Directive version of a `TemplatePortal`. Because the directive *is* a TemplatePortal,
+ * the directive instance itself can be attached to a host, enabling declarative use of portals.
+ */
+declare class CdkPortal extends TemplatePortal {
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortal, "[cdkPortal]", ["cdkPortal"], {}, {}, never, never, true, never>;
+}
+/**
+ * @deprecated Use `CdkPortal` instead.
+ * @breaking-change 9.0.0
+ */
+declare class TemplatePortalDirective extends CdkPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatePortalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplatePortalDirective, "[cdk-portal], [portal]", ["cdkPortal"], {}, {}, never, never, true, never>;
+}
+/**
+ * Possible attached references to the CdkPortalOutlet.
+ */
+type CdkPortalOutletAttachedRef = ComponentRef<any> | EmbeddedViewRef<any> | null;
+/**
+ * Directive version of a PortalOutlet. Because the directive *is* a PortalOutlet, portals can be
+ * directly attached to it, enabling declarative use.
+ *
+ * Usage:
+ * `<ng-template [cdkPortalOutlet]="greeting"></ng-template>`
+ */
+declare class CdkPortalOutlet extends BasePortalOutlet implements OnInit, OnDestroy {
+    private _moduleRef;
+    private _document;
+    private _viewContainerRef;
+    /** Whether the portal component is initialized. */
+    private _isInitialized;
+    /** Reference to the currently-attached component/view ref. */
+    private _attachedRef;
+    constructor(...args: unknown[]);
+    /** Portal associated with the Portal outlet. */
+    get portal(): Portal<any> | null;
+    set portal(portal: Portal<any> | null | undefined | '');
+    /** Emits when a portal is attached to the outlet. */
+    readonly attached: EventEmitter<CdkPortalOutletAttachedRef>;
+    /** Component or view reference that is attached to the portal. */
+    get attachedRef(): CdkPortalOutletAttachedRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Attach the given ComponentPortal to this PortalOutlet.
+     *
+     * @param portal Portal to be attached to the portal outlet.
+     * @returns Reference to the created component.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    /**
+     * Attach the given TemplatePortal to this PortalHost as an embedded View.
+     * @param portal Portal to be attached.
+     * @returns Reference to the created embedded view.
+     */
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    /**
+     * Attaches the given DomPortal to this PortalHost by moving all of the portal content into it.
+     * @param portal Portal to be attached.
+     * @deprecated To be turned into a method.
+     * @breaking-change 10.0.0
+     */
+    attachDomPortal: (portal: DomPortal) => void;
+    /** Gets the root node of the portal outlet. */
+    private _getRootNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkPortalOutlet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkPortalOutlet, "[cdkPortalOutlet]", ["cdkPortalOutlet"], { "portal": { "alias": "cdkPortalOutlet"; "required": false; }; }, { "attached": "attached"; }, never, never, true, never>;
+}
+/**
+ * @deprecated Use `CdkPortalOutlet` instead.
+ * @breaking-change 9.0.0
+ */
+declare class PortalHostDirective extends CdkPortalOutlet {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalHostDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalHostDirective, "[cdkPortalHost], [portalHost]", ["cdkPortalHost"], { "portal": { "alias": "cdkPortalHost"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class PortalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PortalModule, never, [typeof CdkPortal, typeof CdkPortalOutlet, typeof TemplatePortalDirective, typeof PortalHostDirective], [typeof CdkPortal, typeof CdkPortalOutlet, typeof TemplatePortalDirective, typeof PortalHostDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PortalModule>;
+}
+
+export { BasePortalOutlet as B, DomPortal as D, Portal as P, TemplatePortal as T, ComponentPortal as a, BasePortalHost as d, CdkPortal as e, TemplatePortalDirective as f, CdkPortalOutlet as h, PortalHostDirective as i, PortalModule as j };
+export type { ComponentType as C, PortalOutlet as b, PortalHost as c, CdkPortalOutletAttachedRef as g };

package/private/index.d.ts

@@ -1,4 +1,4 @@
-export { _CdkPrivateStyleLoader } from '../style-loader.d-DbvWk0ty.js';
+export { _ as _CdkPrivateStyleLoader } from '../style-loader.d-BXZfQZTF.js';
 import * as i0 from '@angular/core';
 
 /**

package/schematics/ng-add/index.js

@@ -29,7 +29,7 @@ function default_1() {
             // In order to align the CDK version with other Angular dependencies that are setup by
             // `@schematics/angular`, we use tilde instead of caret. This is default for Angular
             // dependencies in new CLI projects.
-            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~{STABLE_PROJECT_VERSION}`);
+            (0, package_config_1.addPackageToPackageJson)(host, '@angular/cdk', `~19.2.12`);
             // Add a task to run the package manager. This is necessary because we updated the
             // workspace "package.json" file and we want lock files to reflect the new version range.
             context.addTask(new tasks_1.NodePackageInstallTask());

package/scrolling/index.d.ts

@@ -1,10 +1,10 @@
-export { CdkFixedSizeVirtualScroll, CdkScrollable, CdkScrollableModule, CdkVirtualForOf, CdkVirtualForOfContext, CdkVirtualScrollRepeater, CdkVirtualScrollViewport, CdkVirtualScrollable, CdkVirtualScrollableElement, CdkVirtualScrollableWindow, DEFAULT_SCROLL_TIME, ExtendedScrollToOptions, FixedSizeVirtualScrollStrategy, ScrollDispatcher, ScrollingModule, VIRTUAL_SCROLLABLE, VIRTUAL_SCROLL_STRATEGY, VirtualScrollStrategy, _Bottom, _End, _Left, _Right, _Start, _Top, _Without, _XAxis, _XOR, _YAxis, _fixedSizeVirtualScrollStrategyFactory } from '../scrolling-module.d-CUKr8D_p.js';
+export { b as CdkFixedSizeVirtualScroll, C as CdkScrollable, a as CdkScrollableModule, c as CdkVirtualForOf, r as CdkVirtualForOfContext, t as CdkVirtualScrollRepeater, d as CdkVirtualScrollViewport, v as CdkVirtualScrollable, f as CdkVirtualScrollableElement, e as CdkVirtualScrollableWindow, D as DEFAULT_SCROLL_TIME, E as ExtendedScrollToOptions, F as FixedSizeVirtualScrollStrategy, S as ScrollDispatcher, g as ScrollingModule, u as VIRTUAL_SCROLLABLE, V as VIRTUAL_SCROLL_STRATEGY, s as VirtualScrollStrategy, k as _Bottom, o as _End, l as _Left, m as _Right, n as _Start, j as _Top, h as _Without, p as _XAxis, i as _XOR, q as _YAxis, _ as _fixedSizeVirtualScrollStrategyFactory } from '../scrolling-module.d-ud2XrbF8.js';
 import * as i0 from '@angular/core';
 import { OnDestroy } from '@angular/core';
 import { Observable } from 'rxjs';
-export { Dir as ɵɵDir } from '../bidi-module.d-BSI86Zrk.js';
-import '../data-source.d-DAIyaEMO.js';
-import '../number-property.d-BzBQchZ2.js';
+export { b as ɵɵDir } from '../bidi-module.d-D-fEBKdS.js';
+import '../data-source.d-Bblv7Zvh.js';
+import '../number-property.d-CJVxXUcb.js';
 
 /** Time in ms to throttle the resize events by default. */
 declare const DEFAULT_RESIZE_TIME = 20;