@angular/material 20.0.0-next.0 → 20.0.0-next.10

package/module.d-m-qXd3m8.d.ts

@@ -0,0 +1,329 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, AfterViewInit, ElementRef } from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+import * as i2 from '@angular/cdk/overlay';
+import { ScrollStrategy, OverlayRef, ConnectedPosition, OriginConnectionPosition, OverlayConnectionPosition } from '@angular/cdk/overlay';
+import { M as MatCommonModule } from './common-module.d-C8xzHJDr.js';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { Directionality } from '@angular/cdk/bidi';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/cdk/scrolling';
+
+/** Possible positions for a tooltip. */
+type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+/**
+ * Options for how the tooltip trigger should handle touch gestures.
+ * See `MatTooltip.touchGestures` for more information.
+ */
+type TooltipTouchGestures = 'auto' | 'on' | 'off';
+/** Possible visibility states of a tooltip. */
+type TooltipVisibility = 'initial' | 'visible' | 'hidden';
+/** Time in ms to throttle repositioning after scroll events. */
+declare const SCROLL_THROTTLE_MS = 20;
+/**
+ * Creates an error to be thrown if the user supplied an invalid tooltip position.
+ * @docs-private
+ */
+declare function getMatTooltipInvalidPositionError(position: string): Error;
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+declare const MAT_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY(_overlay: unknown): () => ScrollStrategy;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare const MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: any[];
+    useFactory: typeof MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY;
+};
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY(): MatTooltipDefaultOptions;
+/** Injection token to be used to override the default options for `matTooltip`. */
+declare const MAT_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<MatTooltipDefaultOptions>;
+/** Default `matTooltip` options that can be overridden. */
+interface MatTooltipDefaultOptions {
+    /** Default delay when the tooltip is shown. */
+    showDelay: number;
+    /** Default delay when the tooltip is hidden. */
+    hideDelay: number;
+    /** Default delay when hiding the tooltip on a touch device. */
+    touchendHideDelay: number;
+    /** Time between the user putting the pointer on a tooltip trigger and the long press event being fired on a touch device. */
+    touchLongPressShowDelay?: number;
+    /** Default touch gesture handling for tooltips. */
+    touchGestures?: TooltipTouchGestures;
+    /** Default position for tooltips. */
+    position?: TooltipPosition;
+    /**
+     * Default value for whether tooltips should be positioned near the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    positionAtOrigin?: boolean;
+    /** Disables the ability for the user to interact with the tooltip element. */
+    disableTooltipInteractivity?: boolean;
+    /**
+     * Default classes to be applied to the tooltip. These default classes will not be applied if
+     * `tooltipClass` is defined directly on the tooltip element, as it will override the default.
+     */
+    tooltipClass?: string | string[];
+}
+/**
+ * CSS class that will be attached to the overlay panel.
+ * @deprecated
+ * @breaking-change 13.0.0 remove this variable
+ */
+declare const TOOLTIP_PANEL_CLASS = "mat-mdc-tooltip-panel";
+/**
+ * Directive that attaches a material design tooltip to the host element. Animates the showing and
+ * hiding of a tooltip provided position (defaults to below the element).
+ *
+ * https://material.io/design/components/tooltips.html
+ */
+declare class MatTooltip implements OnDestroy, AfterViewInit {
+    private _elementRef;
+    private _ngZone;
+    private _platform;
+    private _ariaDescriber;
+    private _focusMonitor;
+    protected _dir: Directionality;
+    private _injector;
+    private _viewContainerRef;
+    private _animationsDisabled;
+    private _defaultOptions;
+    _overlayRef: OverlayRef | null;
+    _tooltipInstance: TooltipComponent | null;
+    _overlayPanelClass: string[] | undefined;
+    private _portal;
+    private _position;
+    private _positionAtOrigin;
+    private _disabled;
+    private _tooltipClass;
+    private _viewInitialized;
+    private _pointerExitEventsInitialized;
+    private readonly _tooltipComponent;
+    private _viewportMargin;
+    private _currentPosition;
+    private readonly _cssClassPrefix;
+    private _ariaDescriptionPending;
+    private _dirSubscribed;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    get position(): TooltipPosition;
+    set position(value: TooltipPosition);
+    /**
+     * Whether tooltip should be relative to the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    get positionAtOrigin(): boolean;
+    set positionAtOrigin(value: BooleanInput);
+    /** Disables the display of the tooltip. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** The default delay in ms before showing the tooltip after show is called */
+    get showDelay(): number;
+    set showDelay(value: NumberInput);
+    private _showDelay;
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    get hideDelay(): number;
+    set hideDelay(value: NumberInput);
+    private _hideDelay;
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide, however it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    touchGestures: TooltipTouchGestures;
+    /** The message to be displayed in the tooltip */
+    get message(): string;
+    set message(value: string | null | undefined);
+    private _message;
+    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */
+    get tooltipClass(): string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    set tooltipClass(value: string | string[] | Set<string> | {
+        [key: string]: any;
+    });
+    /** Manually-bound passive event listeners. */
+    private readonly _passiveListeners;
+    /** Timer started at the last `touchstart` event. */
+    private _touchstartTimeout;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Whether ngOnDestroyed has been called. */
+    private _isDestroyed;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy(): void;
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay?: number, origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay?: number): void;
+    /** Shows/hides the tooltip */
+    toggle(origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Returns true if the tooltip is currently visible to the user */
+    _isTooltipVisible(): boolean;
+    /** Create the overlay config and position strategy */
+    private _createOverlay;
+    /** Detaches the currently-attached tooltip. */
+    private _detach;
+    /** Updates the position of the current tooltip. */
+    private _updatePosition;
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    protected _addOffset(position: ConnectedPosition): ConnectedPosition;
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    _getOrigin(): {
+        main: OriginConnectionPosition;
+        fallback: OriginConnectionPosition;
+    };
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    _getOverlayPosition(): {
+        main: OverlayConnectionPosition;
+        fallback: OverlayConnectionPosition;
+    };
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    private _updateTooltipMessage;
+    /** Updates the tooltip class */
+    private _setTooltipClass;
+    /** Inverts an overlay position. */
+    private _invertPosition;
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    private _updateCurrentPositionClass;
+    /** Binds the pointer events to the tooltip trigger. */
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListeners;
+    private _platformSupportsMouseEvents;
+    /** Listener for the `wheel` event on the element. */
+    private _wheelListener;
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    private _disableNativeGesturesIfNecessary;
+    /** Updates the tooltip's ARIA description based on it current state. */
+    private _syncAriaDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTooltip, "[matTooltip]", ["matTooltip"], { "position": { "alias": "matTooltipPosition"; "required": false; }; "positionAtOrigin": { "alias": "matTooltipPositionAtOrigin"; "required": false; }; "disabled": { "alias": "matTooltipDisabled"; "required": false; }; "showDelay": { "alias": "matTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "matTooltipHideDelay"; "required": false; }; "touchGestures": { "alias": "matTooltipTouchGestures"; "required": false; }; "message": { "alias": "matTooltip"; "required": false; }; "tooltipClass": { "alias": "matTooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Internal component that wraps the tooltip's content.
+ * @docs-private
+ */
+declare class TooltipComponent implements OnDestroy {
+    private _changeDetectorRef;
+    protected _elementRef: ElementRef<HTMLElement>;
+    _isMultiline: boolean;
+    /** Message to display in the tooltip */
+    message: string;
+    /** Classes to be added to the tooltip. Supports the same syntax as `ngClass`. */
+    tooltipClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    /** The timeout ID of any current timer set to show the tooltip */
+    private _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    private _hideTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Whether animations are currently disabled. */
+    private _animationsDisabled;
+    /** Reference to the internal tooltip element. */
+    _tooltip: ElementRef<HTMLElement>;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    /** Name of the show animation and the class that toggles it. */
+    private readonly _showAnimation;
+    /** Name of the hide animation and the class that toggles it. */
+    private readonly _hideAnimation;
+    constructor(...args: unknown[]);
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     * This method is only needed by the mdc-tooltip, and so it is only implemented
+     * in the mdc-tooltip, not here.
+     */
+    protected _onShow(): void;
+    /** Whether the tooltip text has overflown to the next line */
+    private _isTooltipMultiline;
+    /** Event listener dispatched when an animation on the tooltip finishes. */
+    _handleAnimationEnd({ animationName }: AnimationEvent): void;
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations(): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "mat-tooltip-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class MatTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTooltipModule, never, [typeof i1.A11yModule, typeof i2.OverlayModule, typeof MatCommonModule, typeof MatTooltip, typeof TooltipComponent], [typeof MatTooltip, typeof TooltipComponent, typeof MatCommonModule, typeof i5.CdkScrollableModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTooltipModule>;
+}
+
+export { MatTooltipModule as M, SCROLL_THROTTLE_MS as S, MAT_TOOLTIP_SCROLL_STRATEGY as c, MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY as d, MAT_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER as e, MAT_TOOLTIP_DEFAULT_OPTIONS_FACTORY as f, getMatTooltipInvalidPositionError as g, MAT_TOOLTIP_DEFAULT_OPTIONS as h, TOOLTIP_PANEL_CLASS as j, MatTooltip as k, TooltipComponent as l };
+export type { TooltipPosition as T, TooltipTouchGestures as a, TooltipVisibility as b, MatTooltipDefaultOptions as i };

package/option-harness.d-IqsW95GR.d.ts

@@ -0,0 +1,35 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+
+interface OptionHarnessFilters extends BaseHarnessFilters {
+    text?: string | RegExp;
+    isSelected?: boolean;
+}
+
+/** Harness for interacting with a `mat-option` in tests. */
+declare class MatOptionHarness extends ContentContainerComponentHarness {
+    /** Selector used to locate option instances. */
+    static hostSelector: string;
+    /** Element containing the option's text. */
+    private _text;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for an option with specific attributes.
+     * @param options Options for filtering which option instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with<T extends MatOptionHarness>(this: ComponentHarnessConstructor<T>, options?: OptionHarnessFilters): HarnessPredicate<T>;
+    /** Clicks the option. */
+    click(): Promise<void>;
+    /** Gets the option's label text. */
+    getText(): Promise<string>;
+    /** Gets whether the option is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets whether the option is selected. */
+    isSelected(): Promise<boolean>;
+    /** Gets whether the option is active. */
+    isActive(): Promise<boolean>;
+    /** Gets whether the option is in multiple selection mode. */
+    isMultiple(): Promise<boolean>;
+}
+
+export { MatOptionHarness as M };
+export type { OptionHarnessFilters as O };

package/option-parent.d-CnYuuMkO.d.ts

@@ -0,0 +1,20 @@
+import { Signal, InjectionToken } from '@angular/core';
+
+/**
+ * Describes a parent component that manages a list of options.
+ * Contains properties that the options can inherit.
+ * @docs-private
+ */
+interface MatOptionParentComponent {
+    disableRipple?: boolean | Signal<boolean>;
+    multiple?: boolean;
+    inertGroups?: boolean;
+    hideSingleSelectionIndicator?: boolean;
+}
+/**
+ * Injection token used to provide the parent component to options.
+ */
+declare const MAT_OPTION_PARENT_COMPONENT: InjectionToken<MatOptionParentComponent>;
+
+export { MAT_OPTION_PARENT_COMPONENT as a };
+export type { MatOptionParentComponent as M };

package/option.d-BVGX3edu.d.ts

@@ -0,0 +1,146 @@
+import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewChecked, OnDestroy, ChangeDetectorRef, EventEmitter, ElementRef, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+
+/**
+ * Injection token that can be used to reference instances of `MatOptgroup`. It serves as
+ * alternative token to the actual `MatOptgroup` class which could cause unnecessary
+ * retention of the class and its component metadata.
+ */
+declare const MAT_OPTGROUP: InjectionToken<MatOptgroup>;
+/**
+ * Component that is used to group instances of `mat-option`.
+ */
+declare class MatOptgroup {
+    /** Label for the option group. */
+    label: string;
+    /** whether the option group is disabled. */
+    disabled: boolean;
+    /** Unique id for the underlying label. */
+    _labelId: string;
+    /** Whether the group is in inert a11y mode. */
+    _inert: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOptgroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatOptgroup, "mat-optgroup", ["matOptgroup"], { "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "mat-option, ng-container"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Event object emitted by MatOption when selected or deselected. */
+declare class MatOptionSelectionChange<T = any> {
+    /** Reference to the option that emitted the event. */
+    source: MatOption<T>;
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput: boolean;
+    constructor(
+    /** Reference to the option that emitted the event. */
+    source: MatOption<T>, 
+    /** Whether the change in the option's value was a result of a user action. */
+    isUserInput?: boolean);
+}
+/**
+ * Single option inside of a `<mat-select>` element.
+ */
+declare class MatOption<T = any> implements FocusableOption, AfterViewChecked, OnDestroy {
+    private _element;
+    _changeDetectorRef: ChangeDetectorRef;
+    private _parent;
+    group: MatOptgroup | null;
+    private _signalDisableRipple;
+    private _selected;
+    private _active;
+    private _disabled;
+    private _mostRecentViewValue;
+    /** Whether the wrapping component is in multiple selection mode. */
+    get multiple(): boolean | null | undefined;
+    /** Whether or not the option is currently selected. */
+    get selected(): boolean;
+    /** The form value of the option. */
+    value: T;
+    /** The unique ID of the option. */
+    id: string;
+    /** Whether the option is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether ripples for the option are disabled. */
+    get disableRipple(): boolean;
+    /** Whether to display checkmark for single-selection. */
+    get hideSingleSelectionIndicator(): boolean;
+    /** Event emitted when the option is selected or deselected. */
+    readonly onSelectionChange: EventEmitter<MatOptionSelectionChange<T>>;
+    /** Element containing the option's text. */
+    _text: ElementRef<HTMLElement> | undefined;
+    /** Emits when the state of the option changes and any parents have to be notified. */
+    readonly _stateChanges: Subject<void>;
+    constructor(...args: unknown[]);
+    /**
+     * Whether or not the option is currently active and ready to be selected.
+     * An active option displays styles as if it is focused, but the
+     * focus is actually retained somewhere else. This comes in handy
+     * for components like autocomplete where focus must remain on the input.
+     */
+    get active(): boolean;
+    /**
+     * The displayed value of the option. It is necessary to show the selected option in the
+     * select's trigger.
+     */
+    get viewValue(): string;
+    /** Selects the option. */
+    select(emitEvent?: boolean): void;
+    /** Deselects the option. */
+    deselect(emitEvent?: boolean): void;
+    /** Sets focus onto this option. */
+    focus(_origin?: FocusOrigin, options?: FocusOptions): void;
+    /**
+     * This method sets display styles on the option to make it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setActiveStyles(): void;
+    /**
+     * This method removes display styles on the option that made it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setInactiveStyles(): void;
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel(): string;
+    /** Ensures the option is selected when activated from the keyboard. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     */
+    _selectViaInteraction(): void;
+    /** Returns the correct tabindex for the option depending on disabled state. */
+    _getTabIndex(): string;
+    /** Gets the host DOM element. */
+    _getHostElement(): HTMLElement;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /** Emits the selection change event. */
+    private _emitSelectionChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatOption<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatOption<any>, "mat-option", ["matOption"], { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, ["mat-icon", "*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+/**
+ * Counts the amount of option group labels that precede the specified option.
+ * @param optionIndex Index of the option at which to start counting.
+ * @param options Flat list of all of the options.
+ * @param optionGroups Flat list of all of the option groups.
+ * @docs-private
+ */
+declare function _countGroupLabelsBeforeOption(optionIndex: number, options: QueryList<MatOption>, optionGroups: QueryList<MatOptgroup>): number;
+/**
+ * Determines the position to which to scroll a panel in order for an option to be into view.
+ * @param optionOffset Offset of the option from the top of the panel.
+ * @param optionHeight Height of the options.
+ * @param currentScrollPosition Current scroll position of the panel.
+ * @param panelHeight Height of the panel.
+ * @docs-private
+ */
+declare function _getOptionScrollPosition(optionOffset: number, optionHeight: number, currentScrollPosition: number, panelHeight: number): number;
+
+export { MatOption as M, _countGroupLabelsBeforeOption as _, MatOptgroup as a, MatOptionSelectionChange as b, _getOptionScrollPosition as c, MAT_OPTGROUP as d };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/material",
-  "version": "20.0.0-next.0",
+  "version": "20.0.0-next.10",
   "description": "Angular Material",
   "repository": {
     "type": "git",
@@ -353,7 +353,7 @@
     }
   },
   "peerDependencies": {
-    "@angular/cdk": "20.0.0-next.0",
+    "@angular/cdk": "20.0.0-next.10",
     "@angular/core": "^20.0.0-0 || ^20.1.0-0 || ^20.2.0-0 || ^20.3.0-0 || ^21.0.0-0",
     "@angular/common": "^20.0.0-0 || ^20.1.0-0 || ^20.2.0-0 || ^20.3.0-0 || ^21.0.0-0",
     "@angular/forms": "^20.0.0-0 || ^20.1.0-0 || ^20.2.0-0 || ^20.3.0-0 || ^21.0.0-0",
@@ -363,6 +363,9 @@
   "dependencies": {
     "tslib": "^2.3.0"
   },
+  "devDependencies": {
+    "@angular/cdk": "workspace:*"
+  },
   "schematics": "./schematics/collection.json",
   "ng-update": {
     "migrations": "./schematics/migration.json",

package/{core/tokens/m2/mat/_paginator.scss → paginator/_m2-paginator.scss}

@@ -1,9 +1,9 @@
 @use 'sass:math';
 @use 'sass:map';
-@use '../../token-definition';
-@use '../../../theming/theming';
-@use '../../../theming/inspection';
-@use '../../../style/sass-utils';
+@use '../core/tokens/m2-utils';
+@use '../core/theming/theming';
+@use '../core/theming/inspection';
+@use '../core/style/sass-utils';
 
 // The prefix used to generate the fully qualified name for tokens in this file.
 $prefix: (mat, paginator);
@@ -81,8 +81,8 @@ $prefix: (mat, paginator);
 @function get-token-slots() {
   @return sass-utils.deep-merge-all(
       get-unthemable-tokens(),
-      get-color-tokens(token-definition.$placeholder-color-config),
-      get-typography-tokens(token-definition.$placeholder-typography-config),
-      get-density-tokens(token-definition.$placeholder-density-config)
+      get-color-tokens(m2-utils.$placeholder-color-config),
+      get-typography-tokens(m2-utils.$placeholder-typography-config),
+      get-density-tokens(m2-utils.$placeholder-density-config)
   );
 }

package/{core/tokens/m3/mat/_paginator.scss → paginator/_m3-paginator.scss}

@@ -1,6 +1,9 @@
 @use 'sass:map';
-@use '../../../style/sass-utils';
-@use '../../token-definition';
+@use 'sass:list';
+@use '../core/style/sass-utils';
+@use '../core/tokens/m3-utils';
+@use '../core/theming/theming';
+@use '../core/theming/inspection';
 
 // The prefix used to generate the fully qualified name for tokens in this file.
 $prefix: (mat, paginator);
@@ -12,7 +15,7 @@ $prefix: (mat, paginator);
 /// @return {Map} A set of custom tokens for the mat-paginator
 @function get-tokens($systems, $exclude-hardcoded, $token-slots) {
   $tokens: sass-utils.merge-all(
-    token-definition.generate-typography-tokens($systems, container-text, body-small),
+    m3-utils.generate-typography-tokens($systems, container-text, body-small),
     (
       container-text-color: map.get($systems, md-sys-color, on-surface),
       container-background-color: map.get($systems, md-sys-color, surface),
@@ -23,5 +26,18 @@ $prefix: (mat, paginator);
     )
   );
 
-  @return token-definition.namespace-tokens($prefix, $tokens, $token-slots);
+  @return m3-utils.namespace($prefix, $tokens, $token-slots);
+}
+
+// Tokens that can be configured through Angular Material's density theming API.
+@function get-density-tokens($theme) {
+  $scale: theming.clamp-density(inspection.get-theme-density($theme), -5);
+  $index: ($scale * -1) + 1;
+
+  @return (
+    container-size: list.nth((56px, 52px, 48px, 40px, 40px, 40px), $index),
+    form-field-container-height: list.nth((40px, 40px, 40px, 40px, 40px, 36px), $index),
+    form-field-container-vertical-padding: list.nth((8px, 8px, 8px, 8px, 8px, 6px), $index),
+    touch-target-display: list.nth((block, block, none, none, none, none), $index),
+  );
 }