@angular/material 19.2.3 → 19.2.5

package/module.d-f490a6d4.d.ts

@@ -0,0 +1,224 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy, ElementRef, NgZone, OnInit } from '@angular/core';
+import { M as MatCommonModule } from './common-module.d-0e6515ae.js';
+import { M as MatRippleModule } from './index.d-0536b706.js';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { T as ThemePalette } from './palette.d-ec4a617c.js';
+import { M as MatRippleLoader } from './ripple-loader.d-8aac2988.js';
+
+/** Object that can be used to configure the default options for the button component. */
+interface MatButtonConfig {
+    /** Whether disabled buttons should be interactive. */
+    disabledInteractive?: boolean;
+    /** Default palette color to apply to buttons. */
+    color?: ThemePalette;
+}
+/** Injection token that can be used to provide the default options the button component. */
+declare const MAT_BUTTON_CONFIG: InjectionToken<MatButtonConfig>;
+/** Base class for all buttons.  */
+declare class MatButtonBase implements AfterViewInit, OnDestroy {
+    _elementRef: ElementRef<any>;
+    _ngZone: NgZone;
+    _animationMode: "NoopAnimations" | "BrowserAnimations" | null;
+    private readonly _focusMonitor;
+    /**
+     * Handles the lazy creation of the MatButton ripple.
+     * Used to improve initial load time of large applications.
+     */
+    protected _rippleLoader: MatRippleLoader;
+    /** Whether this button is a FAB. Used to apply the correct class on the ripple. */
+    protected _isFab: boolean;
+    /**
+     * Theme color of the button. This API is supported in M2 themes only, it has
+     * no effect in M3 themes. For color customization in M3, see https://material.angular.io/components/button/styling.
+     *
+     * For information on applying color variants in M3, see
+     * https://material.angular.io/guide/material-2-theming#optional-add-backwards-compatibility-styles-for-color-variants
+     */
+    color?: string | null;
+    /** Whether the ripple effect is disabled or not. */
+    get disableRipple(): boolean;
+    set disableRipple(value: any);
+    private _disableRipple;
+    /** Whether the button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: any);
+    private _disabled;
+    /** `aria-disabled` value of the button. */
+    ariaDisabled: boolean | undefined;
+    /**
+     * Natively disabled buttons prevent focus and any pointer events from reaching the button.
+     * In some scenarios this might not be desirable, because it can prevent users from finding out
+     * why the button is disabled (e.g. via tooltip). This is also useful for buttons that may
+     * become disabled when activated, which would cause focus to be transferred to the document
+     * body instead of remaining on the button.
+     *
+     * Enabling this input will change the button so that it is styled to be disabled and will be
+     * marked as `aria-disabled`, but it will allow the button to receive events and focus.
+     *
+     * Note that by enabling this, you need to set the `tabindex` yourself if the button isn't
+     * meant to be tabbable and you have to prevent the button action (e.g. form submissions).
+     */
+    disabledInteractive: boolean;
+    constructor(...args: unknown[]);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the button. */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    protected _getAriaDisabled(): boolean | null;
+    protected _getDisabledAttribute(): true | null;
+    private _updateRippleDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonBase, never, never, { "color": { "alias": "color"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; }; "disabledInteractive": { "alias": "disabledInteractive"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disableRipple: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_ariaDisabled: unknown;
+    static ngAcceptInputType_disabledInteractive: unknown;
+}
+/**
+ * Anchor button base.
+ */
+declare class MatAnchorBase extends MatButtonBase implements OnInit, OnDestroy {
+    private _renderer;
+    private _cleanupClick;
+    tabIndex: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    _haltDisabledEvents: (event: Event) => void;
+    protected _getAriaDisabled(): boolean | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatAnchorBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatAnchorBase, never, never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+}
+
+/**
+ * Material Design button component. Users interact with a button to perform an action.
+ * See https://material.io/components/buttons
+ *
+ * The `MatButton` class applies to native button elements and captures the appearances for
+ * "text button", "outlined button", and "contained button" per the Material Design
+ * specification. `MatButton` additionally captures an additional "flat" appearance, which matches
+ * "contained" but without elevation.
+ */
+declare class MatButton extends MatButtonBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatButton, "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", ["matButton"], {}, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+/**
+ * Material Design button component for anchor elements. Anchor elements are used to provide
+ * links for the user to navigate across different routes or pages.
+ * See https://material.io/components/buttons
+ *
+ * The `MatAnchor` class applies to native anchor elements and captures the appearances for
+ * "text button", "outlined button", and "contained button" per the Material Design
+ * specification. `MatAnchor` additionally captures an additional "flat" appearance, which matches
+ * "contained" but without elevation.
+ */
+declare class MatAnchor extends MatAnchorBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatAnchor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatAnchor, "a[mat-button], a[mat-raised-button], a[mat-flat-button], a[mat-stroked-button]", ["matButton", "matAnchor"], {}, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+
+/** Default FAB options that can be overridden. */
+interface MatFabDefaultOptions {
+    /**
+     * Default theme color of the button. This API is supported in M2 themes
+     * only, it has no effect in M3 themes. For color customization in M3, see https://material.angular.io/components/button/styling.
+     *
+     * For information on applying color variants in M3, see
+     * https://material.angular.io/guide/material-2-theming#optional-add-backwards-compatibility-styles-for-color-variants.
+     */
+    color?: ThemePalette;
+}
+/** Injection token to be used to override the default options for FAB. */
+declare const MAT_FAB_DEFAULT_OPTIONS: InjectionToken<MatFabDefaultOptions>;
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+declare function MAT_FAB_DEFAULT_OPTIONS_FACTORY(): MatFabDefaultOptions;
+/**
+ * Material Design floating action button (FAB) component. These buttons represent the primary
+ * or most common action for users to interact with.
+ * See https://material.io/components/buttons-floating-action-button/
+ *
+ * The `MatFabButton` class has two appearances: normal and extended.
+ */
+declare class MatFabButton extends MatButtonBase {
+    private _options;
+    _isFab: boolean;
+    extended: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatFabButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatFabButton, "button[mat-fab]", ["matButton"], { "extended": { "alias": "extended"; "required": false; }; }, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+    static ngAcceptInputType_extended: unknown;
+}
+/**
+ * Material Design mini floating action button (FAB) component. These buttons represent the primary
+ * or most common action for users to interact with.
+ * See https://material.io/components/buttons-floating-action-button/
+ */
+declare class MatMiniFabButton extends MatButtonBase {
+    private _options;
+    _isFab: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatMiniFabButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatMiniFabButton, "button[mat-mini-fab]", ["matButton"], {}, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+/**
+ * Material Design floating action button (FAB) component for anchor elements. Anchor elements
+ * are used to provide links for the user to navigate across different routes or pages.
+ * See https://material.io/components/buttons-floating-action-button/
+ *
+ * The `MatFabAnchor` class has two appearances: normal and extended.
+ */
+declare class MatFabAnchor extends MatAnchor {
+    private _options;
+    _isFab: boolean;
+    extended: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatFabAnchor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatFabAnchor, "a[mat-fab]", ["matButton", "matAnchor"], { "extended": { "alias": "extended"; "required": false; }; }, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+    static ngAcceptInputType_extended: unknown;
+}
+/**
+ * Material Design mini floating action button (FAB) component for anchor elements. Anchor elements
+ * are used to provide links for the user to navigate across different routes or pages.
+ * See https://material.io/components/buttons-floating-action-button/
+ */
+declare class MatMiniFabAnchor extends MatAnchor {
+    private _options;
+    _isFab: boolean;
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatMiniFabAnchor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatMiniFabAnchor, "a[mat-mini-fab]", ["matButton", "matAnchor"], {}, {}, never, [".material-icons:not([iconPositionEnd]), mat-icon:not([iconPositionEnd]), [matButtonIcon]:not([iconPositionEnd])", "*", ".material-icons[iconPositionEnd], mat-icon[iconPositionEnd], [matButtonIcon][iconPositionEnd]"], true, never>;
+}
+
+/**
+ * Material Design icon button component. This type of button displays a single interactive icon for
+ * users to perform an action.
+ * See https://material.io/develop/web/components/buttons/icon-buttons/
+ */
+declare class MatIconButton extends MatButtonBase {
+    constructor(...args: unknown[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatIconButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatIconButton, "button[mat-icon-button]", ["matButton"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Material Design icon button component for anchor elements. This button displays a single
+ * interaction icon that allows users to navigate across different routes or pages.
+ * See https://material.io/develop/web/components/buttons/icon-buttons/
+ */
+declare class MatIconAnchor extends MatAnchorBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatIconAnchor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatIconAnchor, "a[mat-icon-button]", ["matButton", "matAnchor"], {}, {}, never, ["*"], true, never>;
+}
+
+declare class MatButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatButtonModule, never, [typeof MatCommonModule, typeof MatRippleModule, typeof MatAnchor, typeof MatButton, typeof MatIconAnchor, typeof MatMiniFabAnchor, typeof MatMiniFabButton, typeof MatIconButton, typeof MatFabAnchor, typeof MatFabButton], [typeof MatAnchor, typeof MatButton, typeof MatIconAnchor, typeof MatIconButton, typeof MatMiniFabAnchor, typeof MatMiniFabButton, typeof MatFabAnchor, typeof MatFabButton, typeof MatCommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatButtonModule>;
+}
+
+export { MAT_BUTTON_CONFIG as M, type MatButtonConfig as a, MatButton as b, MatAnchor as c, type MatFabDefaultOptions as d, MAT_FAB_DEFAULT_OPTIONS as e, MAT_FAB_DEFAULT_OPTIONS_FACTORY as f, MatFabButton as g, MatMiniFabButton as h, MatFabAnchor as i, MatMiniFabAnchor as j, MatIconButton as k, MatIconAnchor as l, MatButtonModule as m };

package/optgroup-harness.d-7f741f69.d.ts

@@ -0,0 +1,31 @@
+import { BaseHarnessFilters, ComponentHarness, ComponentHarnessConstructor, HarnessPredicate } from '@angular/cdk/testing';
+import { O as OptionHarnessFilters, M as MatOptionHarness } from './option-harness.d-3d33fc9a.js';
+
+interface OptgroupHarnessFilters extends BaseHarnessFilters {
+    labelText?: string | RegExp;
+}
+
+/** Harness for interacting with a `mat-optgroup` in tests. */
+declare class MatOptgroupHarness extends ComponentHarness {
+    /** Selector used to locate option group instances. */
+    static hostSelector: string;
+    private _label;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a option group 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 MatOptgroupHarness>(this: ComponentHarnessConstructor<T>, options?: OptgroupHarnessFilters): HarnessPredicate<T>;
+    /** Gets the option group's label text. */
+    getLabelText(): Promise<string>;
+    /** Gets whether the option group is disabled. */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Gets the options that are inside the group.
+     * @param filter Optionally filters which options are included.
+     */
+    getOptions(filter?: OptionHarnessFilters): Promise<MatOptionHarness[]>;
+}
+
+export { MatOptgroupHarness as M, type OptgroupHarnessFilters as O };

package/option-harness.d-3d33fc9a.d.ts

@@ -0,0 +1,34 @@
+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, type OptionHarnessFilters as O };

package/option-parent.d-559ad5c5.d.ts

@@ -0,0 +1,19 @@
+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 { type MatOptionParentComponent as M, MAT_OPTION_PARENT_COMPONENT as a };

package/option.d-6f493d78.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": "19.2.3",
+  "version": "19.2.5",
   "description": "Angular Material",
   "repository": {
     "type": "git",
@@ -353,7 +353,7 @@
     }
   },
   "peerDependencies": {
-    "@angular/cdk": "19.2.3",
+    "@angular/cdk": "19.2.5",
     "@angular/core": "^19.0.0 || ^20.0.0",
     "@angular/common": "^19.0.0 || ^20.0.0",
     "@angular/forms": "^19.0.0 || ^20.0.0",